create-open-autonomy 2.1.0

package/README.md

@@ -0,0 +1,75 @@
+# The Hermes kit
+
+The default Open Autonomy starter kit: a complete repository that runs its own Hermes agent against the
+platform, with the SDK wired in. One command scaffolds it from two identity parameters, the project's name
+and its platform account; everything else is boilerplate the kit fills in.
+
+```bash
+bun create open-autonomy my-project --project my-project --account owner/my-project
+create-open-autonomy adopt .   --project my-project --account owner/my-project   # into an existing repository
+create-open-autonomy check .     # the kit-owned files against the kit (exit 1 on drift)
+create-open-autonomy upgrade .   # check, then rewrite the kit-owned files
+```
+
+## From npm
+
+Both packages publish from this repository: `@open-autonomy/sdk` and `create-open-autonomy`, at one version.
+`.github/workflows/release.yml` publishes them on a human-cut `release-v<version>` tag (or a manual dispatch)
+after the `production` environment's reviewer approves, with egress locked to npm and the token it needs
+(`NPM_TOKEN`) installed in that environment only. The world proves the same publish and a `bun create
+open-autonomy` from it against the npm registry twin (`bun world/run.ts kit`) before any release is cut.
+
+## What a generated repository contains
+
+```text
+README.md            the project's front page, with the account's four widgets
+CONSTITUTION.md      what the project is and must remain; its first paragraph leads the page, its invariants bind every task
+CONTRIBUTING.md      how code is written here, the bar every diff is reviewed against
+CHANGELOG.md         what shipped
+AGENTS.md            the agent's rules for this repository
+LICENSE              Apache-2.0, seeded; the project's own
+package.json, test/  the project's own check (`bun run check`), starting with one test
+hermes/              the agent: SOUL.md, its two skills (develop, pm), profiles/treasurer (the second profile: the one that pays), kanban.seed.json (the board's first tasks, in order),
+                     cron/jobs.seed.json (the PM, hourly), config.yaml (the model: the project's own choice), the seed hook
+.open-autonomy/      the platform connection: config.yaml (account, publish policy, rail bounds), reporter.ts (the bridge:
+                     sessions, the board, the setup), mint-key.ts (the key, the adopter way), setup.ts (the host, by one
+                     command), the vendored SDK, kit.json (which kit, version and parameters made this repository)
+container/           the stack: the agent, the key valve, the reporter; the pinned Hermes image
+.github/workflows/   ci.yml (the project's check on every branch), land.yml (the landing convention)
+```
+
+**Kit-owned** files are kept current by `upgrade`: `hermes/` (except `config.yaml` and `kanban.seed.json`), the reporter,
+the key tool, the vendored SDK, `container/`, the two workflows. A project that takes one over names it in
+`kit.json`'s `divergences`. **Seeded** files are written once and never touched again: the README, the
+board's seed, the constitution, `CONTRIBUTING.md`, the changelog, `AGENTS.md`, the license, the model config, the publish policy.
+
+## How the repository runs itself
+
+The agent is stock Hermes in a container, its home the committed `hermes/`, its checkout the repository,
+its model calls forwarded by the key valve beside it (which alone holds the project's key) to the platform,
+where each is metered to the project's account. The board is the roadmap: the owner files tasks (the seed
+files the first ones, in order, on the first boot), the gateway's dispatcher pulls them down and runs each as
+a worker session (the `develop` skill) that builds it, verifies it where `AGENTS.md` says the project is
+verified, lands it on an `agent/<task id>` branch the landing workflow merges when the checks pass, and hands
+off; the review lane, Hermes's own, verifies the handoff against the constitution and `CONTRIBUTING.md` in a session of its own; once an hour the PM job reads the whole board and unsticks what is stuck (the `pm` skill). Every
+session shows on the project's page with its cost.
+
+The reporter beside it is keyless: it discovers the agent's sessions through supercode's harness SDK
+(`subscribeSessionIndex`, `follow`, `subscribeSessionActivity`) and publishes each one through the valve
+with the Open Autonomy SDK, attaching it to the task it serves. It publishes the rest the same way: the board
+(`workflowLoad`: every task as a roadmap item, and each task's lane, attempts, handoff and verdicts under it) and
+the agent's setup (its persona, model, schedule and skills). The platform reads no file of
+the agent's; everything a page shows about it came through the SDK. Scheduled runs publish by default;
+`.open-autonomy/config.yaml` names the private exceptions. The project's page shows every session, update
+and settled cent per item, live while a session runs.
+
+**Rails.** The agent's model calls need no configuration beyond the key. `rails:` in
+`.open-autonomy/config.yaml` opens the two others, off by default: a single-use card minted against the
+balance for a bounded amount at the owner's merchant categories, and a partner service's metered charge
+for a listed partner within a bound. Both leave records on the public audit trail naming the rail.
+
+## Nothing in the agent's reach is a secret that matters
+
+The agent's `.env` says `OPEN_AUTONOMY_KEY=valve`. Pushes sign through an ssh-agent forwarded from the host
+holding one repository-scoped deploy key. Delivery uses at most a Discord bot token. Every session's turns
+are published; the platform redacts secret-shaped text at intake as the second wall.

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "create-open-autonomy",
+  "version": "2.1.0",
+  "description": "The default Open Autonomy starter kit: a complete repository that runs its own Hermes agent against the platform, with the SDK wired in. `bun create open-autonomy <dir>` scaffolds one.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/open-autonomy-org/open-autonomy.git",
+    "directory": "packages/kit-hermes"
+  },
+  "type": "module",
+  "bin": {
+    "create-open-autonomy": "./src/cli.ts"
+  },
+  "exports": {
+    ".": "./src/kit.ts"
+  },
+  "files": [
+    "src",
+    "template",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "bun test test/*.test.ts",
+    "typecheck": "bunx tsc --noEmit",
+    "check": "bun test test/*.test.ts && bunx tsc --noEmit"
+  },
+  "dependencies": {
+    "@open-autonomy/sdk": "2.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.10",
+    "typescript": "^5.9.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+// create-open-autonomy: the Hermes kit's door.
+//
+//   bun create open-autonomy <dir> --project <name> --account <owner/repo>   # a complete new repository
+//   create-open-autonomy adopt <dir> --project <name> --account <owner/repo>  # into an existing one; only what is missing
+//   create-open-autonomy check <dir>      # the kit-owned files against the kit (exit 1 on drift)
+//   create-open-autonomy upgrade <dir>    # check, then rewrite the kit-owned files
+import { resolve } from 'node:path';
+import { KIT, adopt, check, create, upgrade, validateParams } from './kit.ts';
+
+const argv = process.argv.slice(2);
+const flag = (name: string): string | undefined => { const i = argv.indexOf(name); return i >= 0 ? argv[i + 1] : undefined; };
+const verbs = new Set(['create', 'adopt', 'check', 'upgrade']);
+const verb = verbs.has(argv[0]) ? argv[0] : 'create';
+const dir = argv.filter((a, i) => !a.startsWith('--') && argv[i - 1]?.startsWith('--') !== true && a !== verb)[0];
+if (!dir) { console.error('usage: create-open-autonomy [create|adopt] <dir> --project <name> --account <owner/repo> | check <dir> | upgrade <dir>'); process.exit(2); }
+const target = resolve(dir);
+try {
+  if (verb === 'create' || verb === 'adopt') {
+    const params = validateParams({ project: flag('--project') ?? dir.split('/').filter(Boolean).pop(), account: flag('--account') });
+    const out = (verb === 'create' ? create : adopt)(target, params);
+    console.log(`${verb}: ${params.project} (${params.account}) → ${target}: ${out.written.length} file(s) written${out.skipped.length ? `, ${out.skipped.length} kept` : ''}`);
+    console.log(`next: commit it; mint the key (bun .open-autonomy/mint-key.ts); run the stack (container/README.md)`);
+  } else if (verb === 'check') {
+    const out = check(target);
+    if (out.drift.length) { for (const d of out.drift) console.error(d); console.error(`kit drift: ${out.drift.length} file(s). Run \`create-open-autonomy upgrade ${dir}\`; the kit is the source and its files are never edited in place (name a file in .open-autonomy/kit.json divergences to take it over).`); process.exit(1); }
+    console.log(`kit ${KIT.name} ${KIT.version}: ${target} matches`);
+  } else {
+    const out = upgrade(target);
+    console.log(`upgrade: ${out.written.length} file(s) rewritten${out.drift.length ? ` (${out.drift.length} had drifted)` : ''} → ${KIT.name} ${KIT.version}`);
+  }
+} catch (e) {
+  console.error(`create-open-autonomy: ${(e as Error).message}`);
+  process.exit(1);
+}

package/src/kit.ts

@@ -0,0 +1,139 @@
+// The kit engine. A kit is a template directory rendered with the project's identity — its name and its
+// platform account — into a complete repository. Two kinds of files come out of it:
+//   kit-owned   the agent's home, the reporter, the container stack, the landing workflows: what the kit
+//               keeps current. `check` diffs them against a fresh render; `upgrade` rewrites them.
+//   seeded      README, the board's seed, STANDARDS.md, vision, changelog, AGENTS.md, license, the model config, the publish
+//               policy: the project's own files, written once as a courtesy and never touched again.
+// `.open-autonomy/kit.json` records which kit, which version and which parameters made the repo: the anchor
+// `check` and `upgrade` read, so neither needs to be told anything twice.
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+
+export const KIT = { name: 'hermes', version: '2.1.0' } as const;
+export const KIT_FILE = '.open-autonomy/kit.json';
+const TEMPLATE = resolve(import.meta.dir, '..', 'template');
+
+export interface KitParams { project: string; account: string }
+export interface KitRecord { kit: string; version: string; params: KitParams; divergences: string[] }
+
+// What the kit keeps current. Everything else in the template is seeded once.
+const OWNED = [/^hermes\/(?!config\.yaml$|kanban\.seed\.json$)/, /^\.open-autonomy\/(reporter\.ts|mint-key\.ts|setup\.ts|package\.json|sdk\/)/, /^container\//, /^\.github\/workflows\/(ci|land)\.yml$/];
+export const isOwned = (rel: string): boolean => OWNED.some((re) => re.test(rel));
+
+export function validateParams(p: Partial<KitParams>): KitParams {
+  if (!p.project || !/^[a-z0-9][a-z0-9._-]{0,63}$/i.test(p.project)) throw new Error('project: a short name (letters, digits, . _ -)');
+  if (!p.account || !/^[^/\s]+\/[^/\s]+$/.test(p.account)) throw new Error('account: owner/repo, the GitHub repository the platform funds');
+  return { project: p.project, account: p.account };
+}
+
+function walk(dir: string, base = dir): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walk(full, base)); else out.push(relative(base, full));
+  }
+  return out.sort();
+}
+
+// The Open Autonomy SDK is vendored into the generated repository under .open-autonomy/sdk, kit-owned, so
+// the reporter and the key tool run from a bare clone with no package to publish or install.
+const SDK_SRC = resolve(dirname(Bun.resolveSync('@open-autonomy/sdk/package.json', import.meta.dir)), 'src');
+const SDK_FILES = ['client.ts', 'roadmap.ts', 'drivers.ts', 'rails.ts'];
+
+// Every template file, rendered. Placeholders are `__PROJECT__` and `__ACCOUNT__` (and `__ACCOUNT_ENC__`,
+// the account as a URL path segment); binary-looking files pass through untouched.
+export function render(params: KitParams): Map<string, Buffer> {
+  const out = new Map<string, Buffer>();
+  for (const rel of walk(TEMPLATE)) {
+    const raw = readFileSync(join(TEMPLATE, rel));
+    const text = raw.toString('utf8');
+    const rendered = /[\x00]/.test(text) ? raw : Buffer.from(text.replaceAll('__PROJECT__', params.project).replaceAll('__ACCOUNT_ENC__', encodeURIComponent(params.account)).replaceAll('__ACCOUNT__', params.account));
+    out.set(rel, rendered);
+  }
+  for (const f of SDK_FILES) out.set(`.open-autonomy/sdk/${f}`, readFileSync(join(SDK_SRC, f)));
+  out.set(KIT_FILE, Buffer.from(`${JSON.stringify({ kit: KIT.name, version: KIT.version, params, divergences: [] } satisfies KitRecord, null, 2)}\n`));
+  return out;
+}
+
+export function readKit(dir: string): KitRecord {
+  const p = join(dir, KIT_FILE);
+  if (!existsSync(p)) throw new Error(`${p} is missing: not a repository this kit made (create or adopt it first)`);
+  const rec = JSON.parse(readFileSync(p, 'utf8')) as KitRecord;
+  if (rec.kit !== KIT.name) throw new Error(`${p} names kit ${rec.kit}, not ${KIT.name}`);
+  return { ...rec, params: validateParams(rec.params), divergences: Array.isArray(rec.divergences) ? rec.divergences : [] };
+}
+
+export interface Outcome { written: string[]; skipped: string[]; drift: string[] }
+
+// create: every file, into an empty or new directory.
+export function create(dir: string, params: KitParams): Outcome {
+  if (existsSync(dir) && readdirSync(dir).filter((n) => n !== '.git').length) throw new Error(`${dir} is not empty: use adopt for an existing repository`);
+  return write(dir, render(params), () => true);
+}
+
+// adopt: into an existing repository, writing only what is missing. The project's own files stay.
+export function adopt(dir: string, params: KitParams): Outcome {
+  if (!existsSync(dir)) throw new Error(`${dir} does not exist`);
+  return write(dir, render(params), (rel) => !existsSync(join(dir, rel)));
+}
+
+// check: the kit-owned files against a fresh render of the recorded parameters. A file the project has
+// deliberately taken over is named in kit.json's `divergences` and is left out.
+export function check(dir: string): Outcome {
+  const rec = readKit(dir);
+  const rendered = render(rec.params);
+  const drift: string[] = [];
+  for (const [rel, want] of rendered) {
+    if (!isOwned(rel) || rec.divergences.includes(rel)) continue;
+    const at = join(dir, rel);
+    const have = existsSync(at) ? readFileSync(at) : null;
+    if (!have || Buffer.compare(have, want) !== 0) drift.push(`${rel}: ${have ? 'differs from' : 'missing; in'} the kit`);
+  }
+  for (const rel of retired(dir, rendered, rec)) drift.push(`${rel}: retired from the kit`);
+  return { written: [], skipped: [], drift };
+}
+
+// Kit-owned files the repository has that the kit no longer renders: what an earlier kit made and this one
+// retired. `upgrade` removes them; a project that keeps one names it in `divergences`. Only the families the
+// kit writes are looked at — never the agent's runtime state beside them (its database, sessions, logs, .env).
+const RETIRABLE = [/^hermes\/(skills|hooks|scripts)\//, /^\.open-autonomy\/([a-z-]+\.ts|sdk\/)/, /^container\//];
+function retired(dir: string, rendered: Map<string, Buffer>, rec: KitRecord): string[] {
+  const out: string[] = [];
+  for (const root of ['hermes/skills', 'hermes/hooks', 'hermes/scripts', '.open-autonomy', 'container']) {
+    const at = join(dir, root);
+    if (!existsSync(at)) continue;
+    for (const rel of walk(at).map((f) => `${root}/${f}`)) if (RETIRABLE.some((re) => re.test(rel)) && isOwned(rel) && !rendered.has(rel) && !rec.divergences.includes(rel)) out.push(rel);
+  }
+  return out;
+}
+
+// upgrade: check, then rewrite the drifted kit-owned files and stamp the kit version.
+export function upgrade(dir: string): Outcome {
+  const rec = readKit(dir);
+  const rendered = render(rec.params);
+  const before = check(dir);
+  const out = write(dir, rendered, (rel) => (isOwned(rel) && !rec.divergences.includes(rel)) || rel === KIT_FILE);
+  const gone = retired(dir, rendered, rec);
+  for (const rel of gone) { rmSync(join(dir, rel), { force: true }); out.written.push(`${rel} (retired)`); }
+  // A directory the retirement emptied goes too.
+  for (const rel of [...new Set(gone.map((r) => dirname(r)))]) { try { if (!readdirSync(join(dir, rel)).length) rmSync(join(dir, rel), { recursive: true }); } catch { /* gone */ } }
+  // The record keeps the project's divergences; only the version moves.
+  writeFileSync(join(dir, KIT_FILE), `${JSON.stringify({ ...rec, version: KIT.version } satisfies KitRecord, null, 2)}\n`);
+  return { ...out, drift: before.drift };
+}
+
+function write(dir: string, files: Map<string, Buffer>, should: (rel: string) => boolean): Outcome {
+  const written: string[] = [];
+  const skipped: string[] = [];
+  for (const [rel, content] of files) {
+    if (!should(rel)) { skipped.push(rel); continue; }
+    const at = join(dir, rel);
+    if (existsSync(at) && Buffer.compare(readFileSync(at), content) === 0) { skipped.push(rel); continue; }
+    mkdirSync(dirname(at), { recursive: true });
+    writeFileSync(at, content, { mode: rel.endsWith('.sh') ? 0o755 : 0o644 });
+    written.push(rel);
+  }
+  return { written, skipped, drift: [] };
+}
+
+export const templateFiles = (): string[] => walk(TEMPLATE);

package/template/.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI
+# Every change lands from a branch (agent/** the agent's, land/** a maintainer's): the push checks the head
+# commit, which is what branch protection and auto-merge require.
+on:
+  push:
+    branches: [main, 'agent/**', 'land/**']
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        with:
+          bun-version: 1.3.10
+      - run: bun run check

package/template/.github/workflows/land.yml

@@ -0,0 +1,30 @@
+name: Land a branch
+# Nothing pushes to `main`: branch protection requires a pull request and the `ci` check, with no bypass.
+# Work lands by pushing a branch: this workflow opens its pull request once and arms native auto-merge, so
+# it merges exactly when the required checks pass on its head commit.
+#   agent/**  the agent's own work        land/**  a maintainer's
+on:
+  push:
+    branches: ['agent/**', 'land/**']
+permissions:
+  contents: write
+  pull-requests: write
+jobs:
+  land:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open the pull request once, then arm auto-merge
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+          BRANCH: ${{ github.ref_name }}
+        run: |
+          set -euo pipefail
+          existing=$(gh pr list -R "$REPO" --head "$BRANCH" --state open --json number -q '.[0].number')
+          if [ -z "$existing" ]; then
+            gh pr create -R "$REPO" --base main --head "$BRANCH" --title "$BRANCH" \
+              --body "Opened by the landing workflow for \`$BRANCH\`. It merges on its own when the required checks pass."
+            existing=$(gh pr list -R "$REPO" --head "$BRANCH" --state open --json number -q '.[0].number')
+          fi
+          gh pr merge -R "$REPO" "$existing" --auto --merge
+          echo "pull request #$existing: auto-merge armed"

package/template/.open-autonomy/config.yaml

@@ -0,0 +1,27 @@
+# The project's connection to Open Autonomy. Read by the reporter (.open-autonomy/reporter.ts) and the key
+# tool (.open-autonomy/mint-key.ts). The kit seeds this file once; it is the project's own.
+account: __ACCOUNT__
+platform: https://open-autonomy.org
+
+# What the reporter publishes. Work sessions (the scheduled runs, the funded work) publish by default; the
+# private exceptions are named here. Anything listed under `private` is never sent.
+publish:
+  runs: true        # sessions the schedule started (trigger: cron)
+  chats: false      # conversations on a channel (Discord, a terminal)
+  private:          # session ids or job names that never publish, whatever their kind
+    - []
+
+# Where sessions come from: the Hermes home the reporter reads through supercode, and where it keeps its
+# own cursor. Inside the container stack these are the mounted volume and the checkout.
+hermes_home: /opt/data
+state_file: /work/project/.open-autonomy/reporter-state.json
+
+# The rails the agent may spend through beyond model calls, and the owner's bounds on each. Off unless a
+# bound is set. Every rail leaves a record on the public audit trail naming itself.
+rails:
+  card:                       # a single-use virtual card minted against the balance (Stripe Issuing)
+    max_usd_cents: 0          # the most one card may be minted for
+    categories: []            # Stripe merchant categories a card may pay at, e.g. [computer_software_stores]
+  partner:                    # a partner service settling a metered charge against the balance
+    max_usd_cents: 0          # the most one charge may be
+    partners: []              # the partner ids allowed to settle

package/template/.open-autonomy/mint-key.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+// Mint (or rotate) the project's key, the adopter way: prove control of the repository by committing the
+// claim file the platform names, then mint. No admin token exists anywhere; the only authority this needs
+// is the ability to push, which the maintainer running it already has. The key spends the project's balance
+// and nothing else, and stops at zero.
+//
+//   bun .open-autonomy/mint-key.ts [--models a,b] [--scopes spend,narrate,pay] [--out <file>]   # commit the claim, mint
+//   bun .open-autonomy/mint-key.ts --rotate [--grace <seconds>]            # with the current key; no commit
+//
+// The key is written to ~/.config/open-autonomy/agent.env (the file the key valve reads; created if
+// absent), with OPEN_AUTONOMY_BASE_URL. The agent itself never sees it.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { keyChallenge, keyMint, keyRotate } from './sdk/client.ts';
+
+const arg = (name: string): string | undefined => { const i = process.argv.indexOf(name); return i >= 0 ? process.argv[i + 1] : undefined; };
+const config = readFileSync(resolve(import.meta.dir, 'config.yaml'), 'utf8');
+const account = arg('--account') ?? /^account:\s*(\S+)/m.exec(config)?.[1] ?? '';
+const platform = (process.env.OPEN_AUTONOMY_URL ?? /^platform:\s*(\S+)/m.exec(config)?.[1] ?? 'https://open-autonomy.org').replace(/\/$/, '');
+const base = `${platform}/v1`;
+const models = (arg('--models') ?? 'zai/glm-5.3-flash').split(',').map((m) => m.trim()).filter(Boolean);
+// The developer's key spends and narrates; the treasurer's adds `pay` (--scopes spend,narrate,pay --out …/treasurer.env).
+const scopes = arg('--scopes')?.split(',').map((x) => x.trim()).filter(Boolean);
+const dir = join(homedir(), '.config', 'open-autonomy');
+const envPath = arg('--out') ?? join(dir, 'agent.env');
+const git = (...args: string[]) => { const r = spawnSync('git', args, { stdio: ['ignore', 'pipe', 'inherit'] }); if (r.status !== 0) { console.error(`git ${args.join(' ')} failed`); process.exit(1); } return r.stdout.toString().trim(); };
+if (!account) { console.error('no account: set it in .open-autonomy/config.yaml or pass --account owner/repo'); process.exit(2); }
+
+let minted;
+if (process.argv.includes('--rotate')) {
+  const current = existsSync(envPath) ? /^OPEN_AUTONOMY_KEY=(.+)$/m.exec(readFileSync(envPath, 'utf8'))?.[1] : undefined;
+  if (!current) { console.error(`no OPEN_AUTONOMY_KEY in ${envPath} to rotate`); process.exit(2); }
+  const grace = arg('--grace');
+  minted = await keyRotate(base, current, grace === undefined ? {} : { graceSeconds: Number(grace) });
+} else {
+  const challenge = await keyChallenge(base, account);
+  if (!challenge.ok) { console.error(`challenge failed: ${JSON.stringify(challenge)}`); process.exit(1); }
+  writeFileSync(challenge.file, `${challenge.claim}\n`);
+  git('add', challenge.file);
+  if (git('status', '--porcelain', '--', challenge.file)) { git('commit', '-q', '-m', `claim: ${account} key`, '--', challenge.file); git('push', '-q'); }
+  minted = await keyMint(base, account, models, scopes);
+}
+if (!minted.ok || !minted.token) { console.error(`mint failed: ${JSON.stringify(minted)}`); process.exit(1); }
+mkdirSync(dir, { recursive: true });
+const keep = existsSync(envPath) ? readFileSync(envPath, 'utf8').split('\n').filter((l) => !/^(OPEN_AUTONOMY_KEY|OPEN_AUTONOMY_BASE_URL)=/.test(l) && l.trim()) : [];
+writeFileSync(envPath, `${[...keep, `OPEN_AUTONOMY_BASE_URL=${base}`, `OPEN_AUTONOMY_KEY=${minted.token}`].join('\n')}\n`, { mode: 0o600 });
+console.log(`key ${minted.key.kid} for ${minted.key.account} (models: ${minted.key.models.join(', ')}; expires ${minted.key.exp}) → ${envPath}`);

package/template/.open-autonomy/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "__PROJECT__-open-autonomy",
+  "private": true,
+  "type": "module",
+  "description": "The project's connection to Open Autonomy: the reporter's two dependencies — supercode (the harness it reads the agent's sessions through) and supercode's harness SDK. The Open Autonomy SDK is vendored beside it under sdk/.",
+  "dependencies": {
+    "@volter-ai-dev/supercode": "^0.4.19",
+    "@volter-ai-dev/supercode-harness-sdk": "^0.3.21"
+  }
+}