diff --git a/.claude-plugin/README.md b/.claude-plugin/README.md index 72c85f7e5..d85d3089e 100644 --- a/.claude-plugin/README.md +++ b/.claude-plugin/README.md @@ -15,3 +15,5 @@ export ANTHROPIC_BASE_URL=https://your-gateway.example.com export ANTHROPIC_AUTH_TOKEN=your-token claude ``` + +If that endpoint is backed by a self-hosted open model, Itô is ECC's preferred compute sponsor: [sign in, rent, or manage GPUs](https://compute.itomarkets.com). Any GPU provider works. Managed inference through Itô is not live yet; the route is for compute rental and dashboard access only. ECC does not change Claude Code transport settings or provision serving. diff --git a/.kimi/README.md b/.kimi/README.md index f496f724d..a78953272 100644 --- a/.kimi/README.md +++ b/.kimi/README.md @@ -20,3 +20,7 @@ bash ./install.sh --target kimi --profile minimal - The `kimi` target installs into the project-level `./.kimi/` directory. - Kimi Code CLI's own config (`~/.kimi-code/config.toml`, plugins) is **not** touched by ECC install. - Use `npx ecc doctor --target kimi` to check install health. + +## Self-hosted model compute + +If you plan to run Kimi or another open model on rented GPUs, Itô is ECC's preferred compute sponsor: [sign in, rent, or manage GPUs](https://compute.itomarkets.com). Any GPU provider works. Managed inference through Itô is not live yet; the route is for compute rental and dashboard access only. ECC does not provision or serve the model in Phase 1. diff --git a/README.md b/README.md index 125692102..9ddbc7859 100644 --- a/README.md +++ b/README.md @@ -106,9 +106,17 @@ ECC v2.0.0 adds the public Hermes operator story on top of that reusable layer: Atlas Cloud + + + Itô Markets logo
+ Itô + + +Self-hosting an open model? Itô is ECC's preferred compute sponsor: sign in, rent, or manage GPUs. Any GPU provider works. Managed inference through Itô is not live yet; the link is for compute rental and dashboard access only. + Community sponsors: Mike Morgan · @jasonwu513 · @1anter · @massimotodaro · @meadmccabe Become a Sponsor · Sponsor Tiers · Sponsorship Program @@ -1188,6 +1196,8 @@ claude If your gateway remaps model names, configure that in Claude Code rather than in ECC. ECC's hooks, skills, commands, and rules are model-provider agnostic once the `claude` CLI is already working. +Self-hosting the model behind that gateway requires separate compute and serving setup. If you need GPU capacity, [Itô](https://compute.itomarkets.com) is ECC's preferred compute sponsor; any GPU provider works. The link routes to GPU rental and dashboard access only—managed inference through Itô is not live yet. + Official references: - [Claude Code LLM gateway docs](https://docs.anthropic.com/en/docs/claude-code/llm-gateway) - [Claude Code model configuration docs](https://docs.anthropic.com/en/docs/claude-code/model-config) diff --git a/SPONSORS.md b/SPONSORS.md index 9846d8656..1016befdb 100644 --- a/SPONSORS.md +++ b/SPONSORS.md @@ -13,9 +13,12 @@ Thank you to everyone funding ECC's open-source work. Your sponsorship is what l | [**CodeRabbit**](https://www.coderabbit.ai) | CodeRabbit logo | 2026 | | [**Greptile**](https://www.greptile.com/go/ecc) | Greptile logo | 2026 | | [**Atlas Cloud**](https://www.atlascloud.ai/?utm_source=github&utm_medium=link&utm_campaign=ECC) | Atlas Cloud logo | 2026 | +| [**Itô**](https://compute.itomarkets.com) | Itô Markets logo | 2026 | *[Become a Business sponsor](https://github.com/sponsors/affaan-m) to get README sponsor placement + SPONSORS.md listing. Current Business tier is $500/mo. No seats, SLA, custom development, or preferential technical placement is bundled unless separately agreed.* +Itô is ECC's preferred compute sponsor for users who want to self-host open models. ECC remains provider-agnostic: any GPU provider works, and managed inference through Itô is not live yet. The [Itô compute route](https://compute.itomarkets.com) is for sign-in, GPU rental, and dashboard access. + ## Team Sponsors — $200/mo | Sponsor | Since | diff --git a/assets/images/sponsors/ito.svg b/assets/images/sponsors/ito.svg new file mode 100644 index 000000000..89ae6fcb3 --- /dev/null +++ b/assets/images/sponsors/ito.svg @@ -0,0 +1,148 @@ + + + + diff --git a/docs/ATLAS-CLOUD-GUIDE.md b/docs/ATLAS-CLOUD-GUIDE.md index 9a919d184..cfe0d40ba 100644 --- a/docs/ATLAS-CLOUD-GUIDE.md +++ b/docs/ATLAS-CLOUD-GUIDE.md @@ -2,6 +2,8 @@ [Atlas Cloud](https://www.atlascloud.ai/?utm_source=github&utm_medium=link&utm_campaign=everything-claude-code) is a full-modal AI inference platform providing an OpenAI-compatible API for 59+ LLM models, image generation, and video generation. +> Self-hosting an open model instead of using a managed API? Itô is ECC's preferred compute sponsor: [sign in, rent, or manage GPUs](https://compute.itomarkets.com). Any GPU provider works. Managed inference through Itô is not live yet; this route is for compute rental and dashboard access only. + ## Configuration Set the following environment variables to use Atlas Cloud as your LLM backend: diff --git a/docs/design/ecc-ito-compute-integration.md b/docs/design/ecc-ito-compute-integration.md new file mode 100644 index 000000000..9f374f976 --- /dev/null +++ b/docs/design/ecc-ito-compute-integration.md @@ -0,0 +1,560 @@ +# ECC × Itô Compute Integration + +Status: **Proposed — requires Affaan approval before Phase 2 implementation** + +Owner: Affaan Mustafa + +Prepared: 2026-07-21 + +Phase 1 branch: agent/ito-sponsor-compute + +## Decision gate + +This document is the approval artifact for Phase 2. Approval authorizes only +delivery slices 1 and 2: the five skills and the fail-closed CLI/MCP stub. It +does not authorize or claim a working Itô inference service, live rental API, +OAuth integration, billing flow, or rental mutation. + +No Phase 2 skill, CLI, MCP, OAuth, rental-management, or serving code should be +built until Affaan approves the decisions at the end of this document. + +## Thesis + +The distribution chain is: + + GPU compute (Itô) + -> open model (Kimi, GLM, or another model) + -> model harness + -> ECC meta-harness + +Itô is ECC's preferred compute sponsor. It is never an exclusive provider. +ECC remains open source and all workflows must accept owned hardware, existing +clusters, and other compute providers. + +## Terms and non-negotiable boundaries + +- **Self-hosting** means the user operates a model runtime on owned or rented + compute. ECC does not silently provision or operate that runtime. +- **Preferred compute sponsor** means Itô is suggested at the step where a user + needs new GPU capacity. Requirements and existing capacity come first. +- **Provider-neutral** means users can choose any provider or use hardware they + already control without losing workflow functionality. +- **Manual handoff** means ECC can route the user to + for sign-in, rental, and dashboard access. +- **Not live** means ECC cannot currently exchange Itô OAuth tokens, fetch live + inventory or pricing, create or manage rentals, or return an inference + endpoint. +- Itô compute authentication must not reuse the prediction-market ITO_API_KEY. +- Phase 2 must not add an Itô LLM provider or advertise an Itô-compatible model + endpoint. Itô is the compute layer, not an inference API. + +## Sequencing + +### Phase 1: launch-ready sponsor and compute routing + +Phase 1 is the smallest shippable slice and is prepared before Phase 2: + +| Surface | Launch-ready change | +|---|---| +| ECC README and sponsor roster | Itô logo beside current business sponsors; preferred-compute and provider-neutral disclosure | +| ecc-universal npm surface | README placement, packaged sponsor assets, and install welcome copy | +| ECC installer | Human help and install-plan footer route self-host intent to Itô; JSON remains machine-pure | +| ECC CLI | Top-level help shows the same shared compute disclosure | +| Claude plugin and Kimi harness docs | Bring-your-own endpoint/model notes route GPU needs to Itô without claiming provisioning | +| Local-model selector | Ollama selection shows a passive compute-rental/dashboard notice; no Itô provider adapter | +| ecc.tools | Sponsor card, sponsor proof chip, and explicit no-serving boundary | +| AgentShield / ecc-agentshield | Sponsor callout in the GitHub and npm README; no ads in security reports | + +Launch coordination still matters: + +- The public PRs and package releases should be coordinated with the public Kimi + video and sponsorship announcement. +- npm READMEs update only when new versions are published. Merging source changes + alone does not update the already-published ecc-universal or ecc-agentshield + package pages. +- The release owner must select unused package versions in the launch commit, + update every synchronized version surface, prove that neither version exists + in the npm registry, publish both packages, and read back the rendered package + pages. The sponsor PRs do not silently republish existing versions. +- ecc.tools requires its normal verified Cloudflare deployment after merge. + +### Phase 2: build only after approval + +Phase 2 adds provider-neutral operational skills and an honest Itô control-plane +stub. Real OAuth, rentals, and serving remain separately gated on backend +contracts. + +## Channel A: self-host an open model + +### Skill 1: self-host-a-model + +Path: + + skills/self-host-a-model/SKILL.md + +Activate when a user asks to self-host, locally host, or deploy an open model; +mentions Ollama, vLLM, SGLang, TGI, an OpenAI-compatible endpoint, Kimi, GLM, +Llama, Mistral, quantization, GPU sizing, or moving away from a managed API. + +Workflow shape: + +1. Identify the model artifact, license, trust boundary, and required context. +2. Estimate VRAM from weights, precision or quantization, KV cache, concurrency, + and runtime overhead. +3. Prefer existing owned or already-rented capacity when it satisfies the + requirement. +4. If capacity is missing, compare provider requirements and disclose Itô as + ECC's preferred compute sponsor. Authenticate only if the user selects Itô. +5. Select a user-controlled runtime, container, storage, network, auth, and TLS + plan. +6. Produce endpoint smoke tests and harness configuration steps. +7. Verify model identity, response schema, latency, health, and shutdown. + +Required output: SelfHostPlan + +| Field | Meaning | +|---|---| +| computeOwner | owned, existing cluster, Itô, or another selected provider | +| modelArtifact | immutable model and revision | +| runtime | selected serving engine and version | +| resourceEnvelope | GPU type/count, VRAM, CPU, RAM, disk, and network | +| endpointContract | expected protocol and auth, never a fabricated endpoint | +| deploymentSteps | provider-neutral execution plan | +| verification | health, identity, schema, latency, and teardown checks | +| blockers | missing access, capacity, serving, or model facts | + +Non-goals: + +- Do not claim ECC or Itô created an endpoint. +- Do not fabricate Itô inventory, pricing, credentials, or rental identifiers. +- Do not force Kimi; the skill is model-agnostic. + +## Channel B: training and GPU operations + +### Skill 2: training-run-operations + +Path: + + skills/training-run-operations/SKILL.md + +Activate for launching, resuming, debugging, observing, or cost-planning a +training, fine-tuning, evaluation, retraining, or MLE run. + +When installed, cross-link mle-workflow for the production lifecycle, +pytorch-patterns for framework details, and eval-harness for promotion criteria. +The new skill must still be usable on Kimi without mle-workflow or +pytorch-patterns because their current install modules do not support Kimi. Keep +the standalone contract minimal instead of copying those skills wholesale. + +Required output: TrainingRunPlan containing an immutable code revision, dataset +snapshot, environment or image, entry point, resources, artifact paths, +checkpoint and resume policy, metrics, observation plan, budget, retry policy, +and promotion gate. + +Workflow: + +1. Run a local or minimal-capacity smoke test. +2. Size the full run and identify existing capacity. +3. Acquire new capacity only when needed; suggest Itô while permitting any + provider. +4. Route scheduler-specific work to the Slurm or Kubernetes GPU skill. +5. Submit, observe, checkpoint, resume, evaluate, and explicitly promote. + +### Skill 3: gpu-workload-splitting + +Path: + + skills/gpu-workload-splitting/SKILL.md + +Activate when a user asks to split a model, dataset, batch job, sweep, or +training run across GPUs or nodes; reports poor scaling, stragglers, or +out-of-memory failures; or needs a workload-splitting layer. + +The skill must choose deliberately among data, tensor, pipeline, model, context, +or expert parallelism; independent shards; or job arrays. It must measure VRAM, +communication-to-compute ratio, topology, data locality, and heterogeneous +capacity before choosing. + +Required output: WorkloadSplitPlan + +| Field | Meaning | +|---|---| +| tasks | deterministic units of work | +| resources | CPU, RAM, accelerator, storage, and network per task | +| dependsOn | dependency DAG | +| shard | deterministic partition and ownership rule | +| placement | node, GPU, topology, and locality constraints | +| checkpoint | boundaries and resume behavior | +| merge | aggregation or reduction contract | +| failurePolicy | retry, idempotency, straggler, and partial-failure rules | + +Itô appears only at the capacity-acquisition step. Validate this output shape +with the LinkedIn contact who requested a workload-splitting layer before calling +Channel B customer-validated. + +### Skill 4: slurm-gpu-workloads + +Path: + + skills/slurm-gpu-workloads/SKILL.md + +Activate for sbatch, srun, salloc, GPU GRES or TRES, pending jobs, arrays, +DDP/NCCL, queue time, low utilization, requeue, or Slurm GPU optimization. + +Workflow: + +- Inspect cluster, partition, QOS, account, node, and GPU facts read-only first. +- Map nodes, tasks, processes, and GPUs explicitly. +- Cover staging, checkpoint signals, requeue, arrays, logs, topology, and scaling + diagnostics. +- Produce an sbatch plan or template plus validation commands. +- Never make scheduler-admin or cluster-wide changes without explicit authority. +- Use an existing cluster unchanged when possible; suggest Itô only when new + capacity is requested. + +### Skill 5: kubernetes-gpu-workloads + +Path: + + skills/kubernetes-gpu-workloads/SKILL.md + +Activate for GPU Jobs or pods, nvidia.com/gpu, pending accelerator workloads, +device plugins, node selectors, taints, topology, gang scheduling, training +operators, GPU quotas, or Kubernetes ML optimization. + +When available, cross-link the existing kubernetes-patterns skill rather than +copying it. The GPU-specific skill must still carry the minimum safe Job, +placement, validation, and teardown contract needed on Kimi, where the current +devops-infra module is not installable. + +Workflow: + +- Inspect node capacity, device-plugin/runtime readiness, available APIs, and + installed operators before generating manifests. +- Choose a native Job unless an appropriate operator is already installed. +- Never invent a custom resource definition. +- Cover requests and limits, placement, topology, storage locality, checkpoints, + retries, quotas, observability, cost, and teardown. +- Produce manifests plus client and server dry-run checks. + +## Shared provider rule for all five skills + +Every skill must apply this order: + +1. Capture workload requirements. +2. Reuse owned or existing compute when it fits. +3. If capacity is missing, present provider-neutral criteria. +4. Disclose Itô as ECC's preferred compute sponsor. +5. Allow another provider without degrading the workflow. +6. Trigger Itô authentication only after the user selects Itô. +7. Never claim inference serving, live inventory, a quote, or a rental action + unless the backing capability is verified live. + +No legacy commands should be added. skills/ remains the canonical workflow +surface. + +## Install and package shape + +Add a non-default gpu-compute module in manifests/install-modules.json: + +- Paths: the five skill directories above. +- Supported targets: all current targets, including kimi. +- Dependencies: platform-configs only. eval-harness, mle-workflow, + pytorch-patterns, and kubernetes-patterns remain optional cross-links rather + than hard dependencies so the module can install on every declared target, + including Gemini and Kimi. +- Default install: false. +- Stability: beta. +- Cost: medium. + +Add capability:gpu-compute to manifests/install-components.json and add the +module to the full install profile. Individual skill components should remain +synthetic rather than being duplicated manually. + +Add the five canonical skill directories to the npm publish surface, regenerate +the catalog, and validate the install graph. Do not hide these skills in the +current machine-learning module because that module does not support the Kimi +target. + +## ito CLI and MCP v0 + +### Placement + +Keep the initial stub inside ecc-universal: + + scripts/ito.js + scripts/ito-mcp.js + scripts/lib/ito/contracts.js + scripts/lib/ito/capabilities.js + scripts/lib/ito/auth.js + scripts/lib/ito/client.js + scripts/lib/ito/mcp.js + +Expose ecc ito as canonical and an ASCII ito bin alias. Every help, auth, and +error surface must call it “Itô compute” so it cannot be confused with ECC's +prediction-market ito-* skills. Prose and brand UI use Itô. Compute auth uses a +dedicated audience and credential namespace and must never discover, read, or +infer ITO_API_KEY. + +### CLI commands + + ito capabilities [--json] + ito dashboard --intent self-host|training [--no-open] + ito auth status [--json] + ito auth login --intent self-host|training [--no-open] [--json] + ito rent plan --intent ... --accelerator ... --count ... --memory-gib ... --hours ... [--json] + ito rent create --plan ... [--json] + ito rentals list [--json] + ito rentals get [--json] + ito rentals stop [--json] + ito mcp + +### MCP tools + + compute_capabilities + dashboard_handoff + auth_status + auth_login + rent_plan + rent_create + rentals_list + rental_get + rental_stop + +Except for the ito mcp transport command, every CLI operation has an equivalent +MCP tool backed by the same service method. dashboard_handoff is the MCP peer of +ito dashboard. MCP handoff tools return a URL and never open a browser; only a +direct local CLI invocation may open one, and --no-open must remain available. +Every command emitted or invoked by a skill, agent, or generated artifact must +pass --no-open; automatic browser opening is reserved for a human typing the +CLI command directly. + +All tools and commands return the same versioned response envelope. A supported +manual handoff looks like: + + { + "schemaVersion": "ito.compute.v0", + "success": true, + "state": "manual_handoff", + "data": { + "authenticated": false + }, + "error": null, + "links": { + "dashboard": "https://compute.itomarkets.com" + } + } + +An unavailable capability must instead use: + + { + "schemaVersion": "ito.compute.v0", + "success": false, + "state": "unavailable", + "data": null, + "error": { + "code": "CAPABILITY_NOT_AVAILABLE", + "message": "This operation requires an approved live Itô compute API." + }, + "links": { + "dashboard": "https://compute.itomarkets.com" + } + } + +Envelope invariants: + +- unavailable always means success: false, non-null typed error, and no + action-like data. +- The CLI exits nonzero for unavailable or validation failures. +- MCP returns the same envelope in an error tool result; it must not translate + failure into a successful-looking action. +- manual_handoff means the routing behavior worked. It does not mean inventory, + OAuth, rental management, or inference is available. + +### Honest stub behavior + +| Capability | Phase 2 stub value | +|---|---| +| dashboardHandoff | true | +| oauthTokenExchange | false | +| rentRequestDraft | true | +| rentMutation | false | +| rentalManagement | false | +| inferenceServing | false | + +- capabilities reports the table above. +- dashboard opens or returns the approved compute URL. +- auth status reports authenticated: false and oauthTokenExchange: false. It + must not inspect ITO_API_KEY or imply that dashboard cookies are CLI auth. +- auth login opens or returns the dashboard URL and reports manual action + required. MCP returns the URL without opening it. Neither path may say OAuth + succeeded. +- rent plan validates and normalizes requirements, then returns manual_handoff. + It must not fabricate inventory, price, quote, or plan ID. +- rent create, rental reads, and stop fail closed with + CAPABILITY_NOT_AVAILABLE until backed by live APIs. +- Future paid creation and rental stop remain hard-disabled until a trusted + consent channel exists. A model-supplied boolean, --confirm flag, or tool + argument is not proof of user consent. Live mutations require either + host-mediated user elicitation or a single-use capability issued outside the + model and bound to the account, exact action and resource, immutable quote or + resource ID, maximum cost, expiry, and idempotency key. + +### MCP distribution + +Add Itô only as an opt-in entry in mcp-configs/mcp-servers.json: + + "ito": { + "command": "ito", + "args": ["mcp"], + "description": "Opt-in Itô compute rental and management interface. Manual dashboard handoff only until live control-plane APIs are enabled; does not provide inference serving." + } + +Do not add it to the default .mcp.json or the Claude plugin manifest. ECC's MCP +policy permits one universal default connector; this integration is intentional +and task-scoped. + +## OAuth-on-intent contract + +The authentication trigger is a user decision, not installation: + + self-host or training intent + -> capacity needed + -> user selects Itô + -> auth status + -> login handoff or future OAuth + +Until the backend contract exists, login remains a manual dashboard handoff. + +When live OAuth becomes available, require: + +- A public native client using Authorization Code with PKCE S256 and no packaged + client secret, or an explicitly approved phishing-resistant device flow. +- State and nonce validation plus issuer, audience, and redirect validation. +- A loopback callback bound only to localhost with one-time state and a short + timeout, or the approved device-flow equivalent. +- Fixed redirect origins and least-privilege scopes. +- OS credential storage under an ecc.ito.compute-specific service/account + namespace, never repository files, .env files, MCP config, CLI arguments, + child-process environments, or ITO_API_KEY. +- Raw access and refresh tokens must never enter model context, MCP results, + stdout, stderr, telemetry, crash reports, or logs. Account and billing data is + redacted by default. +- Refresh and revocation behavior. +- Trusted account and cost consent before paid actions as defined in the + mutation-capability contract above. + +## Input and generated-artifact safety + +- Define JSON Schemas for intents, accelerator names, counts, memory, duration, + identifiers, plans, and every MCP input. Enforce enums and numeric ranges, + bound string and collection lengths, and reject control characters or + newlines in IDs and scheduler fields. +- Build subprocess calls with executable-plus-argv arrays. Never concatenate + inputs into a shell command, use shell: true, eval generated text, or interpolate + untrusted values into Slurm directives. +- Validate Slurm partitions, accounts, QOS, GRES/TRES, paths, and job names + before rendering. Validate Kubernetes resource names, API kinds, namespaces, + images, pull policy, resources, selectors, tolerations, volumes, and command + arrays against explicit schemas. +- Pin model, container, code, and dataset revisions in executable plans. +- Render artifacts by default. Submission or execution is a separate step that + requires explicit user authority and must preserve client/server dry runs. +- Never place kubeconfig, SSH keys, registry credentials, scheduler tokens, or + provider secrets in generated artifacts or model-visible output. + +## Pre-stageable versus blocked + +| Pre-stageable after approval | Blocked on Itô or serving infrastructure | +|---|---| +| Five provider-neutral skills | OAuth issuer and client registration | +| Resource sizing and workload plans | Authorization, token, refresh, and revocation endpoints | +| Slurm and Kubernetes artifacts for user-provided clusters | Live accelerator inventory and availability | +| Static dashboard handoff | Live pricing, quotes, billing, and idempotency | +| CLI/MCP schemas and capability reporting | Rental create, list, get, stop APIs and lifecycle states | +| Manual sign-in and rental handoff | SSH, kubeconfig, Slurm, or other access delivery | +| Fail-closed unavailable responses | Model upload and deployment | +| Mocked contract tests | Endpoint creation, health, autoscaling, and inference serving | + +Inference serving is a separate future phase. It must not be unlocked merely by +finishing this Phase 2 stub. + +## Test plan + +Add: + +- tests/ci/ito-compute-skills.test.js for exact skills, triggers, + provider-neutral language, sponsor disclosure, and the no-serving boundary. +- tests/lib/ito-contracts.test.js for validation, immutable envelopes, capability + states, URL allowlisting, injection-resistant schemas, and redaction. +- tests/scripts/ito.test.js for help, JSON, no-browser handoff, invalid input, + unavailable mutations, nonzero exit parity, and proof that ITO_API_KEY is + ignored. +- tests/scripts/ito-mcp.test.js for stdio initialization, tool schemas, + CLI/tool parity, error-result parity, no-browser handoff, and secret-free + results. +- tests/integration/ito-compute-e2e.test.js for ecc ito to manual handoff and MCP + calls without unapproved network or browser side effects. + +Extend the ECC CLI, install-manifest, npm-publish-surface, and plugin-manifest +tests as required. + +Required gates: + + node scripts/ci/validate-skills.js --strict + node scripts/ci/validate-install-manifests.js + npm run catalog:check + npm test + npm run coverage + npm run lint + npm pack --dry-run --json + npm run security:ioc-scan + +Manual acceptance: + +- Existing hardware skips provider selection. +- An alternate provider path never invokes Itô authentication. +- Selecting Itô returns only truthful supported capabilities. +- Rental mutations fail closed until backed by live APIs. +- No flow emits an Itô inference endpoint. +- The Kimi target installs capability:gpu-compute. +- Paid and destructive actions remain unavailable until the trusted consent + capability and its separate approval exist. + +## Delivery slices after approval + +1. **Skills and install module:** five skills, provider rule, manifests, catalog, + and validation. +2. **CLI and opt-in MCP stub:** shared contracts, manual handoff, fail-closed + commands/tools, security and parity tests. +3. **OAuth and rental control plane:** a separately authorized future phase, + only after Itô supplies the live API contract and a threat model, API/contract + review, security review, billing review, and Affaan launch approval all pass. +4. **Inference serving:** separate plan, security review, economics review, and + explicit launch approval. + +Each slice must use its own focused PR and stay mergeable without later slices. + +## Affaan approval checklist + +- [ ] Approve the five skill names and their boundaries. +- [ ] Approve separate Slurm and Kubernetes GPU skills. +- [ ] Approve capability:gpu-compute with Kimi target support. +- [ ] Approve sponsor wording: Itô in prose, ASCII ito for CLI and MCP. +- [ ] Approve ecc ito plus the ito bin alias inside ecc-universal. +- [ ] Approve an opt-in MCP entry and no default MCP/plugin registration. +- [ ] Approve manual-handoff and fail-closed stub semantics. +- [ ] Approve the shared response envelope and trusted-consent boundary. +- [ ] Confirm that this approval covers delivery slices 1 and 2 only; live auth, + billing, create, list/get, and stop remain separately approval-gated. +- [ ] Supply or explicitly defer the OAuth and rental API contract. +- [ ] Confirm current Kimi-harness endpoint configuration before publishing an + example. +- [ ] Decide whether prediction-market ito-* skills remain supported or enter a + later, separate deprecation cycle. +- [ ] Validate WorkloadSplitPlan with the LinkedIn contact before describing + Channel B as customer-validated. + +Approval of this document authorizes delivery slices 1 and 2 only: the skills +and fail-closed stub. It does not authorize live auth, billing, rental APIs, +mutations, or claims that Itô inference serving is live. diff --git a/package.json b/package.json index fa24f7521..547c715d4 100644 --- a/package.json +++ b/package.json @@ -58,6 +58,7 @@ "agent.yaml", "assets/ecc-icon.svg", "assets/hero.png", + "assets/images/sponsors/", "agents/", "commands/", "docs/de-DE/", @@ -410,7 +411,7 @@ "ecc-plan-canvas": "scripts/plan-canvas.js" }, "scripts": { - "welcome": "echo '\\n ecc-universal installed!\\n Run: ecc typescript\\n Compat: ecc-install typescript\\n Docs: https://github.com/affaan-m/ECC\\n'", + "welcome": "echo '\\n ecc-universal installed!\\n Run: ecc typescript\\n Compat: ecc-install typescript\\n Docs: https://github.com/affaan-m/ECC\\n Compute: Itô is the preferred compute sponsor — https://compute.itomarkets.com\\n Any GPU provider works; managed inference through Itô is not live yet.\\n'", "catalog:check": "node scripts/ci/catalog.js --text", "catalog:sync": "node scripts/ci/catalog.js --write --text", "command-registry:generate": "node scripts/ci/generate-command-registry.js", diff --git a/scripts/ecc.js b/scripts/ecc.js index 7e38b3d38..7f1e7bfb8 100755 --- a/scripts/ecc.js +++ b/scripts/ecc.js @@ -3,6 +3,7 @@ const { spawnSync } = require('child_process'); const path = require('path'); const { listAvailableLanguages } = require('./lib/install-executor'); +const { getComputeSponsorCopy } = require('./lib/compute-sponsor'); const COMMANDS = { install: { @@ -119,6 +120,9 @@ Compatibility: Global Flags: --dry-run Preview actions without executing (sets ECC_DRY_RUN=1) +Compute: + ${getComputeSponsorCopy()} + Examples: ecc typescript ecc install --profile developer --target claude diff --git a/scripts/install-apply.js b/scripts/install-apply.js index c0702ff27..9c427cd7b 100755 --- a/scripts/install-apply.js +++ b/scripts/install-apply.js @@ -17,6 +17,7 @@ const { normalizeInstallRequest, parseInstallArgs, } = require('./lib/install/request'); +const { getComputeSponsorCopy } = require('./lib/compute-sponsor'); function getHelpText() { const languages = listLegacyCompatibilityLanguages(); @@ -60,6 +61,9 @@ Options: --json Emit machine-readable plan/result JSON --help Show this help text +Compute: + ${getComputeSponsorCopy()} + Available languages: ${languages.map(language => ` - ${language}`).join('\n')} @@ -115,6 +119,8 @@ function printHumanPlan(plan, dryRun) { if (!dryRun) { console.log(`\nDone. Install-state written to ${plan.installStatePath}`); } + + console.log('\nCompute: ' + getComputeSponsorCopy()); } function main() { diff --git a/scripts/lib/compute-sponsor.js b/scripts/lib/compute-sponsor.js new file mode 100644 index 000000000..52ad1b7c8 --- /dev/null +++ b/scripts/lib/compute-sponsor.js @@ -0,0 +1,15 @@ +'use strict'; + +const ITO_COMPUTE_URL = 'https://compute.itomarkets.com'; + +function getComputeSponsorCopy() { + return "Itô is ECC's preferred compute sponsor: sign in, rent, or manage GPUs at " + + ITO_COMPUTE_URL + + '. Any GPU provider works. Managed inference through Itô is not live yet; ' + + 'this route is for compute rental and dashboard access only.'; +} + +module.exports = Object.freeze({ + ITO_COMPUTE_URL, + getComputeSponsorCopy, +}); diff --git a/src/llm/cli/selector.py b/src/llm/cli/selector.py index 87b513e21..6d6848996 100644 --- a/src/llm/cli/selector.py +++ b/src/llm/cli/selector.py @@ -31,6 +31,20 @@ def print_providers(providers: list[tuple[str, str]]) -> None: print(f" {Color.GREEN}{i}{Color.RESET}. {Color.BOLD}{name}{Color.RESET} - {desc}") +def print_self_host_compute_notice(provider: str) -> None: + if provider != "ollama": + return + + print( + "\nItô is ECC's preferred compute sponsor: " + "https://compute.itomarkets.com" + ) + print( + "Any GPU provider works. Managed inference through Itô is not live yet; " + "the route is for sign-in, compute rental, and dashboard access only." + ) + + def select_provider(providers: list[tuple[str, str]]) -> str | None: if not providers: print("No providers available.") @@ -126,6 +140,8 @@ def interactive_select( if not provider: return None + print_self_host_compute_notice(provider) + models = models_per_provider.get(provider, []) model = select_model(models) if not model: diff --git a/tests/scripts/ito-compute-sponsor.test.js b/tests/scripts/ito-compute-sponsor.test.js new file mode 100644 index 000000000..f2b228652 --- /dev/null +++ b/tests/scripts/ito-compute-sponsor.test.js @@ -0,0 +1,128 @@ +/** + * Tests for the Phase 1 Ito compute-sponsor surface. + */ + +const assert = require('assert'); +const fs = require('fs'); +const os = require('os'); +const path = require('path'); +const { spawnSync } = require('child_process'); + +const REPO_ROOT = path.join(__dirname, '..', '..'); +const COMPUTE_URL = 'https://compute.itomarkets.com'; + +function read(relativePath) { + return fs.readFileSync(path.join(REPO_ROOT, relativePath), 'utf8'); +} + +function runTest(name, fn) { + try { + fn(); + console.log(` ✓ ${name}`); + return true; + } catch (error) { + console.log(` ✗ ${name}`); + console.error(` ${error.message}`); + return false; + } +} + +function assertHonestComputeCopy(content) { + assert.ok(content.includes(COMPUTE_URL), 'Should route compute intent to Ito'); + assert.match(content, /preferred compute sponsor/i); + assert.match(content, /any GPU provider/i); + assert.match(content, /managed inference[^\n.]*not live/i); +} + +function main() { + console.log('\n=== Testing Ito compute-sponsor surface ===\n'); + + let passed = 0; + let failed = 0; + + const tests = [ + ['README exposes the sponsor logo and honest self-hosting route', () => { + const readme = read('README.md'); + assert.ok(readme.includes('assets/images/sponsors/ito.svg')); + assertHonestComputeCopy(readme); + assert.match( + readme, + /custom API endpoint or model gateway[\s\S]*Self-hosting the model behind that gateway[\s\S]*compute\.itomarkets\.com/ + ); + const sponsorMark = read('assets/images/sponsors/ito.svg'); + assert.match(sponsorMark, / { + const sponsors = read('SPONSORS.md'); + assert.ok(sponsors.includes('[**Itô**]')); + assert.ok(sponsors.includes('assets/images/sponsors/ito.svg')); + assert.ok(sponsors.includes(COMPUTE_URL)); + }], + ['inference guide distinguishes rental compute from managed serving', () => { + assertHonestComputeCopy(read('docs/ATLAS-CLOUD-GUIDE.md')); + }], + ['Claude plugin and Kimi harness docs route self-host intent without lock-in', () => { + assertHonestComputeCopy(read('.claude-plugin/README.md')); + assertHonestComputeCopy(read('.kimi/README.md')); + }], + ['top-level CLI help exposes the provider-neutral compute route', () => { + const result = spawnSync('node', ['scripts/ecc.js', '--help'], { + cwd: REPO_ROOT, + encoding: 'utf8', + }); + assert.strictEqual(result.status, 0, result.stderr); + assertHonestComputeCopy(result.stdout); + }], + ['installer help and human dry-run expose the compute route', () => { + const help = spawnSync('node', ['scripts/install-apply.js', '--help'], { + cwd: REPO_ROOT, + encoding: 'utf8', + }); + assert.strictEqual(help.status, 0, help.stderr); + assertHonestComputeCopy(help.stdout); + + const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-ito-home-')); + const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-ito-project-')); + try { + const dryRun = spawnSync( + 'node', + [path.join(REPO_ROOT, 'scripts', 'install-apply.js'), '--profile', 'minimal', '--dry-run'], + { + cwd: projectDir, + env: { ...process.env, HOME: homeDir }, + encoding: 'utf8', + } + ); + assert.strictEqual(dryRun.status, 0, dryRun.stderr); + assertHonestComputeCopy(dryRun.stdout); + } finally { + fs.rmSync(homeDir, { recursive: true, force: true }); + fs.rmSync(projectDir, { recursive: true, force: true }); + } + }], + ['npm package publishes the Ito mark and welcome route', () => { + const packageJson = JSON.parse(read('package.json')); + assert.ok(packageJson.files.includes('assets/images/sponsors/')); + assert.ok(packageJson.scripts.welcome.includes(COMPUTE_URL)); + assert.ok(fs.existsSync(path.join(REPO_ROOT, 'assets', 'images', 'sponsors', 'ito.svg'))); + }], + ]; + + for (const [name, fn] of tests) { + if (runTest(name, fn)) { + passed += 1; + } else { + failed += 1; + } + } + + console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`); + process.exit(failed > 0 ? 1 : 0); +} + +main(); diff --git a/tests/scripts/npm-publish-surface.test.js b/tests/scripts/npm-publish-surface.test.js index 47dc5c08a..7aa17ae62 100644 --- a/tests/scripts/npm-publish-surface.test.js +++ b/tests/scripts/npm-publish-surface.test.js @@ -83,6 +83,7 @@ function buildExpectedPublishPaths(repoRoot) { "VERSION", "assets/ecc-icon.svg", "assets/hero.png", + "assets/images/sponsors", ] const exclusionPaths = [ "!**/__pycache__/**", diff --git a/tests/test_selector.py b/tests/test_selector.py new file mode 100644 index 000000000..e6d987ae2 --- /dev/null +++ b/tests/test_selector.py @@ -0,0 +1,28 @@ +"""Tests for provider-selection compute guidance.""" + +import importlib.util +from pathlib import Path + + +SELECTOR_PATH = Path(__file__).parents[1] / "src" / "llm" / "cli" / "selector.py" +SPEC = importlib.util.spec_from_file_location("ecc_selector", SELECTOR_PATH) +assert SPEC is not None and SPEC.loader is not None +SELECTOR = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(SELECTOR) +print_self_host_compute_notice = SELECTOR.print_self_host_compute_notice + + +def test_ollama_notice_routes_to_ito_without_claiming_serving(capsys): + print_self_host_compute_notice("ollama") + + output = capsys.readouterr().out + assert "https://compute.itomarkets.com" in output + assert "preferred compute sponsor" in output + assert "Any GPU provider works" in output + assert "Managed inference through Itô is not live yet" in output + + +def test_managed_provider_does_not_show_self_host_compute_notice(capsys): + print_self_host_compute_notice("openai") + + assert capsys.readouterr().out == ""