@ctrl-spc/cs 0.7.1 → 0.7.3

package/README.md

@@ -43,7 +43,7 @@ cs                Open the Companion app (the front door)
 cs open           Open the Companion app in your browser
 cs login          Sign in from the terminal and link this computer
 cs start          Come online now, no window (used by auto-start)
-cs status         Show sign-in state, computer, and detected agents
+cs status         Show the whole setup state and the one next step to take
 cs autostart on   Come online automatically at login
 cs autostart off  Stop coming online at login
 cs logout         Sign this computer out

package/dist/codex-home.js

@@ -195,11 +195,15 @@ export function codexRunConfigToml(server, runTodoId, runtimePlatform = process.
  * codex worker reached for it instead of this product's `dispatch` tool;
  * no level 3 run was ever started through the record.
  *
- * Codex 0.148 made `multi_agent` the stable feature switch and changed
- * `[agents]` into a role table. The old `[agents] enabled = false` now makes
- * the current Desktop runtime reject the whole config before a run starts.
- * `features.multi_agent = false` is therefore the surface-level absence rule
- * on the current runtime, matching the documented configuration contract.
+ * `[agents] enabled = false` is the ONLY key that removes it, and it is
+ * MEASURED, never read off documentation. `features.multi_agent = false` is
+ * the trap: it parses, it reads like the answer, and the tool is still there.
+ * Re-measured 2026-08-25 by spawning codex with each config and asking it to
+ * delegate: with `multi_agent = false` the stream still carries
+ * `collab_tool_call`, and the agent then quietly did the work itself; with
+ * `[agents] enabled = false` the tool is gone and the run starts normally.
+ * Checked on 0.149.0-alpha.4.1 (macOS) and 0.148.0-alpha.8 (Windows), so the
+ * claim that a newer runtime rejects this key does not hold on either.
  *
  * v2's claude workers are deliberately still granted `Task` (see
  * `orchestrator.ts`), so this is an EXPLICIT argument rather than a change to
