@commonlyai/cli 0.1.45 → 0.1.48

package/package.json

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

package/src/commands/agent.js

@@ -33,6 +33,7 @@ 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 { ADAPTERS_WITH_DEFAULT_MCP, defaultMcpServers } from '../lib/default-environment.js';
 import {
   FOCUS_FRAME_MAX_CODE_POINTS,
   formatPodFocusFrame,
@@ -247,14 +248,9 @@ const PRIVATE_RESPONSE_EVENT_TYPES = new Set(['agent.ask', 'agent.ask.response']
 
 // ── default environment for adapters that benefit from auto-MCP wiring ─────
 
-// Adapters that can consume `mcp[]` from the resolved environment spec.
-// `claude` reads it via --mcp-config (see adapters/claude.js); `codex` via
-// `-c mcp_servers.*` config overrides (see adapters/codex.js — added after
-// the 2026-07-22 as-operator attribution incident, where an MCP-less codex
-// agent posted through the operator's CLI profile because it had no
-// commonly_* tools of its own). `stub` does not. Returning null means "no
-// default" — the wrapper proceeds with environment=null exactly like before.
-const ADAPTERS_WITH_DEFAULT_MCP = new Set(['claude', 'codex', 'pi']);
+// Which adapters can consume `mcp[]`, and the server declaration they get by
+// default, live in lib/default-environment.js — the daemon's per-seat token
+// provisioning reads the same module, so the two can never drift apart.
 const CODEX_PERMISSION_PROFILE_MIN_VERSION = [0, 138, 0];
 
 const versionAtLeast = (version, minimum) => {
@@ -285,23 +281,11 @@ const BUNDLED_COMMONLY_SKILL_DIR = pathResolve(
 // reply conversationally, use the roster, don't double-post). Without the
 // skill, wrapper-spawned CLIs fly blind and behave inconsistently — some
 // narrate after tool-posting (double-post), some default to NO_REPLY on a
-// normal question. ${COMMONLY_API_URL} / ${COMMONLY_AGENT_TOKEN} are
-// substituted at spawn-time by the adapter so the env file stays secret-free.
+// normal question. Returning null means "no default" — a non-consuming adapter
+// proceeds with environment=null exactly like before.
 export const buildDefaultEnvironment = (adapterName) => {
   if (!ADAPTERS_WITH_DEFAULT_MCP.has(adapterName)) return null;
-  const environment = {
-    mcp: [
-      {
-        name: 'commonly',
-        transport: 'stdio',
-        command: ['npx', '-y', '@commonlyai/mcp@latest'],
-        env: {
-          COMMONLY_API_URL: '${COMMONLY_API_URL}',
-          COMMONLY_AGENT_TOKEN: '${COMMONLY_AGENT_TOKEN}',
-        },
-      },
-    ],
-  };
+  const environment = { mcp: defaultMcpServers(adapterName) };
   // Only advertise the skill if it actually shipped (defensive: a broken
   // package that dropped the skills/ dir shouldn't hand mountSkills a
   // missing-source path every spawn).

package/src/lib/adapters/pi.js

@@ -34,7 +34,7 @@
 
 import { spawn as childSpawn, spawnSync } from 'child_process';
 import { createHash, randomUUID } from 'crypto';
-import { mkdir, writeFile } from 'fs/promises';
+import { mkdir, readdir, writeFile } from 'fs/promises';
 import { homedir } from 'os';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
@@ -127,6 +127,24 @@ export const seatHome = (ctx) => {
   return ctx._piHome || join(homedir(), '.commonly', 'pi-homes', hash);
 };
 
+/**
+ * Only a session pi wrote can be resumed. The wrapper persists one id per
+ * (agent, pod) across adapters, so a seat switched from codex hands pi the
+ * codex thread id on its first turn — pi answers `No session found` and the
+ * turn fails (sprint-impl's first spawn, 2026-09-18 05:06Z). pi's session
+ * files are `<timestamp>_<id>.jsonl` under the seat's session dir; an id with
+ * no file starts a fresh session under a new id, which the wrapper persists.
+ */
+export const sessionExists = async (sessionDir, sessionId) => {
+  if (!sessionId) return false;
+  try {
+    const files = await readdir(sessionDir);
+    return files.some((name) => name.endsWith(`_${sessionId}.jsonl`) || name === `${sessionId}.jsonl`);
+  } catch {
+    return false;
+  }
+};
+
 export const buildArgs = ({
   prompt, provider, model, thinking, sessionId, isResume, sessionDir, bridge,
 }) => [
@@ -196,9 +214,6 @@ export default {
   },
 
   async spawn(prompt, ctx = {}) {
-    const isResume = !!ctx.sessionId;
-    const sessionId = ctx.sessionId || randomUUID();
-    const fullPrompt = buildMemoryPreamble(prompt, ctx.memoryLongTerm, { freshSession: !isResume });
     const provider = resolveProvider(ctx.environment);
     const model = ctx.environment?.model || DEFAULT_MODEL;
     const thinking = thinkingFor(ctx.environment?.effort);
@@ -213,6 +228,12 @@ export default {
     const sessionDir = join(home, 'sessions');
     await mkdir(agentDir, { recursive: true, mode: 0o700 });
     await mkdir(sessionDir, { recursive: true, mode: 0o700 });
+
+    // Resume only what pi wrote; anything else (a codex thread id from before
+    // the switch, a wiped home) starts fresh under a new id.
+    const isResume = await sessionExists(sessionDir, ctx.sessionId);
+    const sessionId = isResume ? ctx.sessionId : randomUUID();
+    const fullPrompt = buildMemoryPreamble(prompt, ctx.memoryLongTerm, { freshSession: !isResume });
     await writeFile(join(agentDir, 'models.json'), `${JSON.stringify(buildModelsJson(provider, model), null, 2)}\n`, { mode: 0o600 });
 
     const servers = resolveMcpServers(ctx.environment?.mcp, ctx);

package/src/lib/daemon-supervisor.js

@@ -2,6 +2,8 @@ import { isDeepStrictEqual } from 'node:util';
 import { homedir } from 'node:os';
 import { isAbsolute, resolve as pathResolve } from 'node:path';
 
+import { withDefaultMcpServer } from './default-environment.js';
+
 /**
  * ADR-026 Phase 2, slice 2: the resident supervision loop behind
  * `commonly daemon run`.
@@ -181,9 +183,14 @@ export const createDaemonSupervisor = ({
         adapterChanged = existing.adapter !== nextAdapter;
       }
       if (wanted) {
-        const nextEnvironment = wanted.declared
+        const merged = wanted.declared
           ? wanted.value
           : { ...(existing.environment || {}), ...wanted.value };
+        // A server-declared environment replaces the local one, so a seat whose
+        // declaration carries no mcp[] would come back tool-less. Re-apply the
+        // shipped default here and below, or the seat silently loses every
+        // commonly_* tool the next time the UI edits its model (TASK-048).
+        const nextEnvironment = withDefaultMcpServer(merged, nextAdapter);
         const workspacePath = workspacePathFor(nextEnvironment);
         const nextRecord = {
           ...existing,
@@ -200,10 +207,32 @@ export const createDaemonSupervisor = ({
         }
       }
       if (adapterChanged) {
-        saveToken(row.agentName, { ...existing, adapter: nextAdapter });
+        // An adapter that consumes mcp[] must not be started on a record that
+        // declares none, even when only the adapter itself changed.
+        const nextEnvironment = withDefaultMcpServer(existing.environment, nextAdapter);
+        saveToken(row.agentName, {
+          ...existing,
+          adapter: nextAdapter,
+          ...(nextEnvironment ? { environment: nextEnvironment } : {}),
+        });
         log('runtime adapter changed — restarting the seat to load it');
         return 'changed';
       }
+      if (!wanted) {
+        // A record written by a CLI older than the shipped default carries no
+        // mcp[] — the c4-smoke record was exactly this, and the operator had to
+        // hand-add the entry. Behind a row that declares nothing there is no
+        // other write path: the record is never touched again, so the seat
+        // stays tool-less for as long as it runs. Heal it here, and only when
+        // the environment actually changed — otherwise every tick rewrites the
+        // file and restarts the seat forever.
+        const nextEnvironment = withDefaultMcpServer(existing.environment, existing.adapter);
+        if (!isDeepStrictEqual(existing.environment || null, nextEnvironment || null)) {
+          saveToken(row.agentName, { ...existing, environment: nextEnvironment });
+          log('record predates the commonly MCP baseline — restarting the seat to load it');
+          return 'changed';
+        }
+      }
       return 'ready';
     }
     const requestedAdapter = row.runtime && typeof row.runtime === 'object'
@@ -246,6 +275,13 @@ export const createDaemonSupervisor = ({
       return false;
     }
     const environment = environmentFor(row);
+    // A seat installed server-side (no local `agent attach`) arrives with no
+    // mcp[] at all: without the default it spawns a CLI that has no commonly_*
+    // tools and cannot post. See lib/default-environment.js.
+    const recordEnvironment = withDefaultMcpServer(
+      environment ? environment.value : null,
+      adapter,
+    );
     saveToken(row.agentName, {
       agentName: row.agentName,
       instanceId: row.instanceId,
@@ -253,9 +289,9 @@ export const createDaemonSupervisor = ({
       instanceUrl: record.instanceUrl,
       podId: row.podIds?.[0] || null,
       adapter,
-      ...(environment ? { environment: environment.value } : {}),
-      ...(environment?.value ? (() => {
-        const workspacePath = workspacePathFor(environment.value);
+      ...(recordEnvironment ? { environment: recordEnvironment } : {}),
+      ...(recordEnvironment ? (() => {
+        const workspacePath = workspacePathFor(recordEnvironment);
         return workspacePath ? { workspacePath } : {};
       })() : {}),
     });

package/src/lib/default-environment.js

@@ -0,0 +1,70 @@
+/**
+ * The commonly MCP server every wrapper seat gets by default (ADR-008 `mcp[]`).
+ *
+ * One declaration, three consumers: `agent attach`, the COMMONLY_AGENT_TOKEN
+ * bootstrap in `agent run`, and the daemon's per-seat token provisioning. The
+ * third consumer was missing until 2026-09-18 — a seat installed server-side
+ * (nobody ever ran `agent attach` on that host) got a token record carrying
+ * runtime model/effort and no `mcp[]` at all, so the CLI it spawned had no
+ * `commonly_*` tools and could not post; the operator hand-added the entry to
+ * get the seat working (C4 run, TASK-048).
+ *
+ * Only adapters with a real `mcp[]` consumption path get a default:
+ *   claude — `--mcp-config` (adapters/claude.js)
+ *   codex  — `-c mcp_servers.*` overrides (adapters/codex.js; added after the
+ *            2026-07-22 as-operator attribution incident, where an MCP-less
+ *            codex agent posted through the operator's own CLI profile because
+ *            it had no commonly_* tool of its own)
+ *   pi     — stdio servers from the environment spec (adapters/pi.js)
+ * `stub` has no consumption path and must keep being handed `environment: null`.
+ *
+ * The placeholders are substituted at spawn time by the adapter, so the
+ * declaration itself carries no secret and is safe to persist to a token file.
+ */
+
+export const ADAPTERS_WITH_DEFAULT_MCP = new Set(['claude', 'codex', 'pi']);
+
+export const COMMONLY_MCP_SERVER_NAME = 'commonly';
+
+export const commonlyMcpServer = () => ({
+  name: COMMONLY_MCP_SERVER_NAME,
+  transport: 'stdio',
+  command: ['npx', '-y', '@commonlyai/mcp@latest'],
+  env: {
+    COMMONLY_API_URL: '${COMMONLY_API_URL}',
+    COMMONLY_AGENT_TOKEN: '${COMMONLY_AGENT_TOKEN}',
+  },
+});
+
+/** The default `mcp[]` for an adapter, or [] when it has no consumption path. */
+export const defaultMcpServers = (adapterName) => (
+  ADAPTERS_WITH_DEFAULT_MCP.has(adapterName) ? [commonlyMcpServer()] : []
+);
+
+/**
+ * Ensure `environment` declares the commonly MCP server, touching nothing that
+ * is already declared.
+ *
+ * The predicate is "is there an mcp entry named commonly?", not "is mcp[]
+ * absent?" — the daemon projects live room grants into this same array, so a
+ * seat can arrive with `mcp: [<grant broker>]` and no kernel server, and it is
+ * exactly as tool-less as one with no `mcp` key at all.
+ *
+ * Returns the SAME reference when nothing needs adding, so callers can use the
+ * identity as a dirty check. A declared commonly entry is never replaced or
+ * duplicated — an operator's hand-set command (a pinned version, a staging
+ * checkout) wins over the shipped default — and a non-consuming adapter is
+ * returned untouched. A malformed (non-object) spec is not ours to repair.
+ */
+export const withDefaultMcpServer = (environment, adapterName) => {
+  if (!ADAPTERS_WITH_DEFAULT_MCP.has(adapterName)) return environment;
+  if (environment !== null && environment !== undefined
+    && (typeof environment !== 'object' || Array.isArray(environment))) {
+    return environment;
+  }
+  const declared = Array.isArray(environment?.mcp) ? environment.mcp : null;
+  if (declared && declared.some((server) => server?.name === COMMONLY_MCP_SERVER_NAME)) {
+    return environment;
+  }
+  return { ...(environment || {}), mcp: [...(declared || []), commonlyMcpServer()] };
+};