@north-light/crouter 0.3.221 → 0.3.222

package/dist/core/__tests__/human-action-delivery.test.js

@@ -0,0 +1,140 @@
+import { after, afterEach, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb } from '../canvas/db.js';
+import { claimActionDelivery, enqueueActionDelivery, readActionDelivery, } from '../canvas/human-deliveries.js';
+import { actionDeliveryBackoffMs, actionDeliverySettlementForOutcome, deliverAction, } from '../../daemon/human/deliver-action.js';
+let home;
+const priorHome = process.env['CRTR_HOME'];
+beforeEach(() => {
+    closeDb();
+    home = mkdtempSync(join(tmpdir(), 'crtr-human-action-delivery-'));
+    process.env['CRTR_HOME'] = home;
+});
+afterEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    if (priorHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = priorHome;
+});
+test('action delivery retries follow the durable backoff and exit boundary', () => {
+    assert.equal(actionDeliveryBackoffMs(1), 5_000);
+    assert.equal(actionDeliveryBackoffMs(2), 10_000);
+    assert.equal(actionDeliveryBackoffMs(3), 20_000);
+    assert.equal(actionDeliveryBackoffMs(11), 3_600_000);
+    assert.equal(actionDeliveryBackoffMs(100), 3_600_000);
+    const now = 1_000_000;
+    const outcome = (exitCode, signal = null) => actionDeliverySettlementForOutcome({
+        exitCode,
+        signal,
+        timedOut: false,
+        stderr: 'diagnostic',
+    }, 2, now);
+    assert.deepEqual(outcome(0), { state: 'accepted' });
+    assert.deepEqual(outcome(77), {
+        state: 'pending',
+        nextAttemptAt: now + 10_000,
+        failure: { kind: 'exit', exitCode: 77, stderr: 'diagnostic' },
+    });
+    assert.deepEqual(outcome(78), {
+        state: 'permanent_failed',
+        failure: { kind: 'exit', exitCode: 78, stderr: 'diagnostic' },
+    });
+    assert.equal(outcome(79).state, 'pending');
+    assert.equal(outcome(null, 'SIGTERM').state, 'pending');
+    assert.equal(actionDeliverySettlementForOutcome({
+        exitCode: null,
+        signal: null,
+        timedOut: true,
+        stderr: '',
+    }, 1, now).state, 'pending');
+    // The kill escalation's signal is the only way to tell the graceful term from the SIGKILL.
+    assert.deepEqual(actionDeliverySettlementForOutcome({
+        exitCode: null,
+        signal: 'SIGKILL',
+        timedOut: true,
+        stderr: 'stalled',
+    }, 1, now), {
+        state: 'pending',
+        nextAttemptAt: now + 5_000,
+        failure: { kind: 'timeout', signal: 'SIGKILL', stderr: 'stalled' },
+    });
+    assert.equal(actionDeliverySettlementForOutcome({
+        exitCode: null,
+        signal: null,
+        timedOut: false,
+        spawnError: new Error('missing executable'),
+        stderr: '',
+    }, 1, now).state, 'pending');
+});
+test('the delivery child gets the consent boundary env, never crtrd\'s own', async () => {
+    const priorUserHome = process.env['HOME'];
+    const project = join(home, 'project');
+    mkdirSync(join(project, '.crouter'), { recursive: true });
+    writeFileSync(join(project, '.crouter', 'config.json'), JSON.stringify({ spawnEnv: { allow: ['NL_*'] } }));
+    const envDump = join(home, 'child-env.txt');
+    const stdinDump = join(home, 'child-stdin.json');
+    const script = join(home, 'action.sh');
+    writeFileSync(script, `#!/bin/sh\nenv > ${envDump}\ncat > ${stdinDump}\n`);
+    chmodSync(script, 0o755);
+    process.env['HOME'] = home; // no real user-scope config contributes to the boundary
+    process.env['NL_CORE_URL'] = 'http://core.test';
+    process.env['CRTRD_ONLY_SECRET'] = 'must-not-cross';
+    const requestId = 'b'.repeat(64);
+    try {
+        enqueueActionDelivery({
+            requestId,
+            argv: [script],
+            cwd: project,
+            completion: { schema: 'crtr.human-completion/v1', requestId, delivery: { attempt: 0 } },
+        });
+        const claimed = claimActionDelivery(requestId, Date.now(), 'claimant');
+        assert.ok(claimed !== null);
+        await deliverAction(claimed, 'claimant');
+    }
+    finally {
+        delete process.env['NL_CORE_URL'];
+        delete process.env['CRTRD_ONLY_SECRET'];
+        if (priorUserHome === undefined)
+            delete process.env['HOME'];
+        else
+            process.env['HOME'] = priorUserHome;
+    }
+    assert.equal(readActionDelivery(requestId)?.state, 'accepted');
+    const childEnv = new Map(readFileSync(envDump, 'utf8').split('\n').flatMap((line) => {
+        const split = line.indexOf('=');
+        return split === -1 ? [] : [[line.slice(0, split), line.slice(split + 1)]];
+    }));
+    assert.equal(childEnv.get('CRTRD_ONLY_SECRET'), undefined, 'crtrd host state must not cross without consent');
+    assert.equal(childEnv.get('NL_CORE_URL'), 'http://core.test', 'the target cwd\'s spawnEnv.allow carries its own config across');
+    assert.equal(childEnv.get('CRTR_HOME'), home, 'an action that calls crtr must reach the daemon that delivered to it');
+    assert.equal(JSON.parse(readFileSync(stdinDump, 'utf8')).delivery.attempt, 1);
+});
+test('the guarded claim admits only one contender', () => {
+    const requestId = 'a'.repeat(64);
+    enqueueActionDelivery({
+        requestId,
+        argv: ['/bin/true'],
+        cwd: home,
+        completion: { schema: 'crtr.human-completion/v1', delivery: { attempt: 0 } },
+    });
+    const now = Date.now();
+    const first = claimActionDelivery(requestId, now, 'claimant-a');
+    const second = claimActionDelivery(requestId, now, 'claimant-b');
+    assert.equal(first?.state, 'running');
+    assert.equal(first?.attempt, 1);
+    assert.equal(second, null);
+    assert.deepEqual(readActionDelivery(requestId) && {
+        state: readActionDelivery(requestId).state,
+        attempt: readActionDelivery(requestId).attempt,
+        claimOwner: readActionDelivery(requestId).claimOwner,
+    }, { state: 'running', attempt: 1, claimOwner: 'claimant-a' });
+});

