@ours.network/install 0.18.0-nightly.4 → 0.18.0-nightly.6

package/README.md

@@ -9,6 +9,21 @@ npm install --global @ours.network/install
 ours-install
 ```
 
+### Stable and nightly channels
+
+Installing `@ours.network/install@latest` selects the stable channel; installing
+`@ours.network/install@nightly` selects the nightly channel. Before changing the
+machine, the installer resolves `@ours.network/mcp`,
+`@ours.network/claude-code`, and `@ours.network/codex`, verifies that their
+selected dist-tags expose one exact lockstep version, and fails closed if they
+do not. MCP and the Codex launcher are installed by exact version, and local
+Claude Code and Codex marketplace manifests pin the corresponding plugin
+packages to that same version.
+
+`OURS_CHANNEL=latest|nightly` (or the legacy `OURS_INSTALL_CHANNEL`) remains an
+explicit override. Without an override, the installed package's own version
+selects the channel.
+
 The normal flow uses one daemon at `~/.ours` on port 3050, shows an eight-stage
 progress bar, and asks only for information it cannot safely infer (normally the
 Human identity's display name). Existing daemon conflicts and moving a Telegram
@@ -24,8 +39,8 @@ connector from another daemon still require explicit confirmation.
   or preserves the existing one on a re-run.
 - Installs the ours plugin into safely detected Claude Code, Codex, and Hermes
   installations.
-- Configures and starts cowork against the shared daemon.
-- Configures Telegram against the same daemon, but does **not** start it.
+- Configures and starts cowork as a durable shim over the shared daemon.
+- Configures and starts Telegram as a durable shim over the same daemon.
 - Runs Fleet's host initialization and, when `~/fleet.yaml` is absent, writes a
   conservative stopped starter with `FleetCoordinator`, a `fleet-health`
   watchdog, and a ten-minute `coordinator_health` loop. An existing
@@ -35,20 +50,21 @@ The operator CLI owns daemon configuration, lifecycle, and boot persistence.
 The MCP package is only the stdio adapter spawned by agent harnesses; the
 installer never asks `ours-mcp` to start a daemon.
 
-The external-history storage epoch is a clean breaking reset. The daemon refuses
-old packet state without modifying it, and this installer never migrates, purges,
-or silently replaces identities, contacts, invites, pending payloads, or history.
-Back up any wanted old state and remove it explicitly before starting the new epoch.
+Daemon state is temporarily scoped to its package major version. On a same-major
+update, the installer refreshes the packages and runs `ours daemon restart`; the
+CLI streams structured startup phases until restore is complete instead of
+appearing to hang. A different-major update is detected before package
+replacement. The installer explains the incompatibility and, only in an
+interactive run, offers to stop the CLI-managed daemon, copy the complete state
+directory to a timestamped directory under `~/.ours-backups/`, remove the
+managed service and old state, then initialize the new major. The default answer is no, and
+`OURS_ASSUME_YES` never authorizes this purge.
 
 ## What remains stopped
 
-Telegram and Fleet are installed but intentionally not started. Review and
-activate them when ready:
+Only Fleet is intentionally not started. Review and activate it when ready:
 
 ```sh
-# After configuring a Telegram bot and route locally:
-ours-tg-connector install-service
-
 # After reviewing ~/fleet.yaml:
 ours-fleet doctor
 ours-fleet config
@@ -74,8 +90,11 @@ new Human identity and asks no ordinary setup questions, but it never bypasses
 selection conflicts, connector moves, or destructive safeguards.
 
 A non-default daemon must be selected coherently with a config file or matching
-port and state directory. Harnesses and the generated Fleet role receive that
-selection through `OURS_CONFIG`; there is no per-application daemon.
+port and state directory. Hermes and the generated Fleet role persist that
+selection through `OURS_CONFIG`. Claude Code and Codex plugin registrations
+cannot store an environment value; for those harnesses the installer prints the
+exact `export OURS_CONFIG=...` line that must be added to the shell profile
+before starting the harness. There is no per-application daemon.
 
 ## Uninstall
 