@@ -228,8 +232,8 @@ subagentsEnabled = true, persistentPanelOwner = false) {
         /* The account's own connectors, which no config.toml grants and no argv
            removes. See the block comment above. */
         'apps = false',
-        ...(!subagentsEnabled ? ['multi_agent = false'] : []),
         '',
+        ...(!subagentsEnabled ? ['[agents]', 'enabled = false', ''] : []),
     ];
     /* Native Windows must name its sandbox implementation. Without this block,
        codex silently resolves a requested workspace-write run as read-only and

package/dist/config.js

@@ -234,6 +234,23 @@ export function companionToken() {
 export function mcpToken() {
     return persistentToken('mcp-token');
 }
+/**
+ * The stored mcp token, or null when this install has never minted one. Unlike
+ * mcpToken(), it never creates the file — a read-only command (`cs status`)
+ * must not mint a token as a side effect of reporting state, and "no token" is
+ * itself the honest answer to whether anything could be registered yet.
+ */
+export function readMcpToken() {
+    const path = filePath('mcp-token');
+    if (!existsSync(path))
+        return null;
+    try {
+        return readFileSync(path, 'utf8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
 function persistentToken(name) {
     const path = filePath(name);
     if (existsSync(path)) {

package/dist/index.js

@@ -4,33 +4,106 @@ import { runDaemon } from './daemon.js';
 import { openCompanion } from './companion.js';
 import { autostartOn, autostartOff } from './autostart.js';
 import { detectAgents } from './agents.js';
-import { getMachineIdentity, clearSession } from './config.js';
-import { getClient, NotLoggedIn } from './supabase.js';
+import { getMachineIdentity, clearSession, readSession } from './config.js';
+import { getClient } from './supabase.js';
+import { foreignToolsServerAlive, claudeRegisteredOnDisk, codexRegisteredOnDisk } from './mcp.js';
+import { panelCommand } from './panel3/cli.js';
 const HELP = `cs — CTRL+SPC
 
   cs                Open the Companion app (the front door)
   cs open           Open the Companion app in your browser
   cs login          Sign in from the terminal and link this computer
   cs start          Come online and answer cards, no window (used by auto-start)
-  cs status         Show sign-in state, computer, and detected agents
+  cs status         Show the whole setup state and the one next step to take
   cs autostart on   Come online automatically at login
   cs autostart off  Stop coming online at login
   cs logout         Sign this computer out
+
+  cs say "<text>"                 Start a card and put your message on it
+  cs say --project <p> "<text>"   Start it filed under that project (id or name)
+  cs say --card <id> "<text>"     Add a message to a card you already have
+  cs answer <id> "<text>"         Answer a question a card is waiting on you for
+  cs show                         Every card
+  cs show <id>                    One card in full, or one run with its report
+
   cs help           Show this help
 `;
+/**
+ * The whole setup state, and the ONE next step to take, for an agent — the
+ * reader of this command in every story is Claude Code or Codex, not a person
+ * at a prompt, so every step below addresses the agent and names the user only
+ * for sign-in, which is the one step only the user can take.
+ *
+ * A non-zero exit means "not fully set up", NEVER "a command failed". A machine
+ * mid-setup exits 1 while everything is working correctly.
+ */
 async function status() {
     const id = getMachineIdentity();
-    const agents = detectAgents();
-    console.log(`Computer: ${id.name}`);
-    console.log(`Agents:   ${agents.length ? agents.join(', ') : 'none'}`);
-    try {
-        const client = await getClient();
-        const { data } = await client.auth.getUser();
-        console.log(`Signed in as ${data.user?.email ?? 'unknown'}`);
+    const installed = detectAgents();
+    /* Signed-out is a FILE question, not a network one. getClient() throws
+       NotLoggedIn whenever setSession fails FOR ANY REASON, including a network
+       failure (supabase.ts), so trusting it would tell a signed-in user on bad
+       wifi to go and sign in again — the confident-wrong instruction this feature
+       exists to kill. readSession() returning null is the only true "signed out". */
+    const stored = readSession();
+    let signedIn = false;
+    let email = null;
+    let sessionProblem = null;
+    if (stored) {
+        try {
+            const client = await getClient();
+            const { data } = await client.auth.getUser();
+            email = data.user?.email ?? null;
+            signedIn = true;
+        }
+        catch (err) {
+            /* The REASON only. getClient()'s NotLoggedIn message ends with its own
+               "Run `cs login` again.", which would print twice in the step below. */
+            const raw = err instanceof Error ? err.message : String(err);
+            sessionProblem = raw.replace(/\s*Run `cs login` again\.?\s*$/, '').replace(/\.$/, '');
+        }
+    }
+    const serving = await foreignToolsServerAlive();
+    /* Gated on `serving` because a plain shutdown DELIBERATELY leaves the agent
+       config entries in place (presence.ts), so an ungated read prints
+       "registered" against a daemon that is not there. */
+    const registered = {
+        claude: serving && claudeRegisteredOnDisk(),
+        codex: serving && codexRegisteredOnDisk(),
+    };
+    console.log(`Computer:  ${id.name}`);
+    console.log(`Signed in: ${signedIn ? (email ?? 'unknown') : stored ? 'saved sign-in unusable' : 'Not signed in'}`);
+    console.log(`Daemon:    ${serving ? 'running' : 'not running'}`);
+    console.log(`Agents:    ${installed.length ? installed.join(', ') : 'none installed'}`);
+    for (const agent of installed) {
+        console.log(`  ${agent.padEnd(8)} ${registered[agent] ? 'registered' : 'not registered'}`);
+    }
+    console.log('');
+    const unregistered = installed.filter((a) => !registered[a]);
+    if (!stored) {
+        console.log('Nobody is signed in. Ask the user to run `cs login` themselves: it opens a');
+        console.log('browser and waits up to five minutes, so do not run it yourself. They sign in');
+        console.log('with the same email and password they use on ctrl-spc.com. Then run `cs status`');
+        console.log('again.');
+    }
+    else if (!signedIn) {
+        console.log(`The saved sign-in could not be used: ${sessionProblem ?? 'unknown'}. Ask the user to run`);
+        console.log('`cs login` again.');
+    }
+    else if (!serving) {
+        console.log('Nothing is serving the tools. `cs start` never exits on its own, so start it in');
+        console.log('the background and leave it running, then run `cs status` again.');
+    }
+    else if (unregistered.length) {
+        console.log(`The tools are being served but are not registered into ${unregistered.join(' or ')}. Restart the`);
+        console.log('background daemon, then run `cs status` again.');
     }
-    catch (err) {
-        console.log(err instanceof NotLoggedIn ? 'Not signed in. Run `cs login`.' : `Session error: ${err.message}`);
+    else {
+        console.log('Tools are registered. If this agent cannot see them, restart it. An agent picks');
+        console.log('up MCP servers only when it starts.');
+        return;
     }
+    process.exitCode = 1;
 }
 async function main() {
     const cmd = process.argv[2];
@@ -44,6 +117,14 @@ async function main() {
         case 'logout':
             console.log(clearSession() ? 'Signed out.' : 'Was not signed in.');
             return;
+        /* THE PANEL'S OWN COMMANDS, ROUTED WHOLE. The person types one CLI, so the
+           card commands are `cs` subcommands; the argument handling stays inside
+           `panel3/`, which is the one import this file makes into it (named in
+           `test/panel3-isolation.contract.test.mjs`). */
+        case 'say':
+        case 'answer':
+        case 'show':
+            return panelCommand(process.argv.slice(2));
         case 'autostart':
             if (arg === 'on')
                 return autostartOn();

package/dist/login.js

@@ -137,7 +137,15 @@ function renderPage(state) {
   input { padding:8px 10px; font-size:14px; border:1px solid #ccc; border-radius:6px; }
   button[type=submit] { margin-top:6px; padding:9px; border:none; border-radius:6px; background:#111; color:#fff; cursor:pointer; }
   .error { color:#c0392b; font-size:13px; min-height:16px; }
-  @media (prefers-color-scheme: dark){ body{background:#111;color:#eee;} input{background:#1c1c1c;border-color:#333;color:#eee;} button[type=submit]{background:#eee;color:#111;} }
+  @media (prefers-color-scheme: dark){
+    body{background:#111;color:#eee;} p.sub{color:#999;}
+    input{background:#1c1c1c;border-color:#333;color:#eee;}
+    button[type=submit]{background:#eee;color:#111;}
+    .tabs{border-bottom-color:#333;}
+    .tabs button{color:#999;}
+    .tabs button.active{color:#fff;border-bottom-color:#fff;}
+    .error{color:#ff6b5e;}
+  }
 </style></head><body>
 <div id="app">
   <h1>CTRL+SPC</h1><p class="sub">Sign in to link this computer.</p>

package/dist/mcp.js

@@ -13,7 +13,7 @@ import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { TOOLS_SERVER_PORT, SESSION_TTL_MS } from './env.js';
 import { agentPath } from './agents.js';
-import { mcpToken, readSession } from './config.js';
+import { mcpToken, readMcpToken, readSession } from './config.js';
 import { readPngScreenshot, } from './screenshots.js';
 /* 18c Slice 7 correction: the product captures the PNG itself, because a
    spawned worker has no reachable way to run a capture command. The whole
@@ -4756,7 +4756,13 @@ export async function listCredentialsHandler(client) {
  * returns `{secret, username}`; that maps to screen 8's shapes —
  * api_key → `{kind, secret}`, login → `{kind, username, password}`.
  */
-export async function getCredentialHandler(client, args, 
+export async function getCredentialHandler(client, 
+// `id` is the web's copy-for-agent handle, and it is the ONLY thing that can
+// resolve the ambiguity the name path can only report: names are unique per
+// (org, creator), so two credentials the caller can read may share one, and
+// by name this tool could previously do nothing but tell the user to go
+// rename something. A pasted id names the row the user actually clicked.
+args, 
 // 18d Slice 3. OPTIONAL and trailing, so the existing two-argument call sites
 // (and their tests) are untouched. Absent means "not a run" — see
 // `rememberSecret`.
@@ -4765,26 +4771,38 @@ runTodoId = null) {
     // whatever casing the agent happened to type: the match below is
     // case-insensitive, so "talenttrack read token" must still redact as
     // "[redacted: TalentTrack read token]".
+    const wantedId = typeof args.id === 'string' ? args.id.trim() : '';
+    if (!wantedId && !args.name) {
+        return errorResult('get_credential requires name — as listed by list_credentials.');
+    }
     let match;
     try {
         const rows = (await must(client
             .from('credentials')
             .select('id, name, kind, org_id, created_by')
             .order('created_at', { ascending: true }))) ?? [];
-        const wanted = args.name.toLowerCase();
-        // Uniqueness is per (org, creator): the caller can see two credentials
-        // with the same lowercased name across two of their orgs, or within one
-        // org (their own plus one shared to them by another creator). Never guess
-        // which secret was meant. org_id/created_by are read only to word this
-        // error; they never appear in tool output.
-        const matches = rows.filter((row) => row.name.toLowerCase() === wanted);
-        if (matches.length > 1) {
-            const sameOrg = matches.every((row) => row.org_id === matches[0].org_id);
-            return errorResult(sameOrg
-                ? `credential name "${args.name}" is ambiguous — you can access more than one credential with this name in the same organization (e.g. your own and one shared with you); delete or re-create yours under a different name, or ask an org owner to revoke a shared copy`
-                : `credential name "${args.name}" is ambiguous — you have access to credentials with this name in more than one of your organizations; delete or re-create one under a different name`);
-        }
-        match = matches[0];
+        if (wantedId) {
+            // An id names one row, so there is no ambiguity branch to reach. RLS
+            // already filtered the rows, so a credential the caller cannot read is
+            // simply absent and falls through to the uniform not-found below.
+            match = rows.find((row) => row.id === wantedId);
+        }
+        else {
+            const wanted = args.name.toLowerCase();
+            // Uniqueness is per (org, creator): the caller can see two credentials
+            // with the same lowercased name across two of their orgs, or within one
+            // org (their own plus one shared to them by another creator). Never guess
+            // which secret was meant. org_id/created_by are read only to word this
+            // error; they never appear in tool output.
+            const matches = rows.filter((row) => row.name.toLowerCase() === wanted);
+            if (matches.length > 1) {
+                const sameOrg = matches.every((row) => row.org_id === matches[0].org_id);
+                return errorResult(sameOrg
+                    ? `credential name "${args.name}" is ambiguous — you can access more than one credential with this name in the same organization (e.g. your own and one shared with you); delete or re-create yours under a different name, or ask an org owner to revoke a shared copy`
+                    : `credential name "${args.name}" is ambiguous — you have access to credentials with this name in more than one of your organizations; delete or re-create one under a different name`);
+            }
+            match = matches[0];
+        }
     }
     catch (err) {
         return errorResult(`get_credential failed: ${err.message}`);
@@ -4978,9 +4996,51 @@ export async function listSkillsHandler(client, args) {
  * survives a compaction — an agent that has lost `get_skill`'s output still has
  * the skill's name in the conversation and can still reach its files.
  */
-async function resolveSkill(client, rawName, rawOrgId, tool) {
+/**
+ * Resolve a skill by its row id — the handle the web's copy-for-agent button
+ * pastes. An id names ONE row, so neither of the name path's two ambiguity
+ * errors can arise and `org_id` has nothing left to disambiguate: the id
+ * already decided which org's skill this is, and the bundle it belongs to says
+ * which org that was. RLS does the access check, so a row the caller cannot see
+ * is simply not found.
+ */
+async function resolveSkillById(client, id, tool) {
+    const rows = (await must(client
+        .from('skills')
+        .select('id, bundle_id, name, description, relative_path, status, status_reason')
+        .eq('id', id)
+        .is('deleted_at', null))) ?? [];
+    const row = rows[0];
+    if (!row) {
+        return {
+            ok: false,
+            error: errorResult(`${tool}: no skill with id ${id}. It may have been deleted, or belong to an organization you ` +
+                'cannot see. Call list_skills to see the skills that exist.'),
+        };
+    }
+    // The bundle is what carries the org, and only a LIVE bundle counts: a skill
+    // row can outlive the archiving of the bundle that brought it in.
+    const bundles = await liveSkillBundles(client, null);
+    const orgId = bundles.find((bundle) => bundle.id === row.bundle_id)?.org_id;
+    if (!orgId) {
+        return {
+            ok: false,
+            error: errorResult(`${tool}: skill "${row.name}" belongs to a skill pack that is no longer active. ` +
+                'Re-import the pack in the web app.'),
+        };
+    }
+    return { ok: true, value: { row, orgId } };
+}
+async function resolveSkill(client, rawName, rawOrgId, tool, 
+// The web's copy-for-agent handle. A name is still the addressing an agent
+// reaches for unaided (it survives a compaction; see this section's header),
+// so `id` is the ALTERNATIVE, not the replacement: it exists because the
+// Skills page copies `/ctrl-spc skill <id>` and a pasted row must resolve to
+// the row the user clicked, never to a same-named skill in another org.
+rawId = undefined) {
+    const wantedId = typeof rawId === 'string' ? rawId.trim() : '';
     const wanted = typeof rawName === 'string' ? rawName.trim() : '';
-    if (!wanted) {
+    if (!wantedId && !wanted) {
         return {
             ok: false,
             error: errorResult(`${tool} requires name — the name of the skill to read, as listed by list_skills.`),
@@ -4989,6 +5049,8 @@ async function resolveSkill(client, rawName, rawOrgId, tool) {
     const filter = skillOrgFilter(rawOrgId, tool);
     if (!filter.ok)
         return filter;
+    if (wantedId)
+        return resolveSkillById(client, wantedId, tool);
     const bundles = await liveSkillBundles(client, filter.value);
     const orgIdByBundle = new Map(bundles.map((bundle) => [bundle.id, bundle.org_id]));
     const rows = orgIdByBundle.size
@@ -5167,7 +5229,7 @@ async function listSkillBundleFiles(client, orgId, bundleId, relativePath) {
 }
 export async function getSkillHandler(client, args) {
     try {
-        const resolved = await resolveSkill(client, args?.name, args?.org_id, 'get_skill');
+        const resolved = await resolveSkill(client, args?.name, args?.org_id, 'get_skill', args?.id);
         if (!resolved.ok)
             return resolved.error;
         const { row: match, orgId } = resolved.value;
@@ -5276,7 +5338,7 @@ export async function readSkillFileHandler(client, args) {
         if (!wantedPath) {
             return errorResult('read_skill_file requires path — one of the paths get_skill listed in bundle_files.');
         }
-        const resolved = await resolveSkill(client, args?.name, args?.org_id, 'read_skill_file');
+        const resolved = await resolveSkill(client, args?.name, args?.org_id, 'read_skill_file', args?.id);
         if (!resolved.ok)
             return resolved.error;
         const { row: match, orgId } = resolved.value;
@@ -5883,6 +5945,58 @@ async function unnarrowedEmptyNote(client, projectId) {
     }
     return NO_PROJECT_DOCUMENTS_NOTE;
 }
+export async function getDocumentHandler(client, args) {
+    const id = typeof args.id === 'string' ? args.id.trim() : '';
+    if (!id) {
+        return errorResult('get_document requires id — the id of the document to read, as the web app’s “Copy for agent” ' +
+            'button pastes it.');
+    }
+    // Shape-checked once, here at the boundary, exactly as resolveContextProject
+    // does with task_id: without it a mistyped id comes back as a Postgres
+    // "invalid input syntax for type uuid", which reads like a bug in the tool.
+    if (!UUID_RE.test(id)) {
+        return errorResult(`get_document: not a valid document id: "${id}".`);
+    }
+    try {
+        // Context documents first, then instructions. RLS scopes both reads, so a
+        // row the caller may not see is simply absent and falls through to the
+        // not-found below.
+        const documents = await must(client
+            .from('project_documents')
+            .select('title, content, codebase_id, type')
+            .eq('id', id));
+        const document = (documents ?? [])[0];
+        if (document)
+            return textResult(shapeDocument(document));
+        const instructions = await must(client.from('agent_instructions').select('title, content, codebase_id').eq('id', id));
+        const instruction = (instructions ?? [])[0];
+        if (instruction) {
+            return textResult({
+                ...shapeDocument(instruction),
+                // Said plainly, so an agent that fetched one does not conclude these are
+                // reference material it may choose to consult: it already has them.
+                note: 'This is an agent instruction. Every instruction on this project is already delivered in ' +
+                    'your prompt — reading one here does not make it optional.',
+            });
+        }
+        return errorResult(`get_document: no document with id ${id}. It may have been deleted, or belong to a project you ` +
+            'cannot see. Call get_project_context to read the documents on the project you are working.');
+    }
+    catch (err) {
+        return errorResult(`get_document failed: ${errorMessage(err)}`);
+    }
+}
+/** The one shape both tables report in, so a caller never has to branch on
+ *  which table answered. `scope` is what `codebase_id` MEANS — null is the
+ *  project's own document, a value is that codebase's. */
+function shapeDocument(row) {
+    return {
+        title: row.title,
+        ...(row.type ? { type: row.type } : {}),
+        scope: row.codebase_id === null ? 'project' : 'codebase',
+        content: row.content,
+    };
+}
 // ---------------------------------------------------------------------------
 // Project context (feature 13a, Phase 4) — `propose_project_context`.
 //
@@ -9802,6 +9916,7 @@ export const TOOL_NAMES = [
     'get_skill',
     'read_skill_file',
     'get_project_context',
+    'get_document',
     'propose_project_context',
     'list_product_ideas',
     'create_product_idea',
@@ -11216,7 +11331,16 @@ runTodoIdSource = null) {
             'comments, artifacts, documents and questions, and name the credential instead. Never refuse the ' +
             'work to avoid touching the value.',
         inputSchema: {
-            name: z.string().min(1).describe('Credential name, as listed by list_credentials'),
+            name: z
+                .string()
+                .min(1)
+                .optional()
+                .describe('Credential name, as listed by list_credentials'),
+            id: z
+                .string()
+                .optional()
+                .describe('Credential id, as pasted by the web app\'s "Copy for agent" button. Use it instead of ' +
+                'name; it names exactly one credential, where a name can be ambiguous.'),
         },
     }, async (args) => {
         touchSession(connectionId);
@@ -11250,7 +11374,12 @@ runTodoIdSource = null) {
             'about to do. If two organizations hold a skill of the same name this refuses rather than ' +
             'guessing: pass org_id to say which you mean. Read-only.',
         inputSchema: {
-            name: z.string().min(1).describe('Skill name, as listed by list_skills'),
+            name: z.string().min(1).optional().describe('Skill name, as listed by list_skills'),
+            id: z
+                .string()
+                .optional()
+                .describe('Skill id, as pasted by the web app\'s "Copy for agent" button. Use it instead of name; ' +
+                'it names exactly one skill, so org_id is never needed with it.'),
             org_id: z
                 .string()
                 .optional()
@@ -11266,7 +11395,11 @@ runTodoIdSource = null) {
             'those paths here. WHEN A SKILL POINTS AT A FILE BESIDE IT, FETCH IT AND FOLLOW IT — never ask ' +
             'the user to supply a file the organization already stored. Text only, up to 512 KB. Read-only.',
         inputSchema: {
-            name: z.string().min(1).describe('Skill name, as listed by list_skills'),
+            name: z.string().min(1).optional().describe('Skill name, as listed by list_skills'),
+            id: z
+                .string()
+                .optional()
+                .describe('Skill id. Use it instead of name; it names exactly one skill.'),
             path: z
                 .string()
                 .min(1)
@@ -11313,6 +11446,22 @@ runTodoIdSource = null) {
         touchSession(connectionId);
         return getProjectContextHandler(client, openSessions.get(connectionId) ?? null, args);
     });
+    server.registerTool('get_document', {
+        description: 'Read ONE context document or agent instruction by its id — the whole document, not an excerpt. ' +
+            'Use it when someone hands you an id (the web app’s “Copy for agent” button pastes one), or when ' +
+            'get_project_context named a document you need in full. It resolves either kind, so you do not ' +
+            'need to know which one the id belongs to. To read a project’s context as a whole instead, call ' +
+            'get_project_context. Read-only.',
+        inputSchema: {
+            id: z
+                .string()
+                .min(1)
+                .describe('Document id, as the web app’s “Copy for agent” button pastes it'),
+        },
+    }, async (args) => {
+        touchSession(connectionId);
+        return getDocumentHandler(client, args);
+    });
     server.registerTool('propose_project_context', {
         // The description TEACHES: when to reach for this (after reading a repo),
         // what a good proposal is (content it actually read, one line of why),
@@ -13135,7 +13284,7 @@ let foreignProbeCache = null;
 /** Whether ANOTHER process's ctrl-spc tools server answers /health on the fixed
  *  port. Never throws; refusals, timeouts, and non-ctrl-spc answers all read as
  *  "not alive" (→ the badge keeps today's failed semantics). */
-async function foreignToolsServerAlive(fetchImpl) {
+export async function foreignToolsServerAlive(fetchImpl = fetch) {
     const now = Date.now();
     if (foreignProbeCache &&
         foreignProbeCache.fetchImpl === fetchImpl &&
@@ -13162,14 +13311,20 @@ async function foreignToolsServerAlive(fetchImpl) {
  *  `claude mcp add --scope user` writes) carries a `ctrl-spc` entry whose url
  *  matches the CURRENT mcp token and tools port. A stale entry from an old
  *  token or port does not count — it would 401 against the live server. */
-function claudeRegisteredOnDisk() {
+export function claudeRegisteredOnDisk() {
     try {
+        // readMcpToken, never mcpToken: `cs status` must not mint a token as a side
+        // effect of a read. No token on disk means this install never launched, so
+        // nothing can be registered against it either way.
+        const token = readMcpToken();
+        if (!token)
+            return false;
         const raw = readFileSync(join(homedir(), '.claude.json'), 'utf8');
         const parsed = JSON.parse(raw);
         const url = parsed?.mcpServers?.['ctrl-spc']?.url;
         return (typeof url === 'string' &&
             url.includes(`127.0.0.1:${TOOLS_SERVER_PORT}/mcp`) &&
-            url.includes(`token=${mcpToken()}`));
+            url.includes(`token=${token}`));
     }
     catch {
         return false;
@@ -13260,11 +13415,14 @@ export function ensureCodexMcpApproval(path = codexConfigPath()) {
  *  written (current token + port). A substring check on purpose: it holds
  *  regardless of how Codex quotes/normalizes the TOML around it, and the
  *  tokened url is unique to this install. */
-function codexRegisteredOnDisk() {
+export function codexRegisteredOnDisk() {
     try {
+        const token = readMcpToken(); // see claudeRegisteredOnDisk: never mint here
+        if (!token)
+            return false;
         const codexHome = process.env.CODEX_HOME || join(homedir(), '.codex');
         const raw = readFileSync(join(codexHome, 'config.toml'), 'utf8');
-        return raw.includes(`http://127.0.0.1:${TOOLS_SERVER_PORT}/mcp?token=${mcpToken()}`);
+        return raw.includes(`http://127.0.0.1:${TOOLS_SERVER_PORT}/mcp?token=${token}`);
     }
     catch {
         return false;

package/dist/panel3/answer.js

@@ -1,17 +1,17 @@
 /**
- * ═══ AGENT PANEL v3: `cs3 answer`, the person settling a question. ═══
+ * ═══ AGENT PANEL v3: `cs answer`, the person settling a question. ═══
  *
  * THIS FILE BELONGS TO AGENT PANEL v3. Nothing outside `src/panel3/` may
  * import it.
  *
  * ---------------------------------------------------------------------------
- * ═══ IT IS `cs3 say`'s SIBLING, AND IT IS A SEPARATE COMMAND ON PURPOSE. ═══
+ * ═══ IT IS `cs say`'s SIBLING, AND IT IS A SEPARATE COMMAND ON PURPOSE. ═══
  *
  * Both are the person putting something on the record and returning, with no
  * spawn to wait for. They differ in what the record does with it, and that
  * difference is exactly why they are not one command: a message is new work, and
  * an answer is the thing one particular piece of stopped work was waiting for.
- * `cs3 say --card <id> "the answer"` would put the words on the card as a fresh
+ * `cs say --card <id> "the answer"` would put the words on the card as a fresh
  * message, leave the question open, and leave the run that asked it stopped
  * forever — which is the fenced-off answer ux.md spends a section on, arrived at
  * by the shortest route.
@@ -48,12 +48,12 @@
 // `import type` loses its v3 header in the published `dist/`.
 import { at, out, returned, signedInClient } from './client.js';
 import { ASK_CONTENT_COLUMNS, withAskContent } from './show.js';
-const USAGE = 'usage: cs3 answer <question-id> "<text>"';
+const USAGE = 'usage: cs answer <question-id> "<text>"';
 /**
- * The two arguments, and a second bare word refused rather than joined: `cs3
+ * The two arguments, and a second bare word refused rather than joined: `cs
  * answer <id> yes it is` is an answer the shell already split, and gluing it back
  * together would be this command guessing at what the person typed. The same rule
- * `cs3 say` applies, for the same reason.
+ * `cs say` applies, for the same reason.
  */
 function parseArgs(args) {
     const words = args.filter((a) => !a.startsWith('--'));
@@ -81,7 +81,7 @@ function parseArgs(args) {
  *
  * ═══ AND THE WAITING ONE IS ONLY SAID WHEN IT IS TRUE. ═══ It used to say the
  * question "may yet be settled without troubling you" whatever the record said —
- * including for a question `cs3 show` had already called stalled, because the
+ * including for a question `cs show` had already called stalled, because the
  * agent it went to had ended without dealing with it. Two surfaces, opposite
  * claims, and the one the person can act on was the one that was wrong. Those
  * are now answerable, so the only refusal left here is the honest one: it has
@@ -94,15 +94,15 @@ async function whyNot(client, askId) {
         .eq('id', askId), 'read', `question ${askId}`));
     const ask = asks[0];
     if (!ask) {
-        return `there is no question with id ${askId}. \`cs3 show\` lists the cards and the questions on them.`;
+        return `there is no question with id ${askId}. \`cs show\` lists the cards and the questions on them.`;
     }
     if (ask.answered_at) {
         return (`that question was already answered ${at(ask.answered_at)}, with:\n  ${ask.answer ?? '(nothing)'}\n`
             + 'Answering it again would rewrite a decision the work has already been started on. Send a '
-            + `message instead: cs3 say --card ${ask.card_id} "<text>"`);
+            + `message instead: cs say --card ${ask.card_id} "<text>"`);
     }
     return ('that question has not reached you: it is with the work it came from, which has not had its go '
-        + 'at it yet and may settle it without troubling you. `cs3 show` says who has it, and it becomes '
+        + 'at it yet and may settle it without troubling you. `cs show` says who has it, and it becomes '
         + 'yours to answer if they end without dealing with it.');
 }
 export async function answer(args) {
@@ -151,7 +151,7 @@ export function answeredLines(askId, cardId, state) {
             `card      ${cardId}   in hand again`,
             '',
             '  Whoever was waiting on this is started again with it, wherever they had got to.',
-            `  cs3 show ${cardId}`,
+            `  cs show ${cardId}`,
         ];
     }
     return [
@@ -161,6 +161,6 @@ export function answeredLines(askId, cardId, state) {
         '  NOBODY IS BEING STARTED FOR THIS. The answer is on the record and nothing is waiting for',
         '  it, because the work that asked was stopped. Send a message if you want this card picked',
         '  up again:',
-        `  cs3 say --card ${cardId} "<text>"`,
+        `  cs say --card ${cardId} "<text>"`,
     ];
 }