@ctrl-spc/cs 0.7.14 → 0.7.16

package/dist/panel3/spawn.js

@@ -1,3 +1,5 @@
+import { nativeFailureKind, failureMessage } from '../failure-reason.js';
+import { CodexHomeFailure } from '../codex-home.js';
 /**
  * ═══ AGENT PANEL v3: running one headless agent and reading what it said. ═══
  *
@@ -123,7 +125,7 @@ import { spawn as spawnChild } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { agentPath } from '../agents.js';
 import { ensureCodexRunHome, ensurePanel3CodexOwnerHome, removeCodexRunHome, } from '../codex-home.js';
-import { windowsSafeSpawn } from '../win-shell.js';
+import { windowsSafeSpawn, spawnOwnedProcess, releaseOwnedProcess } from '../win-shell.js';
 import { modelChoiceRules } from './prompt.js';
 const AGENT_VAR = 'CTRL_SPC_V3_AGENT';
 /**
@@ -181,6 +183,7 @@ export function agentArgs(level, toolsUrl, agent = harness(), platform = process
     return [
         // `-p` with the prompt on stdin. See the header.
         '-p',
+        '--output-format', 'json',
         '--mcp-config',
         JSON.stringify({ mcpServers: { [SERVER]: { type: 'http', url: toolsUrl } } }),
         '--strict-mcp-config',
@@ -297,6 +300,9 @@ function runKey(toolsUrl) {
  * present.
  */
 export function codexAnswer(stdout, exitCode = 0, stderr = '') {
+    const failureKind = nativeFailureKind(stdout, stderr);
+    if (failureKind !== 'unknown')
+        return { ok: false, failureKind, retryable: failureKind === 'transient', reason: failureMessage('codex', failureKind) };
     let text = null;
     let failure = null;
     for (const line of stdout.split('\n')) {
@@ -341,16 +347,26 @@ export function codexAnswer(stdout, exitCode = 0, stderr = '') {
     }
     return { ok: true, text: text.trim() };
 }
-/** Claude prints provider/model rejections on stdout, even with a nonzero exit. */
+/** The native result envelope distinguishes a provider failure from answer prose. */
 export function claudeAnswer(stdout, exitCode = 0, stderr = '') {
+    const failureKind = nativeFailureKind(stdout, stderr);
+    if (failureKind !== 'unknown')
+        return { ok: false, failureKind, retryable: failureKind === 'transient', reason: failureMessage('claude', failureKind) };
     if (/^\[claude-code:unrecognized_model\]/m.test(stdout + '\n' + stderr)) {
-        return { ok: false, retryable: false, reason: 'Claude rejected the selected model. Choose an available model and retry.' };
+        return { ok: false, failureKind: 'invalid-model', retryable: false, reason: 'Claude rejected the selected model. Choose an available model and retry.' };
     }
     if (exitCode !== 0)
         return { ok: false, reason: `claude exited ${exitCode}${tail(stderr) || tail(stdout)}` };
     if (stdout.trim() === '')
         return { ok: false, reason: `claude exited 0 and said nothing${tail(stderr)}` };
-    return { ok: true, text: stdout.trim() };
+    try {
+        const result = JSON.parse(stdout);
+        if (result?.type === 'result' && result.is_error === false && typeof result.result === 'string' && result.result.trim()) {
+            return { ok: true, text: result.result.trim() };
+        }
+    }
+    catch { /* A malformed native result is not a completed answer. */ }
+    return { ok: false, reason: 'Claude did not return a completed result.' };
 }
 /** Enough for any answer a person reads, and a ceiling so a runaway process
  *  cannot exhaust this daemon's memory. */
@@ -405,11 +421,16 @@ function tail(text, chars = 500) {
  * process still alive" after the daemon that started it has been killed. So the
  * caller gets the pid immediately, writes it, and then waits.
  */
-export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings = {}) {
-    const failed = (reason) => ({
+export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings = {}, lifecycle) {
+    if (lifecycle?.interrupted())
+        return { pid: null, session: Promise.resolve(null),
+            answered: Promise.resolve({ ok: false, reason: 'Work was interrupted by the service command.' }),
+            interrupted: lifecycle.interrupted, completed: lifecycle.complete };
+    const failed = (reason, failureKind = 'unknown') => ({
         pid: null,
         session: Promise.resolve(null),
-        answered: Promise.resolve({ ok: false, reason }),
+        answered: Promise.resolve({ ok: false, reason, failureKind, retryable: false }),
+        ...(lifecycle ? { interrupted: lifecycle.interrupted, completed: lifecycle.complete } : {}),
     });
     let agent;
     try {
@@ -429,7 +450,7 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
     prompt = `${modelChoiceRules(agent)}\n\n${prompt}`;
     const bin = agentPath(agent);
     if (!bin) {
-        return failed(`${agent} is not installed on this machine`);
+        return failed(`${agent} is not installed on this machine`, 'missing-binary');
     }
     /* macOS uses the proven per-run home. Windows keeps its installed home so the
        Desktop runtime's ACL-bound sandbox helpers remain valid; `codexArgs`
@@ -443,17 +464,17 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
             // pass this and keep today's behaviour; see `codex-home.ts`.
             : ensureCodexRunHome({ url: toolsUrl }, null, runKey(toolsUrl), false)
         : null;
-    if (agent === 'codex' && !windowsCodex && !home) {
-        return failed('codex is not signed in on this machine, so a run cannot be given this product\'s tools '
-            + 'and nothing else. Sign codex in on the machine running this, and start it again.');
-    }
+    if (home instanceof CodexHomeFailure)
+        return failed(home.message, home.kind);
     const { args, shell } = windowsSafeSpawn(bin, ARGS);
     let child;
     try {
-        child = spawnChild(bin, args, {
+        lifecycle?.beforeSpawn();
+        const options = {
             // The repo-wide invariant for ANY child process (MEMORY: "Windows silence
             // decision"). A user must never see a console flash.
             windowsHide: true,
+            detached: process.platform !== 'win32',
             shell,
             stdio: ['pipe', 'pipe', 'pipe'],
             // NEVER the daemon's inherited cwd, which under a launchd login item is
@@ -465,14 +486,17 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
                said. Claude is spawned with the environment untouched, exactly as
                before. */
             ...(home ? { env: { ...process.env, CODEX_HOME: home } } : {}),
-        });
+        };
+        child = lifecycle
+            ? spawnOwnedProcess(bin, args, options, lifecycle.id)
+            : spawnChild(bin, args, options);
     }
     catch (err) {
         // NOT `err.message`, which names the binary's absolute path. See
         // `couldNotStart`.
         if (home && !ownerSession)
             removeCodexRunHome(home);
-        return failed(couldNotStart(err, agent));
+        return failed(couldNotStart(err, agent), 'preparation-unavailable');
     }
     let resolveSession;
     let sessionSettled = false;
@@ -488,6 +512,7 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
     else if (agent === 'claude') {
         observeSession(launchedOwnerSession?.resumeSessionId ?? launchedOwnerSession?.freshSessionId ?? null);
     }
+    let registration = Promise.resolve();
     const answered = new Promise((resolve) => {
         let stdout = '';
         let stderr = '';
@@ -512,11 +537,32 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
             /* THE CREDENTIAL COPY GOES WHEN THE RUN DOES. `codex-home.ts` calls this
                the primary reclaim and the startup sweep the backstop; a home left
                behind holds a copy of the user's codex credential. */
-            if (home && !ownerSession)
-                removeCodexRunHome(home);
-            if (!sessionSettled)
-                observeSession(null);
-            resolve(answer);
+            void (async () => {
+                await registration.catch(() => { });
+                if (lifecycle && child.pid) {
+                    // A wrapper's close is not tree exit. Keep the run owned until the
+                    // actual descendants end; lifecycle commands have their own deadline.
+                    let warned = false;
+                    while (true) {
+                        try {
+                            await lifecycle.exited();
+                            break;
+                        }
+                        catch (error) {
+                            if (!warned) {
+                                console.warn(`Owned agent execution has not ended: ${error.message}`);
+                                warned = true;
+                            }
+                            await new Promise((done) => setTimeout(done, 250));
+                        }
+                    }
+                }
+                if (home && !ownerSession)
+                    removeCodexRunHome(home);
+                if (!sessionSettled)
+                    observeSession(null);
+                resolve(answer);
+            })();
         };
         child.stdout?.on('data', (d) => {
             stdout = collect(stdout, String(d));
@@ -543,7 +589,7 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
            WITHOUT the message, which is where node puts the binary's absolute path.
            The same failure as the throw above, arriving asynchronously. */
         child.on('error', (err) => {
-            finish({ ok: false, reason: couldNotStart(err, agent) });
+            finish({ ok: false, reason: couldNotStart(err, agent), failureKind: 'preparation-unavailable', retryable: false });
         });
         child.on('close', (code, signal) => {
             /* ═══ THREE OUTCOMES, AND ONLY ONE OF THEM IS AN ANSWER. ═══ A non-zero
@@ -582,7 +628,23 @@ export function startAgent(prompt, level, toolsUrl, cwd, ownerSession, settings
            handler the EPIPE is an unhandled stream error and takes the daemon down
            with it. */
         child.stdin?.on('error', () => { });
-        child.stdin?.end(prompt);
+        if (lifecycle) {
+            registration = lifecycle.register(child, agent);
+            void registration.then(() => {
+                if (lifecycle.interrupted())
+                    return;
+                releaseOwnedProcess(child);
+                child.stdin?.end(prompt);
+            }).catch((error) => {
+                // No prompt was delivered. The held native handle may be cancelled
+                // even when durable ownership registration itself failed.
+                child.stdin?.destroy();
+                child.kill('SIGKILL');
+                finish({ ok: false, reason: `The agent could not be safely registered: ${error.message}` });
+            });
+        }
+        else
+            child.stdin?.end(prompt);
     });
-    return { pid: child.pid ?? null, session, answered };
+    return { pid: child.pid ?? null, session, answered, ...(lifecycle ? { interrupted: lifecycle.interrupted, completed: lifecycle.complete } : {}) };
 }

package/dist/panel3/tools.js

@@ -1,3 +1,4 @@
+import { clientSessionCurrent } from '../supabase.js';
 import { createEpicHandler, createSprintHandler, listStructureHandler, updateStructureHandler, listStructureArtifactsHandler, getStructureArtifactHandler, searchAgentCardsHandler, createStructureArtifactHandler, updateStructureArtifactHandler } from '../product-tools.js';
 import { listArtifactFoldersHandler, setArtifactFolderHandler, workItemDependencyHandler } from '../product-tools.js';
 /**
@@ -3472,6 +3473,10 @@ export async function startToolsServer(client, dispatch, recoverLanding) {
         res.writeHead(status, { 'Content-Type': 'text/plain' }).end(why);
     };
     async function handle(req, res) {
+        if (!clientSessionCurrent(client)) {
+            fail(res, 401, 'This connection no longer owns the local sign-in.');
+            return;
+        }
         const url = new URL(req.url ?? '/', 'http://127.0.0.1');
         const parts = url.pathname.startsWith('/mcp/')
             ? url.pathname.slice('/mcp/'.length).split('/').filter(Boolean)

package/dist/presence-heartbeat.js

@@ -12,5 +12,8 @@ export function buildPresenceHeartbeatPayload(input, seenAt = new Date()) {
         // A beating heart is not stopped: clears the stamp a clean shutdown left,
         // so a machine that comes back reads online again.
         stopped_at: null,
+        session_state: 'authenticated',
+        session_observed_at: seenAt.toISOString(),
+        harness_auth: input.harnessAuth ?? {},
     };
 }