@ctrl-spc/cs 0.7.1 → 0.7.2

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/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
@@ -13135,7 +13135,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 +13162,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 +13266,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>"`,
     ];
 }