@rosthq/cli 0.7.10 → 0.7.11

package/dist/index.js

@@ -47455,7 +47455,7 @@ The Compass is drafted, then activated by a human through supersession.
     order: 15,
     title: "AICOS chat guide",
     summary: "How the AI Chief of Staff chat works in the authenticated app shell and what it can safely do today.",
-    version: "2026-07-03.2",
+    version: "2026-07-03.3",
     public: true,
     audiences: ["human", "in_app_agent"],
     stages: ["company_setup", "operating_rhythm"],
@@ -47499,7 +47499,7 @@ You can reopen prior threads, search thread titles and summaries, or start a new
 
 New companies receive the governed AICOS foundation during provisioning. Existing companies can also set it up later from **Settings -> AICOS**. Owners and admins can see whether the foundation exists, repair it if needed, and choose the run location after setup.
 
-The repair action ensures the same structure new companies receive: a Founder/CEO root seat, an owner occupancy for stewardship, an **AI Chief of Staff** seat, the stock AICOS agent, and an active agent occupancy. It is idempotent; running it again repairs missing pieces instead of creating a second AICOS.
+The repair action ensures the same structure new companies receive: a Founder/CEO root seat, an owner occupancy for stewardship, an **AI Chief of Staff** seat, the stock AICOS agent, and one active agent occupancy. It is idempotent; running it again repairs missing pieces instead of creating a second AICOS. If older setup attempts left more than one active AICOS occupancy, the repair path keeps the best current stock AICOS agent \u2014 live before dry-run, draft, or paused \u2014 and ends the extra AICOS occupancies so Settings, lane readiness, and chat resolve the same governed agent.
 
 Settings is the infrastructure surface for AICOS. Use it to confirm foundation status, inspect the current lane, see whether a seat-scoped MCP token exists, and choose **Cloud**, **Runner**, or **MCP** when the server-side readiness checks allow it. The richer agent controls remain with the agent itself: open the AICOS seat from Settings or the agent fleet to manage Charter, tool permissions, approvals, go-live state, and run evidence.
 