@@ -92,6 +111,8 @@ targets only the explicit state directory.
 
 `OURS_CHANNEL=nightly` (or `OURS_INSTALL_CHANNEL`) selects the packages' nightly
 dist-tags. Without an override, the installer's own version selects the channel.
+The operator CLI intentionally has no nightly dist-tag and remains untagged on
+both channels.
 
 ## Environment
 

package/install.sh

@@ -21,6 +21,9 @@
 # From a CLONE (a sibling install.mjs is present) it runs that directly. Piped as `curl … | bash`
 # it installs the published command globally — `npm i -g @ours.network/install` — then runs
 # `ours-install`. Idempotent: a re-run updates to @latest and runs again.
+# The bootstrap is deliberately stable. For nightly, install the published nightly command
+# directly: `npm i -g @ours.network/install@nightly && ours-install`; that package's own
+# X.Y.Z-nightly.N version selects and exactly resolves the matching stack channel.
 #
 # Non-interactive env overrides (all optional) — consumed by the Node installer:
 #   OURS_ASSUME_YES=1                        accept every default; never prompt (no tty needed)

package/lib/components.mjs

@@ -1,7 +1,7 @@
 // ours-install v3 — component selection and attachment.
 //
-// Spec: installer-spec-v3 §5 (and the repoint half of §7, which cannot be
-// separated from attaching the connector without making a silent move possible).
+// Component selection and attachment planning. Repoint decisions stay beside
+// attachment decisions so an existing connector can never move silently.
 // Pure, like target.mjs and plan.mjs: the caller injects the current file
 // contents and the installed versions, and every function returns a plan.
 //
