@ctrl-spc/cs 0.7.14 → 0.7.16

package/dist/index.js

@@ -4,9 +4,11 @@ import { runDaemon } from './daemon.js';
 import { openCompanion } from './companion.js';
 import { autostartOn, autostartOff } from './autostart.js';
 import { detectAgents } from './agents.js';
-import { getMachineIdentity, clearSession, readSession } from './config.js';
-import { getClient } from './supabase.js';
-import { foreignToolsServerAlive, claudeRegisteredOnDisk, codexRegisteredOnDisk } from './mcp.js';
+import { getMachineIdentity, clearSession, readSession, machineHostname } from './config.js';
+import { CLI_VERSION } from './package-version.js';
+import { inspectLocalRuntime, runLifecycleCommand, notifySessionChanged } from './daemon-lifecycle.js';
+import { readMigration, readRuntime } from './daemon-lock.js';
+import { claudeRegisteredOnDisk, codexRegisteredOnDisk } from './mcp.js';
 import { panelCommand } from './panel3/cli.js';
 const HELP = `cs — CTRL+SPC
 
@@ -14,7 +16,11 @@ const HELP = `cs — CTRL+SPC
   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 the whole setup state and the one next step to take
+  cs stop           Stop this service; refuses while work is active
+  cs restart        Load this installed version and keep it running in background
+  cs stop --force   Interrupt owned work, save recovery, then stop
+  cs restart --force Interrupt owned work, then load this installed version
+  cs status         Show local service, cloud readiness and running version
   cs autostart on   Come online automatically at login
   cs autostart off  Stop coming online at login
   cs logout         Sign this computer out