@@ -48330,7 +48330,7 @@ External connectors are being rolled out provider by provider, conservatively (r
     order: 48,
     title: "CLI and MCP installation guide",
     summary: "Install the public CLI, register remote token-backed MCP clients, and find the full command and tool catalog.",
-    version: "2026-07-03.9",
+    version: "2026-07-03.10",
     public: true,
     audiences: ["human", "cli", "mcp", "in_app_agent"],
     stages: ["company_setup", "staffing"],
@@ -49063,6 +49063,8 @@ Several rows here are seat-operating commands (\`task.create\`, the \`signal.*\`
 | \`rost_create_a_forge_github_installation_token\` | \`software_factory.github.installation_token.create\` | Mint a short-lived GitHub App installation token for one bound repository after policy evaluation. The token is returned once and never stored. | Tenant | Call with \`{"software_project_id":"<project-id>","repository_id":789,"requested_actions":["read"],"requested_automation_mode":"plan_only"}\`. |
 | \`rost_list_forge_runner_capacity\` | \`software_factory.capacity.list\` | List Forge runner capacity observations (advisory scheduling input only, never an authority input). Read-only; requires the Forge add-on. | Tenant | Call with \`{}\` or \`{"runner_id":"<runner-id>"}\`. |
 
+The web Forge control room at \`/forge\` uses the same command path for project selection, build request creation/list/detail reads, runner capacity, configuration status, and Developer Team template install. The template install button deliberately stages a pending confirmation before durable seats, Skills, or authority grants are applied.
+
 #### Forge GitHub App access
 
 Forge repository access is through a tenant-bound GitHub App installation, not through a human's ambient \`git\` or \`gh\` credentials. The server verifies GitHub webhook signatures before parsing payloads, resolves the installation and repository against active tenant bindings, records delivery ids for idempotency, and creates GitHub issue build requests only when an active repo binding and policy allow intake.
@@ -49410,7 +49412,7 @@ Set \`ROST_SKILL_INSTALL_ROOT\` only for a sandbox or CI override. Local copies
     order: 55,
     title: "Agent reference map",
     summary: "Where CLI sessions, MCP clients, and in-app agents should retrieve {{brand}} guidance before recommending setup changes.",
-    version: "2026-07-03.1",
+    version: "2026-06-27.2",
     public: true,
     audiences: ["cli", "mcp", "in_app_agent"],
     stages: ["company_setup", "graph_design", "charter_design", "staffing", "operating_rhythm"],
@@ -49907,7 +49909,7 @@ Keep agent scope tight at first. Approve more autonomy only after evidence. Use
     order: 71,
     title: "Confirmations and human gates guide",
     summary: "How {{brand}} routes authority-changing work through human confirmation, and why agents never approve their own requests.",
-    version: "2026-06-27.2",
+    version: "2026-07-03.1",
     public: true,
     audiences: ["human", "cli", "mcp", "in_app_agent"],
     stages: ["graph_design", "charter_design", "staffing", "operating_rhythm"],
@@ -49944,6 +49946,8 @@ A gated command does not mutate when an agent calls it. It returns a pending con
 
 When an **agent** triggers a gate, {{brand}} also notifies the seat's steward (Slack with an email fallback) so the held action does not sit silent \u2014 a human is told a decision is waiting and given the approve link. A human pausing their own gated command does not self-notify. See the notifications guide.
 
+Approval replays are validated again before execution. If the stored confirmation input no longer matches the original command schema, the approval fails without consuming the pending confirmation or running the durable command; reject it and re-issue the gated action from the current product surface.
+
 \`\`\`bash
 # Human approves a pending confirmation
 {{cli}} command confirmation.approve --json '{"confirmation_id":"<confirmation-id>"}'
@@ -50169,7 +50173,7 @@ Agents may explain which setting is needed and why. They should not ask users to
     order: 73,
     title: "Members and invites guide",
     summary: "How to invite humans into the company without confusing user access with seat accountability.",
-    version: "2026-07-03.1",
+    version: "2026-07-03.2",
     public: true,
     audiences: ["human", "cli", "mcp", "in_app_agent"],
     stages: ["company_setup", "staffing"],
@@ -50248,7 +50252,7 @@ Every notification should include the seat, cause, evidence, and requested decis
     order: 75,
     title: "Local runner guide",
     summary: "How local agent sessions and runner surfaces should operate through {{brand}} without bypassing Charters or audit.",
-    version: "2026-07-03.1",
+    version: "2026-07-03.2",
     public: true,
     audiences: ["human", "cli", "mcp", "in_app_agent"],
     stages: ["staffing", "operating_rhythm"],
@@ -50280,13 +50284,13 @@ Use Local Runner when a Seat should run on a machine you control. Install it fro
 
 Recommended paths:
 
-- **Always-on host:** \`{{cli}} runner install-service --name <runner-name> --execute\` installs a background service (macOS launchd user agent, \`user/<uid>\` domain) that keeps the runner online. Manage it with \`{{cli}} runner start|stop|restart|status|logs|uninstall --name <runner-name>\`. On macOS this loads reliably when the runner user is logged in at the console; on a purely headless SSH box where that user is not at the console, run \`{{cli}} runner serve\` under a process supervisor instead.
+- **Always-on host:** \`{{cli}} runner install-service --name <runner-name> --execute\` installs a background service (macOS launchd user agent) that keeps the runner online. Manage it with \`{{cli}} runner start|stop|restart|status|logs|uninstall --name <runner-name>\`. On macOS the CLI tries both \`user/<uid>\` and \`gui/<uid>\` launchd domains because session behavior differs across console and SSH contexts; \`runner status --name <runner-name>\` prints the loaded domain.
 - **Manual smoke:** \`{{cli}} runner serve --once\` heartbeats once and exits; \`{{cli}} runner serve --execute\` claims and executes runner work orders while it runs.
 
 Two ways to authenticate and pair \u2014 both first-class, an agent can drive either entirely from the terminal:
 
 - **CLI-native (agent):** \`{{cli}} login --device\` prints a code for one human OAuth approval; after that the session is stored locally and the agent runs unattended ("approve once, then autonomous"). Then \`{{cli}} runner serve\`/\`install-service\` pairs against your active company \u2014 an authenticated CLI can also self-issue a pairing code with \`runner.pairing.start\` and claim it.
-- **Web-guided (human):** issue a pairing code from Settings > Runners > Add a Runner, then on the host run \`{{cli}} runner serve --user-code <code>\`. The host stores only the runner bearer secret in an owner-only file and never logs in.
+- **Web-guided (human):** issue a pairing code from Settings > Runners > Add a Runner, then on the host run \`{{cli}} runner serve --user-code <code>\`. An explicit user code always claims that code, even if the host has an older local runner state file, so the browser and terminal do not accidentally point at different runner ids. The host stores only the runner bearer secret in an owner-only file and never logs in.
 
 Headless and service accounts are supported first-class: when no usable OS keychain exists (for example a service or SSH account), the CLI stores the session in an owner-only file (directory 0700, file 0600) automatically \u2014 no development flag. That file holds only the CLI session token, never tenant secrets, API keys, or vault refs.
 
@@ -54927,11 +54931,13 @@ async function pairIfNeeded(client, fetchImpl, appUrl2, config2, io) {
       config2.expectedTenantId = expectedTenantId;
     }
   }
-  const existing = await loadState(config2.stateFile, config2.expectedTenantId);
-  if (existing) {
-    io.stdout.write(`reusing paired runner ${existing.runner_id}
+  if (config2.userCode === void 0) {
+    const existing = await loadState(config2.stateFile, config2.expectedTenantId);
+    if (existing) {
+      io.stdout.write(`reusing paired runner ${existing.runner_id}
 `);
-    return existing;
+      return existing;
+    }
   }
   let userCode;
   if (config2.userCode !== void 0) {
@@ -55286,7 +55292,12 @@ async function installService(options) {
   await writeFile3(paths.launchAgentPath, plist, { mode: 420 });
   await bootoutQuietly(options.exec, options.uid, paths.launchAgentPath);
   try {
-    await options.exec("launchctl", ["bootstrap", domainTarget(options.uid), paths.launchAgentPath]);
+    const bootstrapped = await bootstrapService(options.exec, options.uid, paths.launchAgentPath);
+    options.io.stdout.write(
+      bootstrapped.alreadyLoaded ? `Runner service was already loaded in launchd domain ${bootstrapped.domain}.
+` : `Loaded runner service in launchd domain ${bootstrapped.domain}.
+`
+    );
   } catch (error51) {
     options.io.stderr.write(
       `Failed to load the runner service: ${redactForLog(error51 instanceof Error ? error51.message : String(error51))}
@@ -55321,15 +55332,13 @@ async function startService(options) {
     );
     return 1;
   }
+  let bootstrapped;
   try {
-    await options.exec("launchctl", ["bootstrap", domainTarget(options.uid), paths.launchAgentPath]);
-    options.io.stdout.write(`Started runner service ${label}.
-`);
-    return 0;
-  } catch (bootstrapError) {
+    bootstrapped = await bootstrapService(options.exec, options.uid, paths.launchAgentPath);
+  } catch {
     try {
-      await options.exec("launchctl", ["kickstart", "-k", serviceTarget(options.uid, label)]);
-      options.io.stdout.write(`Runner service ${label} was already loaded; restarted it.
+      const target2 = await kickstartService(options.exec, options.uid, label);
+      options.io.stdout.write(`Runner service ${label} was already loaded at ${target2}; restarted it.
 `);
       return 0;
     } catch (kickstartError) {
@@ -55340,6 +55349,24 @@ async function startService(options) {
       return 1;
     }
   }
+  if (!bootstrapped.alreadyLoaded) {
+    options.io.stdout.write(`Started runner service ${label} in launchd domain ${bootstrapped.domain}.
+`);
+    return 0;
+  }
+  const target = `${bootstrapped.domain}/${label}`;
+  try {
+    await kickstartServiceTarget(options.exec, target);
+    options.io.stdout.write(`Runner service ${label} was already loaded at ${target}; restarted it.
+`);
+    return 0;
+  } catch (kickstartError) {
+    options.io.stderr.write(
+      `Failed to start runner service ${label}: ${redactForLog(kickstartError instanceof Error ? kickstartError.message : String(kickstartError))}
+`
+    );
+    return 1;
+  }
 }
 async function stopService(options) {
   if (options.platform !== "darwin") {
@@ -55348,11 +55375,11 @@ async function stopService(options) {
   const safeName = safeRunnerName(options.runnerName);
   const paths = runnerServicePaths(options.homeDir, safeName);
   const label = serviceLabel(safeName);
-  try {
-    await options.exec("launchctl", ["bootout", domainTarget(options.uid), paths.launchAgentPath]);
+  const stopped = await bootoutAllDomains(options.exec, options.uid, paths.launchAgentPath);
+  if (stopped) {
     options.io.stdout.write(`Stopped runner service ${label}.
 `);
-  } catch {
+  } else {
     options.io.stdout.write(`Runner service ${label} was not running.
 `);
   }
@@ -55365,8 +55392,8 @@ async function restartService(options) {
   const safeName = safeRunnerName(options.runnerName);
   const label = serviceLabel(safeName);
   try {
-    await options.exec("launchctl", ["kickstart", "-k", serviceTarget(options.uid, label)]);
-    options.io.stdout.write(`Restarted runner service ${label}.
+    const target = await kickstartService(options.exec, options.uid, label);
+    options.io.stdout.write(`Restarted runner service ${label} at ${target}.
 `);
     return 0;
   } catch (error51) {
@@ -55386,13 +55413,14 @@ async function statusService(options) {
   const label = serviceLabel(safeName);
   const installed = await fileExists(paths.launchAgentPath);
   try {
-    const { stdout } = await options.exec("launchctl", ["print", serviceTarget(options.uid, label)]);
-    const state = extractLaunchdState(stdout);
+    const printed = await printService(options.exec, options.uid, label);
+    const state = extractLaunchdState(printed.stdout);
     options.io.stdout.write(
       `${[
         `runner service: ${label}`,
         `installed: ${installed ? "yes" : "no"}`,
         `loaded: yes`,
+        `domain: ${printed.target}`,
         `state: ${state ?? "unknown"}`,
         `plist: ${paths.launchAgentPath}`,
         `logs: ${paths.logDir}`
@@ -55510,17 +55538,72 @@ function safeRunnerName(runnerName) {
 function serviceLabel(safeName) {
   return `com.${cliBrand.binName}.runner.${safeName}`;
 }
-function domainTarget(uid) {
-  return `user/${uid}`;
+function launchdDomains(uid) {
+  return [`user/${uid}`, `gui/${uid}`];
 }
-function serviceTarget(uid, label) {
-  return `user/${uid}/${label}`;
+function serviceTargets(uid, label) {
+  return launchdDomains(uid).map((domain2) => `${domain2}/${label}`);
 }
 async function bootoutQuietly(exec, uid, plistPath) {
-  try {
-    await exec("launchctl", ["bootout", domainTarget(uid), plistPath]);
-  } catch {
+  await bootoutAllDomains(exec, uid, plistPath);
+}
+async function bootoutAllDomains(exec, uid, plistPath) {
+  let bootedOut = false;
+  for (const domain2 of launchdDomains(uid)) {
+    try {
+      await exec("launchctl", ["bootout", domain2, plistPath]);
+      bootedOut = true;
+    } catch {
+    }
+  }
+  return bootedOut;
+}
+async function bootstrapService(exec, uid, plistPath) {
+  const errors = [];
+  for (const domain2 of launchdDomains(uid)) {
+    try {
+      await exec("launchctl", ["bootstrap", domain2, plistPath]);
+      return { domain: domain2, alreadyLoaded: false };
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      if (isLaunchdAlreadyLoadedError(message)) {
+        return { domain: domain2, alreadyLoaded: true };
+      }
+      errors.push(`${domain2}: ${message}`);
+    }
+  }
+  throw new Error(errors.join("; "));
+}
+function isLaunchdAlreadyLoadedError(message) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("service is already loaded") || normalized.includes("service already loaded") || normalized.includes("already bootstrapped") || normalized.includes("already exists");
+}
+async function kickstartService(exec, uid, label) {
+  const errors = [];
+  for (const target of serviceTargets(uid, label)) {
+    try {
+      await kickstartServiceTarget(exec, target);
+      return target;
+    } catch (error51) {
+      errors.push(`${target}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    }
+  }
+  throw new Error(errors.join("; "));
+}
+async function kickstartServiceTarget(exec, target) {
+  await exec("launchctl", ["kickstart", "-k", target]);
+}
+async function printService(exec, uid, label) {
+  const errors = [];
+  for (const target of serviceTargets(uid, label)) {
+    try {
+      const { stdout } = await exec("launchctl", ["print", target]);
+      return { target, stdout };
+    } catch (error51) {
+      errors.push(`${target}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    }
   }
+  throw new Error(errors.join("; "));
 }
 function unsupportedPlatform(io, platform2) {
   io.stderr.write(