@@ -101,7 +101,7 @@ export const tgConfigPath = (home, env = {}) => env.OURS_TG_CONFIG ?? join(home,
 export const coworkConfigPath = (home, env = {}) => env.OURS_COWORK_CONFIG ?? join(home, '.ours-cowork', 'config.json');
 
 // -----------------------------------------------------------------------------
-// §5 — selection
+// Component selection
 // -----------------------------------------------------------------------------
 
 /**
@@ -133,7 +133,7 @@ export function planComponentSelection({ answers = {}, installed = {}, assumeYes
 }
 
 // -----------------------------------------------------------------------------
-// §5 — the MCP server
+// MCP server attachment
 // -----------------------------------------------------------------------------
 
 /**
@@ -159,7 +159,7 @@ export function planMcpAttachment({ stateDir, isDefaultStateDir, channel = 'late
 }
 
 // -----------------------------------------------------------------------------
-// §5 / §7 — the Telegram connector
+// Telegram connector attachment and repointing
 // -----------------------------------------------------------------------------
 
 /**
@@ -203,11 +203,10 @@ export function planTgAttachment({ existing, endpoint, stateDir, brokerUrl, assu
     changed: changes.length > 0,
     changes,
     config: merged,
-    // Telegram is intentionally staged but stopped. Its CLI currently couples
-    // service installation with `enable --now`, so calling it here would violate
-    // the installer's promise not to launch Telegram before a bot is configured.
-    // The end screen gives this exact command as the explicit opt-in start step.
-    service: null,
+    // The connector is a durable shim over the shared daemon. Its service command
+    // owns the platform-specific unit and `enable --now`; the installer invokes
+    // it after committing the coherent daemon selection below.
+    service: ['ours-tg-connector', 'install-service'],
     untouched: [...TG_REGISTRY_FILES, ...TG_ROUTE_FILES],
   };
   if (!pointsElsewhere) return { ...plan, action: plan.changed ? 'attach' : 'unchanged' };
@@ -218,12 +217,12 @@ export function planTgAttachment({ existing, endpoint, stateDir, brokerUrl, assu
     to: { daemonUrl: endpoint, daemonStateDir: dir },
     prompt: `The Telegram connector currently uses ${current.daemonUrl ?? 'an unrecorded daemon'} (${current.daemonStateDir ?? 'unrecorded state directory'}).\nPoint it at ${endpoint} (${dir}) instead? This MOVES the connector; it does not add a second one.`,
   };
-  // Never repointed without a human, in any mode (spec §9).
+  // Never repoint an existing connector without a human, in any mode.
   return assumeYes ? { ...repoint, action: 'skip-repoint', reason: 'never repointed non-interactively' } : repoint;
 }
 
 // -----------------------------------------------------------------------------
-// §5 — cowork
+// cowork attachment
 // -----------------------------------------------------------------------------
 
 /**
@@ -342,7 +341,7 @@ export function planCoworkAttachment({ existing, endpoint, stateDir, installedVe
 }
 
 // -----------------------------------------------------------------------------
-// §5 — one component failing does not stop the others
+// Component failures are isolated so the remaining components can continue.
 // -----------------------------------------------------------------------------
 
 /**

package/lib/detect.mjs

@@ -1,7 +1,7 @@
 // ours-install v3 — which daemons are already on this machine, and which one this
 // run is for.
 //
-// Never ask for a state directory or a port to be TYPED (spec §2). When several
+// Never ask for a state directory or port to be typed. When several
 // daemons are DETECTED, show them and let one be picked: selecting from what was
 // found is not prompting for a path.
 //
@@ -91,7 +91,7 @@ export function detectDaemons({ candidates = [], exists, readJson }) {
 /**
  * A state directory for a daemon this run would CREATE, derived and never typed.
  *
- * Spec §2 forbids asking for a path, so "create a new one" has to derive somewhere
+ * The UI does not ask for a path, so "create a new one" has to derive somewhere
  * to put it: `~/.ours` when free, else the first free `~/.ours-2`, `~/.ours-3`…
  * An operator who wants a specific path still has `--state-dir`, which bypasses
  * this screen entirely.
@@ -151,7 +151,7 @@ export function planDaemonSelection({
  *
  * Deliberately strict: an answer that is not a number in range, or the create
  * option, is NOT a state directory to be interpreted. Accepting free text here
- * would be exactly the "type a path" prompt spec §2 forbids, arriving through the
+ * would reintroduce the forbidden "type a path" prompt through the
  * back door.
  */
 export function resolveSelection(answer, { candidates = [], createOption = null } = {}) {

package/lib/effects.mjs

@@ -12,7 +12,7 @@
 // unit file or the service manager directly.
 
 import { spawnSync, execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { cpSync, existsSync, readFileSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, userInfo, platform as osPlatform, release as osRelease } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { atomicWriteConfig, snapshotConfig, restoreConfig } from './config.mjs';
@@ -29,7 +29,12 @@ async function probePort(port, { timeoutMs = 1500 } = {}) {
     if (!res.ok) return { ok: false, reason: `HTTP ${res.status}` };
     const body = await res.json();
     if (typeof body?.stateDir !== 'string') return { ok: false, reason: 'no stateDir in reply' };
-    return { ok: true, stateDir: body.stateDir };
+    return {
+      ok: true,
+      stateDir: body.stateDir,
+      version: typeof body.version === 'string' ? body.version : null,
+      compat: Number.isInteger(body.compat) ? body.compat : null,
+    };
   } catch (error) {
     return { ok: false, reason: error?.name === 'AbortError' ? 'timed out' : String(error?.message ?? error) };
   } finally {
@@ -64,9 +69,9 @@ function readTextFile(path) {
   }
 }
 
-function installedVersionOf(pkg) {
+function installedVersionOf(pkg, npmBin = 'npm') {
   try {
-    const out = execFileSync('npm', ['ls', '-g', '--depth', '0', '--json', pkg], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const out = execFileSync(npmBin, ['ls', '-g', '--depth', '0', '--json', pkg], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
     return JSON.parse(out)?.dependencies?.[pkg]?.version ?? null;
   } catch {
     // Unreadable is NOT "new enough": the cowork gate fails closed on null.
@@ -74,6 +79,44 @@ function installedVersionOf(pkg) {
   }
 }
 
+function packageDependenciesOf(pkgSpec, npmBin = 'npm') {
+  const probe = capture(npmBin, ['view', pkgSpec, 'dependencies', '--json'], { timeout: 15_000 });
+  if (!probe.ok) return null;
+  try {
+    const parsed = JSON.parse(probe.stdout);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolvePackageVersion(pkg, channel, npmBin = 'npm') {
+  const tag = channel === 'nightly' ? 'nightly' : 'latest';
+  const probe = capture(npmBin, ['view', `${pkg}@${tag}`, 'version', '--json'], { timeout: 15_000 });
+  if (!probe.ok) return '';
+  try {
+    const parsed = JSON.parse(probe.stdout);
+    return typeof parsed === 'string' ? parsed : '';
+  } catch {
+    return /^\S+$/.test(probe.stdout.trim()) ? probe.stdout.trim() : '';
+  }
+}
+
+function codexMarketplace() {
+  const probe = capture('codex', ['plugin', 'marketplace', 'list', '--json'], { timeout: 6_000 });
+  if (!probe.ok) return null;
+  try {
+    return JSON.parse(probe.stdout)?.marketplaces?.find((m) => m?.name === 'ours-codex-marketplace') ?? null;
+  } catch { return null; }
+}
+
+function hasClaudePlugin() {
+  const probe = capture('claude', ['plugin', 'list', '--json'], { timeout: 6_000 });
+  if (!probe.ok) return false;
+  try { return JSON.parse(probe.stdout)?.some((p) => p?.id === 'ours@ours.network') ?? false; }
+  catch { return false; }
+}
+
 /**
  * A read-only command probe that NEVER throws and NEVER inherits stdio.
  *
@@ -207,6 +250,7 @@ function knownStateDirsIn(home) {
  * the orchestrator never reaches for a terminal itself.
  */
 export function realEffects({ write, ttyFd, env = process.env, home = homedir(), out, version = null } = {}) {
+  const npmBin = env.OURS_NPM?.trim() || 'npm';
   return {
     home,
     env,
@@ -221,6 +265,15 @@ export function realEffects({ write, ttyFd, env = process.env, home = homedir(),
     // pure planner already gated four ways, and this deletes exactly that.
     removeDir: (path) => { rmSync(resolve(path), { recursive: true, force: true }); },
     removeFile: (path) => { rmSync(resolve(path), { force: true }); },
+    copyDir: (source, destination) => {
+      mkdirSync(dirname(resolve(destination)), { recursive: true, mode: 0o700 });
+      cpSync(resolve(source), resolve(destination), {
+        recursive: true,
+        errorOnExist: true,
+        force: false,
+        preserveTimestamps: true,
+      });
+    },
     // Rewrites a config file we do NOT own, so it keeps the file's own mode
     // rather than imposing 0600: tightening the permissions of somebody else's
     // ~/.codex/config.toml is a side effect nobody asked this to have.
@@ -266,16 +319,21 @@ export function realEffects({ write, ttyFd, env = process.env, home = homedir(),
     // invocation only and never to the installer's own process: a state
     // directory selected by one run must not leak into anything the operator
     // starts afterwards.
-    run: async (cmd, args, { env: extraEnv = null } = {}) => {
+    run: async (cmd, args, { env: extraEnv = null, stream = false } = {}) => {
       // Always built from this layer's OWN env rather than left to spawnSync's
       // implicit inheritance, so what a child receives is a property of the
       // effects object a caller constructed and not of whatever ambient shell
       // the installer happened to start in.
       const childEnv = { ...env, ...(extraEnv ?? {}) };
-      const r = spawnSync(cmd, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: childEnv });
+      const executable = cmd === 'npm' ? npmBin : cmd;
+      const r = spawnSync(executable, args, {
+        encoding: 'utf8',
+        stdio: stream ? ['ignore', 'inherit', 'inherit'] : ['ignore', 'pipe', 'pipe'],
+        env: childEnv,
+      });
       if (r.status !== 0) {
         const detail = (r.stderr || r.stdout || '').trim().split('\n').slice(-3).join('; ');
-        throw new Error(`${cmd} ${args.join(' ')} exited ${r.status}${detail ? `: ${detail}` : ''}`);
+        throw new Error(`${executable} ${args.join(' ')} exited ${r.status}${detail ? `: ${detail}` : ''}`);
       }
       return { ok: true, code: r.status, stdout: r.stdout ?? '' };
     },
@@ -288,7 +346,11 @@ export function realEffects({ write, ttyFd, env = process.env, home = homedir(),
       const r = spawnSync(cmd, args, { stdio: 'inherit', env: { ...env, ...(extraEnv ?? {}) } });
       return { ok: !r.error && r.status === 0, code: r.status ?? -1 };
     },
-    installedVersion: installedVersionOf,
+    installedVersion: (pkg) => installedVersionOf(pkg, npmBin),
+    packageDependencies: (spec) => packageDependenciesOf(spec, npmBin),
+    resolvePackageVersion: (pkg, channel) => resolvePackageVersion(pkg, channel, npmBin),
+    codexMarketplace,
+    hasClaudePlugin,
     out: out ?? ((line) => process.stdout.write(`${line}\n`)),
     // Never called when assumeYes: the orchestrator takes the default itself.
     ask: async (prompt, def = false) => (ttyFd == null ? def : askYesNo(write, ttyFd, `  ${prompt}  `, def)),
@@ -296,7 +358,7 @@ export function realEffects({ write, ttyFd, env = process.env, home = homedir(),
   };
 }
 
-export const __testables = { probePort, portTakenSync, readJsonFile, readTextFile, installedVersionOf, knownStateDirsIn };
+export const __testables = { probePort, portTakenSync, readJsonFile, readTextFile, installedVersionOf, packageDependenciesOf, resolvePackageVersion, codexMarketplace, hasClaudePlugin, knownStateDirsIn };
 
 // -----------------------------------------------------------------------------
 // THE PAIR
@@ -305,7 +367,7 @@ export const __testables = { probePort, portTakenSync, readJsonFile, readTextFil
 /**
  * The environment that names ONE daemon, for a single child invocation.
  *
- * Spec §2's rule is that a state directory and an endpoint always travel
+ * A state directory and its endpoint always travel
  * together; "endpoint selected, state directory defaulted" must be unreachable.
  * Every consumer downstream — ours-mcp's proxy, ours-fleet's per-role resolver,
  * ours-hermes-install — reads these three names and falls back to `~/.ours` for

package/lib/extras.mjs

@@ -1,14 +1,14 @@
 // ours-install v3 — the four retained extras, re-pointed at the v3 arrangement.
 //
 // The v3 installer keeps harness plugins, ours-fleet, voice setup and the
-// copy-paste hand-off prompt; spec v3's silence about them was an oversight.
+// copy-paste hand-off prompt.
 //
 // The shared daemon belongs to the operator CLI. ours-mcp is only a per-session
 // stdio adapter with no unit, and these extra phases preserve that boundary.
 //
 // Pure, like target.mjs / plan.mjs / components.mjs: no I/O, no subprocess, no
 // terminal. Every function takes what was observed and returns a plan; the
-// orchestrator (a later PR) is what performs it.
+// orchestrator performs it.
 
 import { dirname, join, resolve } from 'node:path';
 import { pkgSpec } from './logic.mjs';
@@ -16,7 +16,7 @@ import { pkgSpec } from './logic.mjs';
 const cfgPath = (stateDir) => join(resolve(stateDir), 'config.json');
 
 // -----------------------------------------------------------------------------
-// §5 — harness plugins
+// Harness plugins
 // -----------------------------------------------------------------------------
 
 export const CLAUDE_MARKET = 'adapt-toolkit/ours-claude-marketplace';
@@ -29,13 +29,12 @@ export const HARNESSES = [
 ];
 
 /**
- * SPEC §5 PROMISES SOMETHING TWO OF THE THREE REGISTRATIONS CANNOT DO.
+ * TWO OF THE THREE REGISTRATIONS CANNOT PERSIST AN ENVIRONMENT VALUE.
  *
- * §5: "For any other state directory the installer registers the harness MCP
- * entry with OURS_CONFIG=<state-dir>/config.json in its environment, so the pair
- * travels together." planMcpAttachment already returns exactly that harnessEnv —
- * and the orchestrator only PRINTS it. That is not an oversight to be fixed by
- * wiring it up harder; none of the three registrations can carry a value:
+ * For a non-default state directory, planMcpAttachment exposes the required
+ * OURS_CONFIG value. Claude Code and Codex cannot persist that value in their
+ * plugin registrations, so the installer prints an explicit shell export and
+ * never claims it was applied automatically:
  *
  *   Claude Code  the marketplace plugin's mcpServers.ours is command+args, with
  *                no env key, and `claude plugin install` injects nothing per
@@ -46,9 +45,7 @@ export const HARNESSES = [
  *   Hermes       renderConfigBlock is OUR writer, and now emits an `env:` block
  *                carrying OURS_CONFIG — so for Hermes the pair is real.
  *
- * So §5's guarantee is ALREADY unmet today for every non-default state
- * directory, silently: the harness attaches to ~/.ours while the operator was
- * told the run targeted somewhere else. The shape is:
+ * The supported behavior is:
  *
  *   default state directory   today's behaviour, byte for byte.
  *   Hermes, non-default       real: the pair is handed to ours-hermes-install's
@@ -56,7 +53,7 @@ export const HARNESSES = [
  *                             as the ours server's own env block.
  *   Claude / Codex, non-def   install the plugin (it is still the right plugin)
  *                             and PRINT the exact line the operator must add.
- *                             Never claim §5's guarantee in the screen text.
+ *                             Never claim automatic configuration in the screen text.
  *
  * Deliberately NOT done: registering a second, user-scoped `ours` MCP server via
  * `claude mcp add --env`. Two `ours` servers in front of one harness, and which
@@ -94,7 +91,7 @@ const driveSteps = {
   codex: (channel) => [
     ['codex', 'plugin', 'marketplace', 'add', CODEX_MARKET],
     ['codex', 'plugin', 'add', 'ours@ours-codex-marketplace'],
-    // Owner-mandated in v2 and kept: choosing the Codex plugin also installs the
+    // Product requirement in v2 and kept: choosing the Codex plugin also installs the
     // ours-codex live launcher, in the same step.
     ['npm', 'i', '-g', pkgSpec('codex', channel)],
   ],
@@ -122,7 +119,7 @@ const driveSteps = {
  * `env` is what an invocation must carry, and it is EMPTY unless the harness can
  * genuinely apply it. `envLine` is what the operator is told. `claimsPair` is
  * false whenever the pair is only printed — the screen text renderer reads it so
- * §5's guarantee cannot be claimed where it does not hold.
+ * the screen cannot claim that the pair was persisted where it was only printed.
  */
 export function planHarnessPlugins({
   harnesses = [],
@@ -170,7 +167,7 @@ export function planHarnessPlugins({
 }
 
 // -----------------------------------------------------------------------------
-// §5 — what the operator has to do BEFORE any of this works
+// Preconditions the operator must satisfy before installation
 // -----------------------------------------------------------------------------
 
 /**
@@ -331,7 +328,7 @@ export function buildHandoffPromptV3({
     steps.push(
       'Finish my Telegram setup without exposing secrets: ask me for the bot name\n'
       + '   and guide me through entering the @BotFather token locally. Register the\n'
-      + '   route, then start the connector only after I approve.',
+      + '   route in the connector service that ours-install already started.',
     );
   }
   if (steps.length === 0) return { text: '', empty: true };

package/lib/logic.mjs

@@ -107,7 +107,7 @@ export function resolveChannel(raw, selfVersion = '') {
 
 // A published nightly carries the `-nightly.N` prerelease suffix the bump script writes.
 export function isNightlyVersion(version) {
-  return /-nightly\.\d+/.test(String(version || ''));
+  return /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)-nightly\.(?:0|[1-9]\d*)$/.test(String(version || ''));
 }
 
 // The npm dist-tag to install for one package key under a channel. Looks the key
@@ -207,15 +207,13 @@ export function planTgDaemonConfig(existing, { daemonUrl, daemonStateDir, broker
 }
 
 // ── Rooms / ours-cowork ────────────────────────────────────────────────────────
-// ours-cowork was a purely standalone daemon: its shipped 0.4.0 bundle has no
-// daemonUrl / daemonStateDir / /api/v1 anywhere and its docs said it "has no
-// dependency on another agent daemon". ours-cowork PR #9 (head 030b71df…) adds an
-// EXTERNAL daemon mode, so Rooms can now answer the same common-vs-dedicated
-// question the Telegram connector does. Its exact contract, as reported:
+// cowork supports an external-daemon mode, so Rooms can use the same
+// common-vs-dedicated selection as the Telegram connector. Its public config
+// contract is:
 //
 //   ~/.ours-cowork/config.json carries an OPTIONAL `daemon` block.
 //     absent  ⇒ EMBEDDED — cowork hosts its own daemon (what every install
-//               before PR #9 does, and still the safe answer for one already
+//               before external mode existed, and still the safe answer for one already
 //               running that way).
 //     present ⇒ { mode: 'external', endpoint: 'http://127.0.0.1:<port>',
 //                 stateDir: '<absolute ours-daemon state dir>' }
@@ -236,19 +234,12 @@ export const COWORK_DEFAULT_PORT = 3052;
 export const COWORK_DAEMON_MODES = ['embedded', 'external'];
 
 // Which cowork builds understand the `daemon` block. Its config is a STRICT
-// document, so handing an unknown key to a build that predates PR #9 is not a
+// document, so handing an unknown key to a build that predates external mode is not a
 // harmless no-op — and cowork's boot is fail-closed, so the failure surfaces as a
 // Rooms daemon that will not start rather than a warning.
 //
-// The FIRST published cowork that implements the external-daemon mode. Verified
-// against the registry rather than taken on trust:
-//   @ours.network/cowork@nightly = 0.4.1-nightly.20260816.4aaf940
-//   gitHead 4aaf9406016098704d06b52352f7a38adc2ef160
-//   dist.shasum 5a6422409b1203a9bcc6aca33965fe47e9a5c17c
-//   depends on @ours.network/sdk 1.3.1; `latest` still 0.4.0
-// and the packed tarball really carries it — dist/daemon.js and dist/cli.js
-// contain the mode enum ["embedded","external"], the endpoint+stateDir pairing
-// check, OURS_COWORK_DAEMON_MODE/_ENDPOINT/_STATE_DIR, and the daemon-token read.
+// The first published cowork version whose package contains external-daemon
+// config parsing, endpoint/state-directory pairing, and daemon-token loading.
 export const COWORK_EXTERNAL_MIN_VERSION = '0.4.1-nightly.20260816.4aaf940';
 
 // Does the cowork build actually on this machine support an external daemon?

package/lib/marketplace.mjs

@@ -0,0 +1,104 @@
+import { join } from 'node:path';
+
+const NUM = '(?:0|[1-9]\\d*)';
+const STABLE_VERSION = new RegExp(`^${NUM}\\.${NUM}\\.${NUM}$`);
+const NIGHTLY_VERSION = new RegExp(`^${NUM}\\.${NUM}\\.${NUM}-nightly\\.${NUM}$`);
+
+// npm view --json normally returns a JSON string, while older/custom npm wrappers may
+// return the plain version. Accept exactly one scalar either way; arrays/objects are not
+// a deliberate dist-tag resolution and therefore fail closed.
+export function parseNpmVersion(text) {
+  const raw = String(text ?? '').trim();
+  if (!raw) return '';
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === 'string' ? parsed.trim() : '';
+  } catch {
+    return /^\S+$/.test(raw) ? raw : '';
+  }
+}
+
+export function validateChannelVersion(version, channel) {
+  const value = String(version ?? '').trim();
+  const selected = channel === 'nightly' ? 'nightly' : 'latest';
+  const valid = selected === 'nightly'
+    ? NIGHTLY_VERSION.test(value)
+    : STABLE_VERSION.test(value);
+  return valid
+    ? { ok: true, version: value, channel: selected }
+    : {
+        ok: false,
+        version: value,
+        channel: selected,
+        reason: selected === 'nightly'
+          ? `expected an exact X.Y.Z-nightly.N version, got ${value || '<empty>'}`
+          : `expected an exact stable X.Y.Z version, got ${value || '<empty>'}`,
+      };
+}
+
+function exactVersion(version, channel) {
+  const checked = validateChannelVersion(version, channel);
+  if (!checked.ok) throw new Error(checked.reason);
+  return checked.version;
+}
+
+export function buildClaudeMarketplace(version, channel) {
+  const pinned = exactVersion(version, channel);
+  return {
+    $schema: 'https://json.schemastore.org/claude-code-marketplace.json',
+    name: 'ours.network',
+    owner: {
+      name: 'Adapt Toolkit',
+      url: 'https://github.com/adapt-toolkit/ours-claude-marketplace',
+    },
+    plugins: [{
+      name: 'ours',
+      displayName: 'ours',
+      description: 'Secure agent-to-agent communication channel over ADAPT: self-sovereign pubkey identity, end-to-end encryption.',
+      author: { name: 'Adapt Toolkit' },
+      homepage: 'https://github.com/adapt-toolkit/ours-claude-marketplace',
+      repository: 'https://github.com/adapt-toolkit/ours-claude-marketplace',
+      keywords: ['mcp', 'a2a', 'adapt', 'e2e', 'messaging'],
+      source: {
+        source: 'npm',
+        package: '@ours.network/claude-code',
+        version: pinned,
+      },
+    }],
+  };
+}
+
+export function buildCodexMarketplace(version, channel) {
+  const pinned = exactVersion(version, channel);
+  return {
+    name: 'ours-codex-marketplace',
+    interface: { displayName: 'ours.network for Codex' },
+    plugins: [{
+      name: 'ours',
+      source: {
+        source: 'npm',
+        package: '@ours.network/codex',
+        version: pinned,
+        registry: 'https://registry.npmjs.org',
+      },
+      policy: { installation: 'AVAILABLE', authentication: 'ON_INSTALL' },
+      category: 'Productivity',
+    }],
+  };
+}
+
+export function marketplacePaths(home) {
+  const root = join(home, '.ours', 'install', 'marketplaces');
+  const claudeRoot = join(root, 'claude-code');
+  const codexRoot = join(root, 'codex');
+  return {
+    claudeRoot,
+    claudeManifest: join(claudeRoot, '.claude-plugin', 'marketplace.json'),
+    codexRoot,
+    codexManifest: join(codexRoot, '.agents', 'plugins', 'marketplace.json'),
+  };
+}
+
+export function marketplaceJson(value) {
+  return JSON.stringify(value, null, 2) + '\n';
+}

package/lib/orchestrate-uninstall.mjs

@@ -40,7 +40,7 @@ async function perform(effects, dryRun, label, thunk) {
 
 /**
  * Which components are being removed alongside this daemon. Asked once, before
- * anything is touched, so the §8 step 1 refusal can be resolved in the same run
+ * anything is touched, so a referenced-component refusal can be resolved in the same run
  * rather than sending the operator away and back.
  *
  * Non-interactively the answer is NO — assume-yes never consents to removing
@@ -81,7 +81,7 @@ export async function runUninstall(argv, effects) {
   effects.out(heading(`ours-uninstall --state-dir ${dir}`));
   if (args.dryRun) effects.out(info('dry-run: nothing will be removed or stopped'));
 
-  // §9 — the documented OURS_UNINSTALL_* contract (item 10.9), read BEFORE any
+  // Read the documented OURS_UNINSTALL_* contract before any
   // file is opened. A variable this uninstaller cannot deliver stops the run
   // here, naming itself and naming the replacement, rather than being silently
   // ignored while the operator's script reports success.