@commonlyai/cli 0.1.69 → 0.1.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonlyai/cli",
-  "version": "0.1.69",
+  "version": "0.1.71",
   "license": "Apache-2.0",
   "description": "The Commonly CLI — connect agents, manage pods, iterate fast",
   "type": "module",

package/src/commands/agent.js

@@ -32,8 +32,9 @@ import { readLongTerm, syncBack } from '../lib/memory-bridge.js';
 import { pollRetryPolicy } from '../lib/poll-retry.js';
 import { detectMemorySources, composeImport, importMemory } from '../lib/memory-import.js';
 import { detectSkills, importSkills } from '../lib/skills-import.js';
-import { parseEnvironmentFile, resolveWorkspace, validateEnvironmentSpec } from '../lib/environment.js';
+import { normalizeSandboxTrust, parseEnvironmentFile, resolveWorkspace, validateEnvironmentSpec } from '../lib/environment.js';
 import { ADAPTERS_WITH_DEFAULT_MCP, defaultMcpServers } from '../lib/default-environment.js';
+import { withholdGrantBroker } from '../lib/grant-broker-guard.js';
 import {
   FOCUS_FRAME_MAX_CODE_POINTS,
   formatPodFocusFrame,
@@ -330,8 +331,14 @@ export const assertSandboxDeclaredForPublicPod = async ({
 }) => {
   if (!podId || !client) return;
 
-  const mode = environment?.sandbox?.mode;
-  const trust = environment?.sandbox?.trust;
+  // Normalized FIRST (Vera 71715, Wren 71718): the predicate below reads a
+  // legacy `internal` record as the `public` it means, the same mapping the
+  // attach gate and both adapters use. Reading it raw refused a record that
+  // means public one call before the gate #1840 fixes — TASK-113 claims
+  // attach's inconsistent derivation is closed, and this path is attach's.
+  const sandbox = normalizeSandboxTrust(environment?.sandbox);
+  const mode = sandbox?.mode;
+  const trust = sandbox?.trust;
   // An ENFORCED declaration is one the adapters act on: a public trust (whose
   // mode they resolve per host at spawn) or an explicit non-'none' mode. This
   // mirrors the daemon's predicate in lib/default-environment.js, so the shape
@@ -476,6 +483,70 @@ export const updateAgentConfiguration = async ({
 
 // ── attach: register a local-CLI-wrapped agent (ADR-005) ────────────────────
 
+/**
+ * The sandbox an attach will actually run under — derived, then gated.
+ *
+ * The trust is normalized ONCE, before it is used for anything. A stored
+ * `internal` means `public` (environment.js, Wren 69585), and resolving the mode
+ * off the raw value made this gate disagree with the adapters in BOTH
+ * directions: `{ trust: 'internal' }` with no declared mode left the attach-time
+ * mode at `'none'` and refused nothing here, and `internal` beside
+ * `mode: 'workspace'` was refused outright as "implemented only for public codex
+ * or Claude adapters" — turning away a record both adapters confine happily.
+ *
+ * This does NOT take the confinement decision from the adapters. They normalize
+ * and re-derive from the environment themselves (claude.js:615, codex.js:546) and
+ * the attach-time value never reaches them, so a legacy record was confined
+ * either way; what was wrong is that this gate's verdict contradicted theirs, and
+ * its refusal for the `mode: 'none'` shape landed later, at adapter spawn, after
+ * attach had already published and minted. Normalizing here makes the two agree
+ * and puts the refusal where the user can see it (Kai, TASK-113; re-measured at
+ * source after Vera 71664).
+ *
+ * Whether the resolved mode is AVAILABLE here — bwrap installed, macOS for
+ * Seatbelt, the codex permission-profile version — is deliberately not this
+ * function's question: that needs the host and the detected version and stays at
+ * the call site. What an adapter can honour at all is just a mode and a name, so
+ * that check is in here, with witnesses of both signs.
+ *
+ * Why this gate was the one that disagreed: the resolver compared the RAW trust,
+ * so a caller that did not normalize first read a legacy `internal` record as
+ * non-public. The adapters normalize at their own entry (claude.js:615,
+ * codex.js:546) and passed the normalized object on, which is why their suites
+ * confined a legacy record all along; the grant-broker guard normalized for its
+ * own trust check and then handed the resolver the raw object, so its symptom was
+ * a false `sandbox_mode_unenforceable` refusal (Vera 71676). Both are settled on
+ * main now — the resolver reads the effective trust (mode.js:38) and the guard
+ * imports the same reader from environment.js (grant-broker-guard.js:186) — so
+ * this helper needs no coupling to them: it normalizes once, here, before its own
+ * two gates, because those gates compare `trust` directly.
+ */
+export const resolveAttachSandbox = ({
+  environment, adapterName, platform = process.platform,
+} = {}) => {
+  const sandbox = normalizeSandboxTrust(environment?.sandbox);
+  const trust = sandbox?.trust;
+  const mode = sandbox?.mode
+    || (trust === 'public' ? resolvePublicSandboxMode(sandbox, platform) : 'none');
+  if (trust === 'public' && mode === 'none') {
+    throw new Error(
+      'sandbox.trust=public requires an enforced sandbox mode; refusing to attach unsandboxed',
+    );
+  }
+  // Moved in from the call site (Vera 71675): this is the check the raw compare
+  // used to fail closed on, refusing `internal` beside `mode: 'workspace'`. It is
+  // pure — a mode and an adapter name — so it belongs with the derivation, and
+  // its witnesses live beside it.
+  if ((mode === 'workspace' || mode === 'read-only')
+    && (trust !== 'public' || !['codex', 'claude'].includes(adapterName))) {
+    throw new Error(
+      `sandbox.mode=${mode} is currently implemented only for public `
+      + 'codex or Claude adapters',
+    );
+  }
+  return { mode, trust };
+};
+
 /**
  * Publish, install, and mint a runtime token for a local-CLI-wrapped agent.
  * Pure core — the commander action wraps this with config loading + logging.
@@ -512,16 +583,7 @@ export const performAttach = async ({
     workspace = await resolveWorkspace(environment, agentName, dirname(envPath));
     log(`workspace: ${workspace.path}${workspace.created ? ' (created)' : ''}`);
 
-    const sandboxMode = environment.sandbox?.mode
-      || (environment.sandbox?.trust === 'public'
-        ? resolvePublicSandboxMode(environment.sandbox)
-        : 'none');
-    const sandboxTrust = environment.sandbox?.trust;
-    if (sandboxTrust === 'public' && sandboxMode === 'none') {
-      throw new Error(
-        'sandbox.trust=public requires an enforced sandbox mode; refusing to attach unsandboxed',
-      );
-    }
+    const { mode: sandboxMode } = resolveAttachSandbox({ environment, adapterName });
     if (sandboxMode === 'bwrap') {
       const bwrap = detectBwrap();
       if (!bwrap.available) {
@@ -534,12 +596,6 @@ export const performAttach = async ({
         );
       }
     } else if (sandboxMode === 'workspace' || sandboxMode === 'read-only') {
-      if (sandboxTrust !== 'public' || !['codex', 'claude'].includes(adapterName)) {
-        throw new Error(
-          `sandbox.mode=${sandboxMode} is currently implemented only for public `
-          + `codex or Claude adapters`,
-        );
-      }
       if (adapterName === 'codex') {
         if (!versionAtLeast(detected.version, CODEX_PERMISSION_PROFILE_MIN_VERSION)) {
           throw new Error(
@@ -872,6 +928,27 @@ export const performRun = ({
   sleepImpl = (ms) => new Promise((resolve) => { setTimeout(resolve, ms); }),
 }) => {
   const client = createClient({ instance: instanceUrl, token });
+
+  // THE SEAT'S OWN RECORD IS THE ONLY DECLARATION THERE IS. The broker reaches a
+  // seat as an injected MCP entry written by hand into its environment — no
+  // server projection puts it there (`GRANT_BROKER_URL` is imported by one
+  // route, the daemon assignment, and that one already refuses). So a seat run
+  // by `commonly agent run` under launchd spawns the entry verbatim, and the
+  // confinement it promises is declared in a different field (`sandbox`), which
+  // can disagree. The daemon half of this refusal already runs
+  // (`daemon-supervisor.js`); this is the same predicate at the only other site
+  // that can see the record — same code, so one refusal with two emitters.
+  //
+  // IN MEMORY, RECORD UNTOUCHED (wren 71641): the withheld environment is what
+  // the adapter spawns with, and the stored record keeps its broker, so the
+  // daemon stays the layer that judges a host it knows. Applied once for the
+  // run rather than per turn: `agent run` reads its record once at boot.
+  const seatEnvironment = withholdGrantBroker(environment, adapter?.name, {
+    instanceUrl,
+    onRefuse: (refusal, names) => log(
+      `${refusal.code} (${refusal.reason}) — withholding ${names.join(', ')}: ${refusal.detail}`,
+    ),
+  });
   let running = true;
   // Stop-after-N-auth-failures: without this, a revoked token leaves the
   // poller hammering 401s forever at 60s backoff — invisible to the user.
@@ -1195,7 +1272,7 @@ export const performRun = ({
       cwd: agentCwd,
       env: process.env,
       memoryLongTerm,
-      environment,
+      environment: seatEnvironment,
       // Runtime context the Claude/Codex adapters expose only to their
       // per-spawn MCP environment. Claude keeps ${COMMONLY_*} placeholders
       // literal on disk and lets its native MCP parser expand them, so the

package/src/lib/default-environment.js

@@ -22,6 +22,8 @@
  * declaration itself carries no secret and is safe to persist to a token file.
  */
 
+import { normalizeSandboxTrust } from './environment.js';
+
 export const ADAPTERS_WITH_DEFAULT_MCP = new Set(['claude', 'codex', 'pi']);
 
 /**
@@ -129,7 +131,12 @@ export const withDefaultSandbox = (environment) => {
     && (typeof environment !== 'object' || Array.isArray(environment))) {
     return environment;
   }
-  const sandbox = environment?.sandbox;
+  // Normalized first (Wren 71719): `assertSandboxDeclaredForPublicPod`'s own
+  // comment says this predicate mirrors it, and a legacy `internal` record
+  // means `public` to both. Read raw, this one replaced a record the attach
+  // gate accepts — benign (same effective trust) but not a mirror, and the
+  // comment would be false. The ORIGINAL block is what gets returned below.
+  const sandbox = normalizeSandboxTrust(environment?.sandbox);
   // An ENFORCED declaration is one the adapters act on: a public trust (whose
   // mode they resolve, and refuse to spawn without) or an explicit non-'none'
   // mode. `mode: 'none'`, an empty block and a missing one are all the same

package/src/lib/environment.js

@@ -69,6 +69,22 @@ export const normalizeSandboxTrust = (sandbox) => (
     ? { ...sandbox, trust: LEGACY_SANDBOX_TRUST[sandbox.trust] }
     : sandbox
 );
+/**
+ * A declared trust resolved THROUGH the legacy table: `internal` → `public`,
+ * anything else (including absent) is itself.
+ *
+ * Exported so every gate reads the mapping once. `normalizeSandboxTrust` above
+ * rewrites a whole sandbox object; this is the scalar form for a site that only
+ * compares the trust and must not write anything back. The server spells the
+ * same predicate `effectiveSandboxTrust` (`grantBrokerConfinement.ts`) — the two
+ * sides have to read `internal` the same way or one of them confines a seat the
+ * other withholds from (Wren 71662).
+ */
+export const effectiveSandboxTrust = (trust) => (
+  typeof trust === 'string' && Object.prototype.hasOwnProperty.call(LEGACY_SANDBOX_TRUST, trust)
+    ? LEGACY_SANDBOX_TRUST[trust]
+    : trust
+);
 
 const expandHome = (p) => {
   if (!p || typeof p !== 'string') return p;

package/src/lib/grant-broker-guard.js

@@ -74,7 +74,7 @@
  */
 import { isGrantBrokerUrl } from './adapters/pi-mcp-client.mjs';
 import { ADAPTERS_WITH_DEFAULT_SANDBOX } from './default-environment.js';
-import { LEGACY_SANDBOX_TRUST } from './environment.js';
+import { effectiveSandboxTrust } from './environment.js';
 import { PUBLIC_SANDBOX_MODES, resolvePublicSandboxMode } from './sandbox/mode.js';
 
 /** One typed code, two emitters (`decidedBy` says which one spoke). */
@@ -92,13 +92,6 @@ export const ENFORCING_MODES = new Set([...PUBLIC_SANDBOX_MODES, 'bwrap']);
 const URL_PLACEHOLDERS = ['${COMMONLY_API_URL}', '${COMMONLY_INSTANCE_URL}'];
 const PARSE_ANCHOR = 'https://grant-declaration.invalid';
 
-/** `internal` → `public`; anything else (including absent) is itself. */
-const effectiveTrust = (trust) => (
-  typeof trust === 'string' && Object.prototype.hasOwnProperty.call(LEGACY_SANDBOX_TRUST, trust)
-    ? LEGACY_SANDBOX_TRUST[trust]
-    : trust
-);
-
 /**
  * A bound instance is only trimmed here (`agent.js` does the same). Any
  * trailing slash it carries is deliberately left alone: the doubled slash it
@@ -190,7 +183,7 @@ export const confinementReason = (environment, adapter, platform = process.platf
   if (sandbox === null || typeof sandbox !== 'object' || Array.isArray(sandbox)) return 'sandbox_absent';
   const declared = sandbox;
   if (declared.mode === 'none') return 'sandbox_mode_none';
-  if (effectiveTrust(declared.trust) !== 'public') return 'sandbox_trust_not_public';
+  if (effectiveSandboxTrust(declared.trust) !== 'public') return 'sandbox_trust_not_public';
   const mode = resolvePublicSandboxMode(declared, platform);
   if (typeof mode !== 'string' || !ENFORCING_MODES.has(mode)) return 'sandbox_mode_unenforceable';
   return null;
@@ -220,7 +213,7 @@ const detailFor = (reason, adapter, environment) => {
   }
   const trust = environment?.sandbox?.trust;
   const shown = trust === undefined ? 'absent' : `'${String(trust)}'`;
-  return `the declared sandbox.trust is ${shown}${shown === 'absent' ? '' : ` (effective '${String(effectiveTrust(trust))}')`},`
+  return `the declared sandbox.trust is ${shown}${shown === 'absent' ? '' : ` (effective '${String(effectiveSandboxTrust(trust))}')`},`
     + " and no host confines a seat whose trust is not 'public'; declare sandbox.trust 'public'" + ` ${drop}`;
 };
 

package/src/lib/sandbox/mode.js

@@ -12,23 +12,30 @@
  *   darwin  → 'workspace' (the claude adapter maps it to Seatbelt)
  *   else    → 'bwrap'     (bubblewrap; attach checks it is installed)
  *
- * Resolution is PUBLIC-only on purpose. A non-public declaration keeps whatever
- * mode it wrote, and an adapter that cannot enforce it is expected to refuse
- * rather than quietly spawn unconfined. An explicit mode on a public
- * declaration still wins — including a wrong one, which the caller then
- * refuses (Vera 69548: an unresolvable public mode must not fall through to a
- * bare, unconfined spawn).
+ * Resolution is PUBLIC-only on purpose, and PUBLIC IS THE EFFECTIVE TRUST: a
+ * legacy `internal` declaration reads as `public` (environment.js, Wren 69585),
+ * so the mapping is applied before this comparison. Comparing the raw value
+ * made `{ trust: 'internal' }` resolve to no mode at all — the mapping was
+ * applied in `confinementReason` and not here, which is half a rule, and the
+ * half that failed was the one that WITHHOLDS: the grant broker was taken from
+ * a seat this daemon would have confined. A non-public declaration keeps
+ * whatever mode it wrote, and an adapter that cannot enforce it is expected to
+ * refuse rather than quietly spawn unconfined. An explicit mode on a public
+ * declaration still wins — including a wrong one, which the caller then refuses
+ * (Vera 69548: an unresolvable public mode must not fall through to a bare,
+ * unconfined spawn).
  *
  * NOT used by the codex adapter. Codex's `mode` is read-vs-write access, not a
  * host mechanism — its permission profiles run on both platforms — so its
  * derived default is 'workspace' everywhere.
  */
+import { effectiveSandboxTrust } from '../environment.js';
 
 export const PUBLIC_SANDBOX_MODES = new Set(['workspace', 'read-only']);
 
 export const resolvePublicSandboxMode = (sandbox, platform = process.platform) => {
   const declared = sandbox?.mode;
-  if (sandbox?.trust !== 'public') return declared;
+  if (effectiveSandboxTrust(sandbox?.trust) !== 'public') return declared;
   if (declared !== undefined && declared !== null) return declared;
   return platform === 'darwin' ? 'workspace' : 'bwrap';
 };