package/dist/core/__tests__/human-actions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/human-actions.test.js

@@ -0,0 +1,116 @@
+// Run with: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/human-actions.test.ts
+//
+// This pins the silent execution boundary: a request must select the nearest
+// project declaration before farther projects or user scope, and its relative
+// executable/cwd must resolve from that declaration's authoring root.
+import { after, afterEach, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveHumanAction } from '../human-actions.js';
+import { createProfile } from '../profiles/manifest.js';
+import { resetScopeCache } from '../scope.js';
+let home;
+let cwd;
+let previousHome;
+let previousProfile;
+let previousCwd;
+before(() => {
+    previousHome = process.env['HOME'];
+    previousProfile = process.env['CRTR_PROFILE_ID'];
+    previousCwd = process.cwd();
+});
+beforeEach(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-human-actions-home-'));
+    cwd = join(home, 'work', 'outer', 'nested', 'src');
+    mkdirSync(cwd, { recursive: true });
+    process.env['HOME'] = home;
+    delete process.env['CRTR_PROFILE_ID'];
+    process.chdir(cwd);
+    resetScopeCache();
+});
+afterEach(() => {
+    process.chdir(previousCwd);
+    rmSync(home, { recursive: true, force: true });
+    resetScopeCache();
+});
+after(() => {
+    process.chdir(previousCwd);
+    if (previousHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = previousHome;
+    if (previousProfile === undefined)
+        delete process.env['CRTR_PROFILE_ID'];
+    else
+        process.env['CRTR_PROFILE_ID'] = previousProfile;
+    resetScopeCache();
+});
+function writeAction(root, relativeExecutable, relativeCwd) {
+    const executable = join(root, relativeExecutable);
+    mkdirSync(join(executable, '..'), { recursive: true });
+    writeFileSync(executable, '');
+    chmodSync(executable, 0o755);
+    mkdirSync(join(root, relativeCwd), { recursive: true });
+}
+test('nearest project declaration wins and resolves paths from its authoring root', () => {
+    const userRoot = join(home, '.crouter');
+    writeAction(userRoot, 'user-bin', 'user-cwd');
+    mkdirSync(userRoot, { recursive: true });
+    writeFileSync(join(userRoot, 'config.json'), JSON.stringify({
+        humanActions: { release: { argv: ['user-bin'], cwd: 'user-cwd' }, 'user-only': { argv: ['user-bin'], cwd: 'user-cwd' } },
+    }));
+    const outer = join(home, 'work', 'outer');
+    writeAction(outer, 'outer-bin', 'outer-cwd');
+    mkdirSync(join(outer, '.crouter'), { recursive: true });
+    writeFileSync(join(outer, '.crouter', 'config.json'), JSON.stringify({
+        humanActions: { release: { argv: ['outer-bin'], cwd: 'outer-cwd' } },
+    }));
+    const nearest = join(outer, 'nested');
+    writeAction(nearest, 'scripts/finish-release', 'work');
+    mkdirSync(join(nearest, '.crouter'), { recursive: true });
+    writeFileSync(join(nearest, '.crouter', 'config.json'), JSON.stringify({
+        humanActions: { release: { argv: ['scripts/finish-release', '--nearest'], cwd: 'work' } },
+    }));
+    resetScopeCache();
+    assert.deepEqual(resolveHumanAction('release', cwd), {
+        name: 'release',
+        configOrigin: join(nearest, '.crouter', 'config.json'),
+        argv: [join(nearest, 'scripts/finish-release'), '--nearest'],
+        cwd: join(nearest, 'work'),
+    });
+    assert.deepEqual(resolveHumanAction('user-only', cwd), {
+        name: 'user-only',
+        configOrigin: join(userRoot, 'config.json'),
+        argv: [join(userRoot, 'user-bin')],
+        cwd: join(userRoot, 'user-cwd'),
+    });
+    const profileProject = join(home, 'profile-project');
+    writeAction(profileProject, 'profile-bin', 'profile-cwd');
+    mkdirSync(join(profileProject, '.crouter'), { recursive: true });
+    writeFileSync(join(profileProject, '.crouter', 'config.json'), JSON.stringify({
+        humanActions: { 'profile-only': { argv: ['profile-bin'], cwd: 'profile-cwd' } },
+    }));
+    process.env['CRTR_PROFILE_ID'] = createProfile('human-actions-test', [{ path: profileProject, memory: 'content' }]).profileId;
+    resetScopeCache();
+    assert.deepEqual(resolveHumanAction('profile-only', cwd), { kind: 'unknown_action', name: 'profile-only' });
+});
+test('a malformed nearer humanActions block does not shadow a farther declaration', () => {
+    const outer = join(home, 'work', 'outer');
+    writeAction(outer, 'outer-bin', 'outer-cwd');
+    mkdirSync(join(outer, '.crouter'), { recursive: true });
+    writeFileSync(join(outer, '.crouter', 'config.json'), JSON.stringify({
+        humanActions: { release: { argv: ['outer-bin'], cwd: 'outer-cwd' } },
+    }));
+    const nearest = join(outer, 'nested');
+    mkdirSync(join(nearest, '.crouter'), { recursive: true });
+    writeFileSync(join(nearest, '.crouter', 'config.json'), JSON.stringify({ humanActions: [] }));
+    resetScopeCache();
+    assert.deepEqual(resolveHumanAction('release', cwd), {
+        name: 'release',
+        configOrigin: join(outer, '.crouter', 'config.json'),
+        argv: [join(outer, 'outer-bin')],
+        cwd: join(outer, 'outer-cwd'),
+    });
+});

package/dist/core/__tests__/inline-memory-refs.test.js

@@ -14,7 +14,7 @@ import { resetScopeCache } from '../scope.js';
 import { clearSessionCache } from '../substrate/session-cache.js';
 import { memoryDir as nodeMemoryDir } from '../runtime/memory.js';
 import { buildRefInventory } from '../memory/inline-ref-inventory.js';
-import { gatewayMemoryRows } from '../runtime/broker-inventory.js';
+import { gatewayMemoryRows } from '../runtime/chat-inventory-rows.js';
 // ---------------------------------------------------------------------------
 // Wave C4 — buildRefInventory: the authoritative corpus builder. Fixture-
 // backed (node/project/user scope docs on disk), since precedence dedup,

package/dist/core/__tests__/profile-project-memory-delivery.test.js

@@ -191,7 +191,7 @@ test('workspace-open clamps each project store the same way boot does', () => {
     const opened = renderWorkspaceOpenDocs(newNode(), new Map());
     assert.ok(opened.includes(B.pcontent), `the content-capped project delivers its body; got:\n${opened}`);
     assert.ok(!opened.includes(B.ppreview), `the cwd project must not deliver its body; got:\n${opened}`);
-    assert.match(opened, /name="t9-ppreview-doc"[^>]*>\nWhen the cwd project delivers\./, `the cwd project delivers its preview line; got:\n${opened}`);
+    assert.match(opened, /name="t9-ppreview-doc" readWhen="When the cwd project delivers\./, `the cwd project delivers its preview line; got:\n${opened}`);
     assert.match(opened, /name="t9-pname-doc"[^>]*\/>/, `the name-capped doc delivers name-only; got:\n${opened}`);
     assert.ok(!opened.includes('t9-pnone-doc'), 'the none-capped project delivers nothing at workspace-open');
     assert.ok(!opened.includes(B.sharedFromPnone), 'nor its side of a name collision');

package/dist/core/__tests__/prospective-inventory-capability-parity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/prospective-inventory-capability-parity.test.js

@@ -0,0 +1,91 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DefaultResourceLoader, ExtensionRunner, } from '@earendil-works/pi-coding-agent';
+import { captureChatCapabilities, registrationChatSurface } from '../runtime/command-surface.js';
+test('startup capability capture preserves same-name lifecycle replacements and excludes new lifecycle registrations', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-prospective-capability-'));
+    const agentDir = join(root, '.pi');
+    const invoked = join(root, 'late-invoked');
+    mkdirSync(agentDir);
+    const first = join(root, 'first.js');
+    const second = join(root, 'second.js');
+    writeFileSync(first, `
+import { writeFileSync } from 'node:fs';
+export default function (pi) {
+  pi.registerCommand('collision', {
+    description: 'first factory command',
+    gateway: true,
+    argumentHint: '<first>',
+    handler: async () => {},
+  });
+  pi.on('session_start', () => {
+    pi.registerCommand('collision', {
+      description: 'lifecycle replacement',
+      argumentHint: '<replacement>',
+      handler: async () => {},
+    });
+    pi.registerCommand('late', {
+      description: 'lifecycle command',
+      gateway: true,
+      handler: async () => writeFileSync(${JSON.stringify(invoked)}, 'yes'),
+    });
+  });
+}
+`);
+    writeFileSync(second, `
+export default function (pi) {
+  pi.registerCommand('collision', {
+    description: 'second factory command',
+    gateway: true,
+    argumentHint: '<second>',
+    handler: async () => {},
+  });
+}
+`);
+    try {
+        const loader = new DefaultResourceLoader({
+            cwd: root,
+            agentDir,
+            additionalExtensionPaths: [first, second],
+            noContextFiles: true,
+        });
+        await loader.reload();
+        const loaded = loader.getExtensions();
+        assert.deepEqual(loaded.errors, []);
+        const runner = new ExtensionRunner(loaded.extensions, loaded.runtime, root, undefined, undefined);
+        const startupCommands = runner.getRegisteredCommands();
+        captureChatCapabilities({ commands: startupCommands, templates: [] });
+        const startupRows = startupCommands.map((command) => ({
+            name: command.invocationName,
+            ...registrationChatSurface(command),
+        }));
+        assert.deepEqual(startupRows, [
+            { name: 'collision:1', gatewayCapable: true, argumentHint: '<first>' },
+            { name: 'collision:2', gatewayCapable: true, argumentHint: '<second>' },
+        ]);
+        for (const extension of loaded.extensions) {
+            for (const handler of extension.handlers.get('session_start') ?? []) {
+                await handler({ type: 'session_start' }, {});
+            }
+        }
+        const reloadedRows = runner.getRegisteredCommands().map((command) => ({
+            name: command.invocationName,
+            ...registrationChatSurface(command),
+        }));
+        assert.deepEqual(reloadedRows, [
+            { name: 'collision:1', gatewayCapable: true, argumentHint: '<replacement>' },
+            { name: 'late', gatewayCapable: false },
+            { name: 'collision:2', gatewayCapable: true, argumentHint: '<second>' },
+        ]);
+        const late = runner.getCommand('late');
+        assert.ok(late, 'the lifecycle command remains registered and addressable');
+        await late.handler('', {});
+        assert.equal(existsSync(invoked), true, 'the lifecycle command remains invokable');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/core/__tests__/seam/memory-slash-node-relative-inventory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/seam/memory-slash-node-relative-inventory.test.js

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { test } from 'node:test';
+import { loadedCommandPreview } from '../../../clients/attach/slash/prompt-preview.js';
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '../../../..');
+const EXTENSION = join(ROOT, 'dist/builtin-pi-packages/pi-crtr-extensions/extensions/memory-slash-commands.ts');
+const LIVE_PROBE = join(ROOT, 'dist/core/__tests__/fixtures/memory-slash-live-probe.js');
+const COMMAND_NAMES = ['acceptance-context-token', 'acceptance-node-token', 'acceptance-independent'];
+function writeSlashDoc(memoryDir, name, description, body) {
+    writeFileSync(join(memoryDir, `${name}.md`), `---\nkind: knowledge\nwhen-and-why-to-read: Acceptance fixture.\nshort-form: ${description}\nslash: true\n---\n${body}`);
+}
+function liveProbe(input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [LIVE_PROBE, EXTENSION, JSON.stringify(input.invocations)], {
+            cwd: input.cwd,
+            env: {
+                ...process.env,
+                CRTR_HOME: input.home,
+                CRTR_NODE_ID: input.nodeId,
+                CRTR_PROFILE_ID: '',
+                PI_CODING_AGENT_DIR: join(input.cwd, '.pi'),
+            },
+            stdio: ['ignore', 'pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let response = '';
+        const stdoutStream = child.stdout;
+        const stderrStream = child.stderr;
+        const responseStream = child.stdio[3];
+        if (stdoutStream === null || stderrStream === null || responseStream === null) {
+            child.kill('SIGKILL');
+            reject(new Error('live probe response channel unavailable'));
+            return;
+        }
+        stdoutStream.setEncoding('utf8');
+        stderrStream.setEncoding('utf8');
+        responseStream.setEncoding('utf8');
+        stdoutStream.on('data', (chunk) => { stdout += chunk; });
+        stderrStream.on('data', (chunk) => { stderr += chunk; });
+        responseStream.on('data', (chunk) => { response += chunk; });
+        child.on('error', reject);
+        child.on('close', (code, signal) => {
+            if (code !== 0) {
+                reject(new Error(`live probe exited ${code ?? signal ?? 'unknown'}: ${stderr}${stdout}`));
+                return;
+            }
+            resolve(JSON.parse(response));
+        });
+    });
+}
+function fixtureRows(rows) {
+    return COMMAND_NAMES.map((name) => {
+        const row = rows.find((candidate) => candidate.name === name);
+        assert.ok(row, `Gateway advertises /${name}`);
+        return row;
+    });
+}
+test('node-relative memory slash commands omit preview metadata without changing live sends', async () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'crtr-memory-slash-inventory-'));
+    const home = join(cwd, 'canvas');
+    const memoryDir = join(cwd, '.crouter', 'memory');
+    const nodeId = 'acceptance-live-node';
+    mkdirSync(memoryDir, { recursive: true });
+    writeSlashDoc(memoryDir, COMMAND_NAMES[0], 'Context-relative fixture.', 'Store $ARGUMENTS in $CRTR_CONTEXT_DIR/result.md.\n');
+    writeSlashDoc(memoryDir, COMMAND_NAMES[1], 'Node-relative fixture.', 'Node $CRTR_NODE_ID received $ARGUMENTS.\n');
+    writeSlashDoc(memoryDir, COMMAND_NAMES[2], 'Node-independent fixture.', 'Independent payload: $ARGUMENTS.\n');
+    try {
+        const live = await liveProbe({
+            cwd,
+            home,
+            nodeId,
+            invocations: COMMAND_NAMES.map((name) => ({ name, args: 'evidence' })),
+        });
+        assert.equal(live.stateBeforeProspective, false);
+        assert.equal(live.stateAfterProspective, false);
+        assert.deepEqual(live.commands, live.prospective.commands);
+        assert.deepEqual(live.memoryRefs, live.prospective.memory_refs);
+        const prospectiveRows = fixtureRows(live.prospective.commands);
+        const liveRows = fixtureRows(live.commands);
+        assert.deepEqual(liveRows, prospectiveRows);
+        assert.deepEqual(prospectiveRows, [
+            { name: COMMAND_NAMES[0], description: 'Context-relative fixture.', source: 'command' },
+            { name: COMMAND_NAMES[1], description: 'Node-relative fixture.', source: 'command' },
+            {
+                name: COMMAND_NAMES[2],
+                description: 'Node-independent fixture.',
+                source: 'command',
+                expansion: {
+                    kind: 'memory-slash',
+                    commandName: COMMAND_NAMES[2],
+                    body: 'Independent payload: $ARGUMENTS.\n',
+                },
+            },
+        ]);
+        const insightsInit = live.commands.find((row) => row.name === 'insights:init');
+        assert.ok(insightsInit, 'Gateway completion includes /insights:init');
+        assert.equal(insightsInit.expansion, undefined);
+        assert.equal(loadedCommandPreview('/insights:init agent-facing CLI', live.commands), undefined);
+        assert.equal(loadedCommandPreview('/acceptance-independent first evidence', live.commands)?.content, 'Independent payload: first evidence.\n');
+        assert.equal(loadedCommandPreview('/acceptance-independent changed evidence', live.commands)?.content, 'Independent payload: changed evidence.\n');
+        assert.deepEqual(live.notifications, []);
+        const sentContent = Object.fromEntries(live.sent.map((send) => [send.name, send.message.content]));
+        assert.deepEqual(sentContent, {
+            [COMMAND_NAMES[0]]: `Store evidence in ${join(home, 'nodes', nodeId, 'context', 'result.md')}.\n`,
+            [COMMAND_NAMES[1]]: `Node ${nodeId} received evidence.\n`,
+            [COMMAND_NAMES[2]]: 'Independent payload: evidence.\n',
+        });
+        for (const send of live.sent) {
+            assert.deepEqual(send.message, {
+                customType: 'memory-slash-command',
+                content: sentContent[send.name],
+                display: true,
+            });
+            assert.deepEqual(send.options, { triggerTurn: true });
+        }
+        assert.doesNotMatch(sentContent[COMMAND_NAMES[0]], /\$CRTR_CONTEXT_DIR|\$CRTR_NODE_ID/);
+        assert.doesNotMatch(sentContent[COMMAND_NAMES[1]], /\$CRTR_CONTEXT_DIR|\$CRTR_NODE_ID/);
+    }
+    finally {
+        rmSync(cwd, { recursive: true, force: true });
+    }
+});

package/dist/core/__tests__/seam/prospective-inventory-stdout.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/seam/prospective-inventory-stdout.test.js

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { runProspectiveInventory } from '../../runtime/prospective-inventory.js';
+test('prospective preflight keeps package stdout out of its response channel', async () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'crtr-prospective-stdout-'));
+    const extension = join(cwd, 'loud-extension.mjs');
+    writeFileSync(extension, `
+export default function (pi) {
+  console.log('harmless package diagnostic');
+  pi.registerCommand('stdout-probe', {
+    description: 'survives package stdout',
+    gateway: true,
+    handler: async () => {},
+  });
+}
+`);
+    try {
+        const rows = await runProspectiveInventory({ cwd, profileId: null, extensions: [extension] });
+        assert.deepEqual(rows.commands.find((row) => row.name === 'stdout-probe'), {
+            name: 'stdout-probe',
+            description: 'survives package stdout',
+            source: 'command',
+        });
+    }
+    finally {
+        rmSync(cwd, { recursive: true, force: true });
+    }
+});