@@ -28,80 +34,62 @@ const HELP = `cs — CTRL+SPC
 
   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.
- */
+/** Inspection never creates a competing cloud refresh owner. */
 async function status() {
-    const id = getMachineIdentity();
+    const machine = getMachineIdentity();
     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;
+    console.log('Computer: ' + machine.name);
+    console.log('Installed CLI version: ' + CLI_VERSION);
+    console.log('Harnesses installed: ' + (installed.join(', ') || 'none'));
+    console.log('Harness sign-in: not checked by this command; each work request checks its selected harness.');
+    const inspection = await inspectLocalRuntime();
+    if (inspection?.status) {
+        const current = inspection.status;
+        console.log('Local service: ' + current.local + ' (pid ' + current.pid + ')');
+        console.log('Running version: ' + current.version + ' — verified');
+        console.log('Cloud connection: ' + current.cloud);
+        const work = [...current.work.active, ...current.work.pending, ...current.work.unknown];
+        console.log('Owned work: ' + work.length + (current.work.unknown.length ? ' (includes unverified execution)' : ''));
+        for (const item of work)
+            console.log('  ' + (item.cardId ?? item.workId ?? 'Card identity unavailable') + ' — ' + (item.harness ?? 'harness unknown'));
+        if (current.work.receipts || current.work.legacyHeldTodoIds.length)
+            console.log('Saved interruptions are waiting for reconciliation or explicit continuation.');
+        if (current.cloud === 'sign-in-required')
+            console.log('Run cs login on ' + machine.name + '. Local stop and restart remain available.');
+        else if (current.cloud !== 'online')
+            console.log('Cloud readiness is not confirmed. Check the connection; cs status will show when it is ready.');
+        if (current.version !== CLI_VERSION)
+            console.log('Run cs restart to activate the installed CLI version.');
+        else
+            console.log('Stop: cs stop. Restart this installed version: cs restart.');
+        console.log('Explicit interruption: cs stop --force or cs restart --force. Interrupted cards need a new message to continue.');
+        if (current.cloud === 'online') {
+            for (const agent of installed)
+                console.log('  ' + agent + ': ' + ((agent === 'claude' ? claudeRegisteredOnDisk() : codexRegisteredOnDisk()) ? 'registered' : 'not registered'));
         }
-        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.');
+        if (current.cloud !== 'online' || current.work.unknown.length)
+            process.exitCode = 1;
+        return;
     }
-    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.');
+    if (inspection) {
+        console.log('Local service: alive; control is unavailable (pid ' + inspection.record.process.pid + ')');
+        console.log('Running version: unavailable. Last recorded version: ' + inspection.record.version);
+        console.log('Cloud connection and owned work: unknown');
+        console.log('Run cs restart --force to recover verified owned execution. This interrupts work; saved cards need a new message to continue.');
     }
     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;
+        const migration = readMigration();
+        console.log('Local service: stopped or not yet managed by this release');
+        console.log('Running version: unavailable');
+        console.log('Cloud connection: unknown; local service is not responding');
+        if (migration && !migration.completed)
+            console.log('One-time upgrade is pending. Run cs restart to check whether this computer still needs a restart.');
+        else if (readRuntime())
+            console.log('A previous service exited. Run cs restart to recover this instance.');
+        else
+            console.log('Run cs start. If an older service needs a one-time computer restart, the command will explain it.');
+        if (!readSession())
+            console.log('No saved sign-in. Run cs login on ' + machine.name + '. Local service controls work without sign-in.');
     }
     process.exitCode = 1;
 }
@@ -112,11 +100,22 @@ async function main() {
         case undefined: return openCompanion();
         case 'open': return openCompanion();
         case 'login': return login();
-        case 'start': return runDaemon();
+        case 'start':
+            if (arg && !(arg.startsWith('--lifecycle-handover=') && process.env.CTRL_SPC_LIFECYCLE_HANDOVER === arg.slice('--lifecycle-handover='.length)))
+                throw new Error('Usage: cs start');
+            return runDaemon();
+        case 'stop':
+        case 'restart':
+            if (process.argv.length > 4 || (arg !== undefined && arg !== '--force'))
+                throw new Error('Usage: cs ' + cmd + ' [--force]');
+            return runLifecycleCommand(cmd, arg === '--force');
         case 'status': return status();
-        case 'logout':
-            console.log(clearSession() ? 'Signed out.' : 'Was not signed in.');
+        case 'logout': {
+            const signedIn = await clearSession();
+            await notifySessionChanged();
+            console.log(signedIn ? '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
@@ -145,6 +144,6 @@ async function main() {
     }
 }
 main().catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
+    console.error('CTRL+SPC on ' + machineHostname() + ': ' + (err instanceof Error ? err.message : String(err)));
     process.exit(1);
 });

package/dist/login.js

@@ -2,8 +2,9 @@ import { createServer } from 'node:http';
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { SUPABASE_URL, SUPABASE_KEY } from './env.js';
 import { openBrowser } from './browser.js';
-import { writeSession, getMachineIdentity } from './config.js';
-import { getClient } from './supabase.js';
+import { getMachineIdentity } from './config.js';
+import { acceptLogin } from './supabase.js';
+import { notifySessionChanged } from './daemon-lifecycle.js';
 const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 const MAX_BODY_BYTES = 64 * 1024;
 export async function login() {
@@ -80,15 +81,12 @@ async function handleCallback(req, res, state, finish) {
         res.end(JSON.stringify({ ok: false, error: 'Invalid or missing state' }));
         return;
     }
-    writeSession({ access_token, refresh_token });
     try {
-        const client = await getClient();
-        const { data, error } = await client.auth.getUser();
-        if (error || !data.user?.email)
-            throw new Error(error?.message ?? 'No user for this session.');
+        const email = await acceptLogin({ access_token, refresh_token });
+        await notifySessionChanged();
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ ok: true }));
-        finish({ ok: true, email: data.user.email });
+        finish({ ok: true, email });
     }
     catch (err) {
         const message = `Session could not be verified: ${err.message}`;
@@ -169,7 +167,9 @@ function renderPage(state) {
   tin.onclick=()=>{tin.classList.add('active');tup.classList.remove('active');fin.classList.add('active');fup.classList.remove('active')}
   tup.onclick=()=>{tup.classList.add('active');tin.classList.remove('active');fup.classList.add('active');fin.classList.remove('active')}
   const { createClient } = await import('https://esm.sh/@supabase/supabase-js@2')
-  const sb = createClient(${JSON.stringify(SUPABASE_URL)}, ${JSON.stringify(SUPABASE_KEY)})
+  const sb = createClient(${JSON.stringify(SUPABASE_URL)}, ${JSON.stringify(SUPABASE_KEY)}, {
+    auth: { autoRefreshToken: false, persistSession: false, detectSessionInUrl: false }
+  })
   async function done(session){
     const r = await fetch('/callback',{method:'POST',headers:{'Content-Type':'application/json'},
       body:JSON.stringify({access_token:session.access_token,refresh_token:session.refresh_token,state:STATE})})

package/dist/mcp.js

@@ -1,3 +1,4 @@
+import { deferMcpCleanup, pendingMcpCleanup, acknowledgeMcpCleanup } from './daemon-processes.js';
 import { listStructureArtifactsHandler, getStructureArtifactHandler, searchAgentCardsHandler, createStructureArtifactHandler, updateStructureArtifactHandler } from './product-tools.js';
 import { createEpicHandler, createSprintHandler, listStructureHandler, updateStructureHandler } from './product-tools.js';
 export { createEpicHandler, createSprintHandler, listStructureHandler, updateStructureHandler } from './product-tools.js';
@@ -20,9 +21,10 @@ import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { workflowToolPermission, validateWorkflowToolTarget, WORKFLOW_TOOL_TEACHING, WORKFLOW_AUTHORING_TEACHING, authorToolMentions } from './workflows.js';
 import { workflowToolForName, validateApprovalAction } from './workflow-tool-mentions.js';
+import { clientSessionCurrent } from './supabase.js';
 import { TOOLS_SERVER_PORT, SESSION_TTL_MS } from './env.js';
 import { agentPath } from './agents.js';
-import { mcpToken, readMcpToken, readSession } from './config.js';
+import { mcpToken, readMcpToken } from './config.js';
 import { FIREWALL_WRITING_RULE } from './firewall.js';
 /* The path rule itself, moved out so `workflows.ts` can ask the same question
    before it builds a workflow. `refuseAbsolutePaths` below is still v2's own
@@ -9237,6 +9239,7 @@ runTodoIdSource = null) {
                     await releaseSessionReservations([prevTodo.sessionId], client);
                 }
                 openSessions.set(connectionId, {
+                    accountId: userId,
                     sessionId: opened.id,
                     taskId: null,
                     todoId: args.todo_id,
@@ -9380,6 +9383,7 @@ runTodoIdSource = null) {
             // Record the new session in the registry keyed by connectionId, with a
             // fresh activity-TTL (extended by every subsequent tool call).
             openSessions.set(connectionId, {
+                accountId: userId,
                 sessionId: session.id,
                 taskId: session.task_id,
                 expiresAt: Date.now() + SESSION_TTL_MS,
@@ -11034,7 +11038,7 @@ export async function releaseSessionReservations(sessionIds,
 /** The client to use. The lifecycle helpers hold `toolsClient`; the tool
  *  handlers hold their own per-connection client and pass it, matching what
  *  they use for the session-status write immediately above each call. */
-client = toolsClient) {
+client = toolsClient, strict = false) {
     if (!client || sessionIds.length === 0)
         return;
     try {
@@ -11049,6 +11053,8 @@ client = toolsClient) {
             throw new Error(error.message);
     }
     catch (err) {
+        if (strict)
+            throw err;
         /* NOTHING ABOVE THIS, following `noteDroppedActivity` and the session
            helpers. The session is already ended, which is the fact the product
            reads; an unreleased lease degrades to exactly the pre-slice behaviour
@@ -11366,64 +11372,49 @@ export async function noteDroppedActivity(todoId) {
         console.warn(`recording a dropped activity write failed: ${errorMessage(err)}`);
     }
 }
-/** Mark ONE connection's open session ended (connection closed). Best-effort. */
-export async function endConnectionSession(connectionId) {
-    const s = openSessions.get(connectionId);
-    /* 18c Slice 6: the remembered session is cleared HERE and only here, because
-       it is scoped to the CONNECTION rather than to the session. The connection
-       is gone, so nothing can produce anything else under it. */
-    lastSessionByConnection.delete(connectionId);
-    if (!toolsClient || !s) {
-        openSessions.delete(connectionId);
+/** Flush only the authenticated account's durable cleanup, using its captured client. */
+export async function reconcileMcpCleanup(client, accountId) {
+    const sessionIds = pendingMcpCleanup(accountId);
+    if (!sessionIds.length)
         return;
-    }
+    const { error } = await client.from('cliv2_agent_sessions').update({ status: 'ended' }).in('id', sessionIds);
+    if (error)
+        throw error;
+    await releaseSessionReservations(sessionIds, client, true);
+    acknowledgeMcpCleanup(accountId, sessionIds);
+}
+/** Retire the local connection immediately; cloud cleanup survives authentication loss. */
+export async function endConnectionSession(connectionId) {
+    const client = toolsClient;
+    const session = openSessions.get(connectionId);
+    if (session)
+        deferMcpCleanup([session]);
     openSessions.delete(connectionId);
-    try {
-        const { error } = await toolsClient
-            .from('cliv2_agent_sessions')
-            .update({ status: 'ended' })
-            .eq('id', s.sessionId);
-        if (error)
-            throw error;
-    }
-    catch (err) {
-        console.warn(`ending session on connection close failed: ${err.message}`);
-    }
-    /* 18c SLICE 9 (GAP 15), ROUTE 4a. THE CONNECTION IS GONE, so nothing can
-       ever release these leases by asking. This is what covers every orchestrator
-       finish path: they all end the agent PROCESS, and a dead process's MCP
-       connection closes here. See `releaseSessionReservations` for why the fix
-       hangs off the session rather than off those ten callers. */
-    await releaseSessionReservations([s.sessionId]);
-}
-/** Mark ALL open sessions ended and clear the registry (server stop / logout). */
-export async function endAllOpenSessions() {
-    if (openSessions.size === 0) {
-        return;
+    lastSessionByConnection.delete(connectionId);
+    if (client && session) {
+        try {
+            await reconcileMcpCleanup(client, session.accountId);
+        }
+        catch {
+            console.warn('Session cleanup is waiting for its original account to reconnect.');
+        }
     }
-    const sessionIds = [...openSessions.values()].map((s) => s.sessionId);
+}
+export async function endAllOpenSessions(client = toolsClient) {
+    const sessions = [...openSessions.values()];
+    deferMcpCleanup(sessions);
     openSessions.clear();
-    /* 18c Slice 6: server stop or logout. Every connection is going away, so no
-       later write can legitimately attribute to any of these. */
     lastSessionByConnection.clear();
-    if (!toolsClient)
+    if (!client)
         return;
-    try {
-        const { error } = await toolsClient
-            .from('cliv2_agent_sessions')
-            .update({ status: 'ended' })
-            .in('id', sessionIds);
-        if (error)
-            throw error;
-    }
-    catch (err) {
-        console.warn(`ending all open sessions failed: ${err.message}`);
+    for (const accountId of new Set(sessions.map(session => session.accountId))) {
+        try {
+            await reconcileMcpCleanup(client, accountId);
+        }
+        catch {
+            console.warn('Session cleanup is waiting for its original account to reconnect.');
+        }
     }
-    /* 18c SLICE 9 (GAP 15), ROUTE 4b. Server stop or logout: every session is
-       over at once, so every lease any of them holds goes with them. On logout in
-       particular, leaving them active would have the next sign-in's first run
-       collide with an account that is no longer even connected. */
-    await releaseSessionReservations(sessionIds);
 }
 async function readJsonBody(req) {
     const chunks = [];
@@ -11537,7 +11528,7 @@ export async function startToolsServer(deps) {
         // clear session.json — it can't reach this server's in-memory session. So
         // every request (including ones on an already-open MCP connection) re-checks
         // the on-disk session; once it's gone, nothing is served for the old account.
-        if (!readSession()) {
+        if (!clientSessionCurrent(deps.client)) {
             res.writeHead(401, { 'Content-Type': 'text/plain' }).end('Logged out');
             return;
         }
@@ -11563,6 +11554,12 @@ export async function startToolsServer(deps) {
                 await existing.handleRequest(req, res);
                 return;
             }
+            if (sessionId) {
+                // MCP clients reinitialize after a lost session only when it returns 404.
+                sessionTodoIds.delete(sessionId);
+                res.writeHead(404, { 'Content-Type': 'text/plain' }).end('Session not found');
+                return;
+            }
             if (req.method !== 'POST') {
                 res.writeHead(400, { 'Content-Type': 'text/plain' }).end('Bad Request: no valid session ID provided');
                 return;
@@ -11668,9 +11665,11 @@ export async function stopToolsServer() {
     // D2b: flip every open work session to ended (this needs toolsClient) BEFORE
     // dropping the client reference, so the board's "working" chips clear on server
     // stop / logout; then release the client alongside the reg-status resets.
-    await endAllOpenSessions();
-    toolsClient = null;
+    const client = toolsClient;
     await h.close();
+    void endAllOpenSessions(client).catch(error => console.warn(`Session cleanup remains incomplete: ${String(error)}`));
+    if (toolsClient === client)
+        toolsClient = null;
 }
 /** Whether the tools server is currently listening, and its fixed port. */
 export function toolsServerStatus() {

package/dist/native/darwin-coalition.build.json

@@ -0,0 +1 @@
+{"sourceHash":"e817b52cb4cf445046d83c9d4a6a7f8e79624f498564a3e40cb66d575ed4d63a","compiler":"Apple clang version 21.0.0 (clang-2100.1.1.101)\nTarget: arm64-apple-darwin25.3.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin\n","binaryHash":"25d9d65d0ee5718ddb8f54a08fa5000b9c73508f6eb532f085e812b249adf9bb"}

package/dist/native/darwin-coalition.c

@@ -0,0 +1,145 @@
+/* The launchd job is the execution owner; this helper only reads and signals
+ * its kernel resource coalition. No privilege or runtime compiler is required.
+ * Apple exports these SPI but omits their structures from the public SDK.
+ * Check every ABI size/capability, and fail closed when unavailable.
+ * Sources: apple-oss-distributions/xnu: bsd/sys/proc_info_private.h,
+ * osfmk/mach/coalition.h, osfmk/kern/coalition.c, bsd/kern/sys_coalition.c.
+ */
+#include <libproc.h>
+#include <sys/sysctl.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+struct coalition_info { uint64_t ids[2], reserved[3]; };
+struct unique_info { uint8_t uuid[16]; uint64_t unique, parent; int32_t version, parent_version; uint64_t reserved[2]; };
+struct process_info { struct proc_bsdinfo bsd; struct unique_info unique; };
+_Static_assert(sizeof(struct coalition_info) == 40, "coalition ABI");
+_Static_assert(sizeof(struct unique_info) == 56, "process ABI");
+static int (*resource_usage)(uint64_t, void *, size_t);
+static int (*signal_token)(audit_token_t *, int);
+static char boot[64];
+
+static void fail(const char *message) { fprintf(stderr, "%s (OS error %d).\n", message, errno); exit(1); }
+static void changed(void) { fputs("Mac execution membership changed during inspection.\n",stderr); exit(75); }
+static uint64_t number(const char *text) {
+  char *end; errno=0; uint64_t value=strtoull(text,&end,10);
+  if(errno || !*text || *end || !value) fail("Invalid Mac execution identity");
+  return value;
+}
+static int coalition(pid_t pid, uint64_t *id) {
+  struct coalition_info info={0}; int n=proc_pidinfo(pid,20,0,&info,sizeof(info));
+  if(n==sizeof(info)) { *id=info.ids[0]; return 1; }
+  if(n==0 && (errno==ESRCH || errno==ENOENT)) return 0;
+  fail("Mac execution ownership cannot be inspected"); return 0;
+}
+static int process_info(pid_t pid, struct process_info *info) {
+  int n=proc_pidinfo(pid,18,0,info,sizeof(*info));
+  if(n==sizeof(*info)) return 1;
+  if(n==0 && (errno==ESRCH || errno==ENOENT)) return 0;
+  fail("Mac process lifetime cannot be inspected"); return 0;
+}
+static int active(uint64_t id, uint64_t *count) {
+  uint64_t usage[2]={0};
+  if(resource_usage(id,usage,sizeof(usage))!=0) {
+    if(errno==ESRCH) { *count=0; return 0; }
+    fail("Mac execution membership cannot be inspected");
+  }
+  if(usage[1]>usage[0]) fail("Invalid Mac execution membership");
+  *count=usage[0]-usage[1]; return 1;
+}
+static void capability(void) {
+  resource_usage=dlsym(RTLD_DEFAULT,"coalition_info_resource_usage");
+  signal_token=dlsym(RTLD_DEFAULT,"proc_signal_with_audittoken");
+  size_t size=sizeof(boot);
+  if(!resource_usage || !signal_token || sysctlbyname("kern.bootsessionuuid",boot,&size,NULL,0)!=0 || size<36 || size>sizeof(boot))
+    fail("This Mac cannot verify safe agent execution; no agent was started");
+  uint64_t id, count; struct process_info info={0};
+  if(!coalition(getpid(),&id) || !process_info(getpid(),&info) || !active(id,&count))
+    fail("This Mac cannot verify safe agent execution; no agent was started");
+}
+static void same_boot(const char *expected) {
+  if(strcmp(expected,boot)) fail("Mac execution belongs to a different boot");
+}
+static void birth(struct process_info *info, char *output, size_t capacity) {
+  time_t seconds=(time_t)info->bsd.pbi_start_tvsec; struct tm tm; char date[32];
+  gmtime_r(&seconds,&tm); strftime(date,sizeof(date),"%Y-%m-%dT%H:%M:%S",&tm);
+  snprintf(output,capacity,"%s.%06"PRIu64"Z",date,info->bsd.pbi_start_tvusec);
+}
+int main(int argc,char **argv) {
+  capability();
+  if(argc==5 && !strcmp(argv[1],"signal-process")) {
+    same_boot(argv[2]); pid_t pid=(pid_t)number(argv[3]); struct process_info info={0}; char started[64];
+    if(!process_info(pid,&info)) return 0;
+    birth(&info,started,sizeof(started));
+    if(strcmp(started,argv[4])) return 0;
+    if(info.bsd.pbi_uid!=getuid()) fail("Mac execution belongs to another user");
+    audit_token_t token={{0}}; token.val[5]=(uint32_t)pid; token.val[7]=(uint32_t)info.unique.version;
+    if(signal_token(&token,SIGKILL)!=0 && errno!=ESRCH) fail("Owned Mac process could not be stopped");
+    return 0;
+  }
+  if(argc==3 && !strcmp(argv[1],"process")) {
+    pid_t pid=(pid_t)number(argv[2]); uint64_t id; struct process_info info={0};
+    if(!process_info(pid,&info) || !coalition(pid,&id)) { puts("null"); return 0; }
+    if(info.bsd.pbi_uid!=getuid()) fail("Mac execution belongs to another user");
+    time_t seconds=(time_t)info.bsd.pbi_start_tvsec; struct tm tm; char date[32];
+    gmtime_r(&seconds,&tm); strftime(date,sizeof(date),"%Y-%m-%dT%H:%M:%S",&tm);
+    printf("{\"id\":\"%"PRIu64"\",\"boot\":\"%s\",\"pid\":%d,\"ppid\":%u,\"pgid\":%u,\"owner\":%u,\"birth\":\"%s.%06"PRIu64"Z\",\"version\":%u}\n",id,boot,pid,info.bsd.pbi_ppid,info.bsd.pbi_pgid,getuid(),date,info.bsd.pbi_start_tvusec,(uint32_t)info.unique.version); return 0;
+  }
+  int all=argc==2 && !strcmp(argv[1],"all");
+  if(!all && argc<4) fail("Invalid Mac execution helper command");
+  uint64_t id=all?0:number(argv[2]);
+  // These one-shot jobs have no future-login plist. A changed kernel boot also
+  // proves every member and queued launch from the recorded boot has ended.
+  if(argc==4 && !strcmp(argv[1],"inspect") && strcmp(argv[3],boot)) { puts("{\"exists\":false,\"active\":0,\"members\":[]}"); return 0; }
+  if(!all) same_boot(argv[3]);
+  if(argc==7 && !strcmp(argv[1],"signal")) {
+    pid_t pid=(pid_t)number(argv[4]); uint64_t version=number(argv[5]), actual;
+    int signal=!strcmp(argv[6],"TERM")?SIGTERM:!strcmp(argv[6],"KILL")?SIGKILL:0;
+    if(!signal) fail("Invalid Mac execution signal");
+    struct process_info info={0};
+    if(!coalition(pid,&actual) || actual!=id || !process_info(pid,&info) || (uint32_t)info.unique.version!=version) return 0;
+    if(info.bsd.pbi_uid!=getuid()) fail("Mac execution belongs to another user");
+    audit_token_t token={{0}}; token.val[5]=(uint32_t)pid; token.val[7]=(uint32_t)version;
+    // The kernel compares the PID version while holding the process reference;
+    // a reused PID cannot receive this signal.
+    if(signal_token(&token,signal)!=0 && errno!=ESRCH) fail("Owned Mac execution could not be stopped");
+    return 0;
+  }
+  if(!all && (argc!=4 || strcmp(argv[1],"inspect"))) fail("Invalid Mac execution helper command");
+  uint64_t count=1; int exists=all?1:active(id,&count);
+  if(!exists || !count) { printf("{\"exists\":%s,\"active\":0,\"members\":[]}\n",exists?"true":"false"); return 0; }
+  int capacity=proc_listpids(PROC_UID_ONLY,getuid(),NULL,0)/(int)sizeof(pid_t)+1024;
+  if(capacity<=1024 || capacity>1000000) fail("Mac process enumeration is unavailable");
+  pid_t *pids=calloc((size_t)capacity,sizeof(pid_t));
+  struct process_info *rows=calloc((size_t)capacity,sizeof(struct process_info));
+  if(!pids || !rows) fail("Mac process enumeration could not allocate memory");
+  int bytes=proc_listpids(PROC_UID_ONLY,getuid(),pids,capacity*(int)sizeof(pid_t));
+  if(bytes<0 || bytes%(int)sizeof(pid_t)) fail("Mac process enumeration is unavailable");
+  int total=bytes/(int)sizeof(pid_t), found=0;
+  if(total<0 || total>=capacity) changed();
+  for(int i=0;i<total;i++) {
+    uint64_t candidate; if(pids[i]<=0 || (!all && (!coalition(pids[i],&candidate) || candidate!=id))) continue;
+    struct process_info row={0}, after={0};
+    if(!process_info(pids[i],&row) || (!all && (!coalition(pids[i],&candidate) || candidate!=id)) || !process_info(pids[i],&after)) continue;
+    if(row.unique.version!=after.unique.version) continue;
+    if(row.bsd.pbi_uid!=getuid()) fail("Mac execution membership includes a different user");
+    rows[found++]=row;
+  }
+  if(all) count=(uint64_t)found; else exists=active(id,&count);
+  // A new task missing from the snapshot is uncertainty, never empty success.
+  if(count>(uint64_t)found) changed();
+  printf("{\"exists\":%s,\"active\":%"PRIu64",\"members\":[",exists?"true":"false",count);
+  for(int i=0;count && i<found;i++) {
+    struct process_info *row=&rows[i]; time_t seconds=(time_t)row->bsd.pbi_start_tvsec; struct tm tm; char date[32];
+    gmtime_r(&seconds,&tm); strftime(date,sizeof(date),"%Y-%m-%dT%H:%M:%S",&tm);
+    printf("%s{\"pid\":%u,\"ppid\":%u,\"pgid\":%u,\"owner\":\"%u\",\"birth\":\"%s.%06"PRIu64"Z\",\"version\":%u}",i?",":"",row->bsd.pbi_pid,row->bsd.pbi_ppid,row->bsd.pbi_pgid,row->bsd.pbi_uid,date,row->bsd.pbi_start_tvusec,(uint32_t)row->unique.version);
+  }
+  puts("]}"); free(rows); free(pids); return 0;
+}