package/dist/core/canvas/db.js

@@ -1153,6 +1153,28 @@ ALTER TABLE crons ADD COLUMN held INTEGER NOT NULL DEFAULT 0;
 ALTER TABLE crons ADD COLUMN last_poke_at TEXT;
 `);
 }
+/** v33 — durable, daemon-owned attempts to deliver settled human completions. */
+function addHumanActionDeliveries(db) {
+    db.exec(`
+CREATE TABLE human_action_deliveries (
+  request_id           TEXT PRIMARY KEY,
+  state                TEXT NOT NULL,
+  attempt              INTEGER NOT NULL DEFAULT 0,
+  argv_json            TEXT NOT NULL,
+  cwd                  TEXT NOT NULL,
+  completion_json      TEXT NOT NULL,
+  next_attempt_at      INTEGER NOT NULL,
+  claimed_at           INTEGER,
+  claim_owner          TEXT,
+  accepted_at          INTEGER,
+  permanent_failed_at  INTEGER,
+  last_failure_json    TEXT,
+  created_at           INTEGER NOT NULL,
+  updated_at           INTEGER NOT NULL
+);
+CREATE INDEX idx_human_action_deliveries_due ON human_action_deliveries(state, next_attempt_at);
+`);
+}
 /** The journaled lane of the state-migration registry, adapted to this chain's
  *  step shape. Registry order is preserved, so these versions stay stable as
  *  long as the registry is append-only (same contract as the local list). */
@@ -1198,6 +1220,7 @@ export const MIGRATIONS = [
     /* v30 */ dropConsultOutbox,
     /* v31 */ addReviewSubmitRequested,
     /* v32 */ addCronHeldColumns,
+    /* v33 */ addHumanActionDeliveries,
     ...JOURNALED_STATE_MIGRATIONS,
 ];
 /** Migration indexes that manage their OWN transaction and therefore must not

package/dist/core/canvas/human-deliveries.d.ts

@@ -0,0 +1,53 @@
+export type ActionDeliveryState = 'pending' | 'running' | 'accepted' | 'permanent_failed';
+export interface ActionDeliveryFailure {
+    kind: 'exit' | 'signal' | 'timeout' | 'spawn_error';
+    exitCode?: number;
+    signal?: string;
+    message?: string;
+    stderr?: string;
+}
+export interface ActionDeliveryRecord {
+    requestId: string;
+    state: ActionDeliveryState;
+    attempt: number;
+    argv: string[];
+    cwd: string;
+    completion: unknown;
+    nextAttemptAt: number;
+    claimedAt: number | null;
+    claimOwner: string | null;
+    acceptedAt: number | null;
+    permanentFailedAt: number | null;
+    lastFailure: ActionDeliveryFailure | null;
+    createdAt: number;
+    updatedAt: number;
+}
+/** Insert the one delivery row for a settled action-bound request. Idempotent
+ *  on requestId: a replayed settlement must not create a second row. */
+export declare function enqueueActionDelivery(row: {
+    requestId: string;
+    argv: string[];
+    cwd: string;
+    /** Complete HumanCompletionV1 with delivery.attempt set to 0. */
+    completion: unknown;
+}): void;
+/** Delivery state for `GET /v1/human/requests/:id`; null when no row exists. */
+export declare function readActionDelivery(requestId: string): ActionDeliveryRecord | null;
+/** Due pending records in deterministic order for the daemon's serial tick. */
+export declare function dueActionDeliveries(now: number): ActionDeliveryRecord[];
+/** Atomically start one due delivery attempt. A null result lost the claim. */
+export declare function claimActionDelivery(requestId: string, now: number, claimOwner: string): ActionDeliveryRecord | null;
+export type ActionDeliverySettlement = {
+    state: 'accepted';
+} | {
+    state: 'permanent_failed';
+    failure: ActionDeliveryFailure;
+} | {
+    state: 'pending';
+    nextAttemptAt: number;
+    failure: ActionDeliveryFailure;
+};
+/** Settle only the still-owned running attempt, so a stale process cannot overwrite a newer claim. */
+export declare function settleActionDelivery(requestId: string, attempt: number, claimOwner: string, settlement: ActionDeliverySettlement, now: number): boolean;
+/** A new daemon deliberately redelivers interrupted completions at least once. */
+export declare function recoverRunningActionDeliveries(now: number): number;