@north-light/crouter 0.3.303 → 0.3.304

package/dist/commands/__tests__/seam/daemon-status.test.d.ts

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

package/dist/commands/__tests__/seam/daemon-status.test.js

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+test('daemon status reports its failed probe without telling the operator to stop a live process', () => {
+    const home = mkdtempSync(join(tmpdir(), 'crtr-daemon-status-'));
+    const pidfile = join(home, 'crtrd.pid');
+    const owner = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1_000)'], { stdio: 'ignore' });
+    try {
+        assert.ok(owner.pid !== undefined, 'fixture process has a pid');
+        writeFileSync(pidfile, String(owner.pid));
+        const result = spawnSync(process.execPath, [join(process.cwd(), 'dist', 'cli.js'), '--json', 'sys', 'daemon', 'status'], {
+            encoding: 'utf8',
+            env: { ...process.env, CRTR_HOME: home, CRTR_PIDFILE: pidfile, CRTR_NO_DAEMON_AUTOSTART: '1' },
+            timeout: 10_000,
+        });
+        assert.equal(result.status, 0, result.stderr);
+        const output = JSON.parse(result.stdout);
+        assert.deepEqual({ running: output.running, serving: output.serving }, { running: true, serving: false });
+        assert.match(output.probe_error ?? '', /ENOENT|ECONNREFUSED/);
+        assert.equal(output.next, undefined, 'a single failed health probe is not a reason to tell the operator to stop the owner');
+    }
+    finally {
+        owner.kill('SIGKILL');
+        rmSync(home, { recursive: true, force: true });
+    }
+});

package/dist/commands/api-client.d.ts

@@ -38,9 +38,9 @@ export declare function readColdStartDiagnostic(): string | undefined;
  *  default: on a cold socket the injected `onColdSocket` hook fires
  *  `ensureDaemon()` (spawns crtrd detached via the branded host), then the
  *  client polls `/healthz` to a bounded deadline and retries once (the poll
- *  lives inside `CrtrClient`, A-2). If crtrd never becomes reachable — or
- *  autostart is disabled — the client throws `daemon_unavailable` (spec §7.1,
- *  §8). This is the ONLY CLI reference to `ensureDaemon`.
+ *  lives inside `CrtrClient`, A-2). If crtrd never becomes reachable, the
+ *  client surfaces the final observed transport failure. This is the ONLY CLI
+ *  reference to `ensureDaemon`.
  *
  *  `onColdSocket` is fire-and-forget — `ensureDaemon()` spawns crtrd and
  *  returns immediately, so the client's OWN `/healthz` poll is the only

package/dist/commands/api-client.js

@@ -104,9 +104,9 @@ export function readColdStartDiagnostic() {
  *  default: on a cold socket the injected `onColdSocket` hook fires
  *  `ensureDaemon()` (spawns crtrd detached via the branded host), then the
  *  client polls `/healthz` to a bounded deadline and retries once (the poll
- *  lives inside `CrtrClient`, A-2). If crtrd never becomes reachable — or
- *  autostart is disabled — the client throws `daemon_unavailable` (spec §7.1,
- *  §8). This is the ONLY CLI reference to `ensureDaemon`.
+ *  lives inside `CrtrClient`, A-2). If crtrd never becomes reachable, the
+ *  client surfaces the final observed transport failure. This is the ONLY CLI
+ *  reference to `ensureDaemon`.
  *
  *  `onColdSocket` is fire-and-forget — `ensureDaemon()` spawns crtrd and
  *  returns immediately, so the client's OWN `/healthz` poll is the only

package/dist/commands/memory/read.js

@@ -22,7 +22,8 @@ async function fetchSubject(nodeId) {
     if (nodeId === undefined)
         return null;
     try {
-        return await CrtrClient.forLocalSocket({ autostart: false }).nodeSubject(nodeId);
+        // This optional gate lookup must not hold a memory read while a daemon is unavailable: an absent subject simply skips gated docs.
+        return await CrtrClient.forLocalSocket({ autostart: false, coldStartPollWindowMs: 0 }).nodeSubject(nodeId);
     }
     catch {
         return null;

package/dist/commands/node/bash.js

@@ -117,7 +117,7 @@ const nodeBashKill = defineLeaf({
     tier: 'hidden',
     help: {
         name: 'node bash kill',
-        summary: 'terminate a background bash job’s process group and tell the owning node it was canceled',
+        summary: 'best-effort stop a background bash job and tell the owning node it was canceled',
         params: [
             { kind: 'positional', name: 'job', required: true, constraint: 'Job id, as reported by node bash list.' },
             { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node owning the job. Defaults to the node in --pane, else the caller (CRTR_NODE_ID).' },
@@ -125,11 +125,11 @@ const nodeBashKill = defineLeaf({
         ],
         output: [
             { name: 'node_id', type: 'string', required: true, constraint: 'The owning node.' },
-            { name: 'signaled', type: 'boolean', required: true, constraint: 'True when the process group was still alive and received SIGTERM.' },
+            { name: 'signaled', type: 'boolean', required: true, constraint: 'True when at least one observed supervisor-tree process received SIGTERM.' },
         ],
         outputKind: 'object',
         effects: [
-            'Sends SIGTERM (then SIGKILL) to the job’s whole process group, stopping the command and anything it forked.',
+            'Snapshots the supervisor’s observable process tree, sends SIGTERM then SIGKILL to those processes, and cannot stop a descendant that detached and reparented before the snapshot.',
             'Records the job’s exit so it stops showing as live, and sends the owning node an urgent inbox message saying the job was stopped — which steers that node mid-turn.',
         ],
     },
@@ -159,8 +159,8 @@ const nodeBashKill = defineLeaf({
         if (stopped.kind === 'not-stoppable') {
             throw new InputError({
                 error: 'not_stoppable',
-                message: `job ${jobId} recorded no process group`,
-                next: `It started before crtr persisted one. Stop it by hand, then it will disappear from the list. Log: ${paths.jobLog}`,
+                message: `job ${jobId} recorded no trusted process identity`,
+                next: `It started before crtr persisted its supervisor identity. Stop it by hand, then it will disappear from the list. Log: ${paths.jobLog}`,
             });
         }
         await cliClient().sendMessage(node.node_id, {
@@ -169,7 +169,7 @@ const nodeBashKill = defineLeaf({
         });
         return { node_id: node.node_id, signaled: stopped.signaled };
     },
-    render: (result) => `Canceled a background bash job for ${result['node_id']}${result['signaled'] === true ? '' : ' (its process group was already gone)'}.`,
+    render: (result) => `Canceled a background bash job for ${result['node_id']}${result['signaled'] === true ? '' : ' (no observed job process was still running)'}.`,
 });
 const nodeBashExtend = defineLeaf({
     name: 'extend',

package/dist/commands/node/message.js

@@ -38,7 +38,7 @@ async function resolveMsgTarget(input, hasBody) {
 }
 function messageOutput() {
     return [
-        { name: 'revived', type: 'boolean', required: false, constraint: 'True when the target was revived.' },
+        { name: 'revived', type: 'boolean', required: false, constraint: 'True when this request synchronously revived the target; ordinary durable delivery to an active or idle dormant target queues lifecycle revival instead.' },
         { name: 'guidance', type: 'string', required: true, constraint: 'Immediate action confirmation.' },
     ];
 }
@@ -67,7 +67,7 @@ function messageRequestParams() {
         { kind: 'stdin', name: 'body', required: false, constraint: 'Visible message body. The schema alone is a complete request.', positionalStdinConflict: missingMessageTargetForBody },
         { kind: 'flag', name: 'to', type: 'string', required: false, constraint: 'Target an existing node by id. Exactly one of --to or --self is required.' },
         { kind: 'flag', name: 'self', type: 'bool', required: false, constraint: 'Target the calling node. Exactly one of --to or --self is required.' },
-        { kind: 'flag', name: 'tier', type: 'enum', choices: ['critical', 'urgent', 'normal'], required: false, default: 'normal', constraint: 'Delivery urgency. Every accepted tier may revive a dormant target, because the request must be answered; deferred is rejected for that reason.' },
+        { kind: 'flag', name: 'tier', type: 'enum', choices: ['critical', 'urgent', 'normal'], required: false, default: 'normal', constraint: 'Delivery urgency. Every accepted tier queues lifecycle revival for an active or idle dormant target because the request must be answered; deferred is rejected for that reason.' },
         { kind: 'flag', name: 'output-schema', type: 'string', required: true, constraint: `JSON Schema the result must satisfy. ${OUTPUT_SCHEMA_TRANSPORT} The target answers with \`crtr push result\` (or declines with \`crtr push result --decline "<reason>" --code <token>\`), then keeps working. ${OUTPUT_SCHEMA_CONSTRAINTS}` },
         { kind: 'flag', name: 'situational-context', type: 'string', required: false, constraint: 'Non-empty hidden ambient context delivered beside the message, or alone.' },
         { kind: 'flag', name: 'reopen', type: 'bool', required: false, hidden: true, constraint: 'Clear a finalized target latch before delivery or fresh revive.' },
@@ -125,7 +125,7 @@ const nodeMessageSend = defineLeaf({
         params: messageSendParams(),
         output: messageOutput(),
         outputKind: 'object',
-        effects: ['Appends one inbox entry. Critical, urgent, and normal delivery may revive a dormant target; deferred waits for its next natural cycle.', '--reopen commits the target resident and clears any finalization latch before delivery, allowing it to take a new mandate; it is valid for live, parked, and finalized targets. Without it, a finalized target rejects delivery before an inbox entry is appended or a revive is attempted.'],
+        effects: ['Appends one inbox entry. Critical, urgent, and normal delivery queues lifecycle revival for an active or idle dormant target; deferred waits for its next natural cycle.', '--reopen commits the target resident and clears any finalization latch before delivery, allowing it to take a new mandate; it is valid for live, parked, and finalized targets. Without it, a finalized target rejects delivery before an inbox entry is appended or a revive is attempted.'],
     },
     run: (input) => runMessageEngine(input),
     render: (r) => String(r['guidance']),

package/dist/commands/sys/daemon.js

@@ -8,7 +8,7 @@
 // This subtree starts, checks, and stops the daemon process.
 import { defineLeaf, defineBranch } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
-import { isDaemonServing, spawnDaemon, stopDaemonProcess, sweepStrayDaemons } from '../../daemon/manage.js';
+import { probeDaemonServing, spawnDaemon, stopDaemonProcess, sweepStrayDaemons } from '../../daemon/manage.js';
 import { isDaemonRunning, readPidfile, isPidAlive } from '../../daemon/pidfile.js';
 import { cliClient } from '../api-client.js';
 // daemon start
@@ -26,7 +26,7 @@ const daemonStart = defineLeaf({
             { name: 'existing_pid', type: 'number', required: false, constraint: 'PID of the already-running daemon (when started=false).' },
             { name: 'running', type: 'boolean', required: false, constraint: 'True only when a live pidfile owner does not serve its Unix API socket.' },
             { name: 'serving', type: 'boolean', required: false, constraint: 'False only when a live pidfile owner does not answer /healthz.' },
-            { name: 'next', type: 'string', required: false, constraint: 'Recovery instruction when running=true and serving=false.' },
+            { name: 'probe_error', type: 'string', required: false, constraint: 'The final /healthz probe failure when a live owner missed readiness.' },
         ],
         outputKind: 'object',
         effects: [
@@ -50,9 +50,9 @@ const daemonStatus = defineLeaf({
         params: [],
         output: [
             { name: 'running', type: 'boolean', required: true, constraint: 'True when the daemon pidfile owner is alive.' },
-            { name: 'serving', type: 'boolean', required: false, constraint: 'True when the live daemon answers /healthz; false when it does not.' },
+            { name: 'serving', type: 'boolean', required: false, constraint: 'True when the live daemon answers /healthz; false when one probe does not.' },
             { name: 'pid', type: 'number', required: false, constraint: 'PID of the running daemon.' },
-            { name: 'next', type: 'string', required: false, constraint: 'Recovery instruction when running=true and serving=false.' },
+            { name: 'probe_error', type: 'string', required: false, constraint: 'The failed /healthz observation when the live owner did not answer.' },
         ],
         outputKind: 'object',
         effects: ['Read-only: reads the pidfile, probes the pid, and requests /healthz without autostart.'],
@@ -62,15 +62,13 @@ const daemonStatus = defineLeaf({
         const running = pid !== null && isPidAlive(pid);
         if (!running)
             return { running: false };
-        const serving = await isDaemonServing();
-        return serving
-            ? { running: true, serving: true, pid }
-            : {
-                running: true,
-                serving: false,
-                pid,
-                next: 'Run `crtr sys daemon stop` to release the non-serving daemon before starting it again.',
-            };
+        try {
+            await probeDaemonServing();
+            return { running: true, serving: true, pid };
+        }
+        catch (error) {
+            return { running: true, serving: false, pid, probe_error: error.message };
+        }
     },
 });
 // daemon restart

package/dist/core/__tests__/broker-stream-watchdog-floor.test.js

@@ -23,8 +23,6 @@ function projectionFor(session, generation) {
         notifyTurnAccepted: () => undefined,
         emitStartupMilestone: () => undefined,
         formatModelSpec: () => null,
-        refreshIntent: async () => false,
-        onRefreshIntentError: () => undefined,
     });
 }
 test('agent_start arms the provider watchdog before another engine event arrives', (t) => {

package/dist/core/__tests__/daemon-boot.test.js

@@ -294,7 +294,7 @@ test('verifyDaemonStartup throws after its tiny startup window expires', async (
         sleepMs: (ms) => {
             now += ms;
         },
-    }), /did not become ready within 25ms/);
+    }), /has no live pidfile owner/);
 });
 // REGRESSION (bug #102): the verifier polls with a real async sleep, NOT a
 // synchronous Atomics.wait, so the event loop stays free to dispatch the spawned

package/dist/core/__tests__/helpers/harness.d.ts

@@ -101,6 +101,8 @@ export interface Harness {
     inbox(nodeId: string): InboxEntry[];
     injected(nodeId: string): Injected[];
     fakeCmd(nodeId: string, cmd: Record<string, unknown>): void;
+    /** Stop only this harness's API server to exercise a broker daemon-read failure. */
+    stopApiServer(): Promise<void>;
     dialogResults(nodeId: string): {
         resolved: unknown;
         ms: number;

package/dist/core/__tests__/helpers/harness.js

@@ -637,6 +637,15 @@ export async function createHarness(opts = {}) {
         fakeCmd(nodeId, cmd) {
             sendCmd(nodeId, cmd);
         },
+        async stopApiServer() {
+            try {
+                apiServerProc.kill('SIGTERM');
+            }
+            catch {
+                /* already gone */
+            }
+            await waitFor(() => apiServerProc.exitCode === null ? null : true, { label: 'harness API server exit' });
+        },
         dialogResults(nodeId) {
             return readLines(join(nodeDir(nodeId), 'fake-pi.dialog.jsonl'))
                 .map((l) => {

package/dist/core/__tests__/integration/worktree-land.test.js

@@ -10,6 +10,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { gitSync } from '../../git.js';
 import { createManagedWorktree, closeManagedWorktree, managedWorktreePath, rollbackManagedWorktree } from '../../worktree.js';
+import { closeManagedWorktreeAsync } from '../../worktree-close.js';
 import { reconcileManagedWorktree } from '../../worktree-sweep.js';
 import { createNode, getNode } from '../../canvas/canvas.js';
 import { closeDb } from '../../canvas/db.js';
@@ -223,6 +224,55 @@ test('closeManagedWorktree fast-forwards local main to the worktree tip without
     const originMainAfter = gitSync(['rev-parse', 'origin/main'], sourceDir).stdout.trim();
     assert.equal(originMainAfter, originMainBefore, 'origin/main must not move — landing is local-only');
 });
+test('async close leaves an upstream-contained tip and a diverged local base byte-for-byte unchanged (#958)', async () => {
+    const repo = mkdtempSync(join(tmpdir(), 'crtr-worktree-contained-close-'));
+    const remote = mkdtempSync(join(tmpdir(), 'crtr-worktree-contained-close-remote-'));
+    try {
+        run(['init', '-b', 'main'], repo);
+        run(['config', 'user.email', 'test@example.com'], repo);
+        run(['config', 'user.name', 'Test'], repo);
+        writeFileSync(join(repo, 'README.md'), 'initial\n');
+        run(['add', '.'], repo);
+        run(['commit', '-m', 'initial'], repo);
+        run(['init', '--bare'], remote);
+        run(['remote', 'add', 'origin', remote], repo);
+        run(['push', '-u', 'origin', 'main'], repo);
+        const nodeId = 'wt-contained-diverged-base';
+        const wt = createManagedWorktree(repo, nodeId);
+        createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
+        writeFileSync(join(wt.path, 'delivered.txt'), 'already delivered\n');
+        run(['add', '.'], wt.path);
+        run(['commit', '-m', 'delivered work'], wt.path);
+        const deliveredHead = gitSync(['rev-parse', 'HEAD'], wt.path).stdout.trim();
+        run(['push', 'origin', `${wt.branch}:main`], wt.path);
+        run(['fetch', 'origin'], repo);
+        writeFileSync(join(repo, 'local-only.txt'), 'must not receive a replay\n');
+        run(['add', '.'], repo);
+        run(['commit', '-m', 'independent local base work'], repo);
+        const before = {
+            childHead: gitSync(['rev-parse', 'HEAD'], wt.path).stdout,
+            baseRef: gitSync(['rev-parse', 'refs/heads/main'], repo).stdout,
+            baseHead: gitSync(['rev-parse', 'HEAD'], repo).stdout,
+            status: gitSync(['status', '--porcelain=v1'], repo).stdout,
+            worktree: gitSync(['worktree', 'list', '--porcelain'], repo).stdout,
+            index: readFileSync(join(repo, '.git', 'index')),
+        };
+        const result = await closeManagedWorktreeAsync(nodeId);
+        assert.equal(result.landed_sha, deliveredHead);
+        assert.deepEqual({
+            childHead: gitSync(['rev-parse', 'HEAD'], wt.path).stdout,
+            baseRef: gitSync(['rev-parse', 'refs/heads/main'], repo).stdout,
+            baseHead: gitSync(['rev-parse', 'HEAD'], repo).stdout,
+            status: gitSync(['status', '--porcelain=v1'], repo).stdout,
+            worktree: gitSync(['worktree', 'list', '--porcelain'], repo).stdout,
+            index: readFileSync(join(repo, '.git', 'index')),
+        }, before, 'a delivered child must not rebase or move the divergent local base');
+    }
+    finally {
+        rmSync(repo, { recursive: true, force: true });
+        rmSync(remote, { recursive: true, force: true });
+    }
+});
 test('custom local base is recorded and fast-forwarded without touching main or origin', () => {
     const nodeId = 'wt-custom-base';
     run(['branch', 'feature/custom-base'], sourceDir);

package/dist/core/__tests__/integration/worktree-reap.test.js

@@ -4,20 +4,28 @@
 // (worktree-land.test.ts) only so the two run as two parallel files.
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, writeFileSync, chmodSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { mkdtempSync, mkdirSync, renameSync, rmSync, existsSync, writeFileSync, chmodSync, realpathSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { gitSync } from '../../git.js';
-import { createManagedWorktree, closeManagedWorktree } from '../../worktree.js';
+import { withExclusiveDirectoryLockAsync } from '../../exclusive-lock.js';
+import { createManagedWorktree, closeManagedWorktree, worktreeLockPathForCommonDir } from '../../worktree.js';
 import { reconcileManagedWorktree } from '../../worktree-sweep.js';
 import { createApiServer } from '../../../daemon/api/server.js';
+import { ManagedWorktreeSweepReconciler } from '../../../daemon/reconcilers/managed-worktree-sweep.js';
 import { apiSocketPath } from '../../canvas/paths.js';
-import { CrtrClient } from '../../../api/index.js';
+import { ApiError, CrtrClient } from '../../../api/index.js';
 import { createNode, getNode } from '../../canvas/canvas.js';
+import { headlessBrokerHost } from '../../runtime/host.js';
+import { reviveNode } from '../../runtime/revive.js';
+import { bindTestFleet } from '../helpers/fleet.js';
+import { resetFleetForTests } from '../../runtime/fleet.js';
 import { closeDb } from '../../canvas/db.js';
 let home;
 let remoteDir;
 let sourceDir;
+const scratchRoot = join(homedir(), '.crouter', 'canvas', 'scratch');
 function run(args, cwd) {
     const res = gitSync(args, cwd);
     if (res.status !== 0) {
@@ -42,7 +50,8 @@ before(() => {
     // `/var` → `/private/var` symlink, so the recorded managed-worktree path and
     // git's canonical `worktree list` output differ as strings while naming one
     // directory. Every path-ownership check must judge identity, not spelling.
-    home = mkdtempSync(join(tmpdir(), 'crtr-worktree-home-'));
+    mkdirSync(scratchRoot, { recursive: true });
+    home = mkdtempSync(join(scratchRoot, 'crtr-worktree-home-'));
     process.env['CRTR_HOME'] = home;
     // Bare "remote" wired up as origin so the test can prove landing NEVER pushes
     // to it (managed worktrees are based on and land onto local `main` only).
@@ -97,6 +106,104 @@ test('autoDropCleanManagedWorktree drops a clean, zero-commit worktree', async (
     const swept = getNode(nodeId)?.managed_worktree;
     assert.deepEqual({ state: swept?.state, cleanup: swept?.cleanup }, { state: 'closed', cleanup: 'complete' });
 });
+test('a dead managed child keeps its open checkout through the sweep and revives there (#962)', async () => {
+    const repo = mkdtempSync(join(scratchRoot, 'crtr-worktree-962-'));
+    const nodeId = 'wt-sweep-dead-open';
+    const originalLaunch = headlessBrokerHost.launch;
+    try {
+        run(['init', '-b', 'main'], repo);
+        run(['config', 'user.email', 'test@example.com'], repo);
+        run(['config', 'user.name', 'Test'], repo);
+        writeFileSync(join(repo, 'README.md'), 'hello\n');
+        run(['add', '.'], repo);
+        run(['commit', '-m', 'init'], repo);
+        const wt = createManagedWorktree(repo, nodeId);
+        createNode(node(nodeId, { cwd: wt.path, status: 'dead', managed_worktree: wt }));
+        const reconciler = new ManagedWorktreeSweepReconciler();
+        let pass;
+        reconciler.run(Date.now(), {
+            lifecycle: {
+                acceptsDetachedWork: () => true,
+                registerDetached: (work) => { pass = work; },
+            },
+            fleet: { isClaimed: () => false },
+        });
+        await pass;
+        const afterSweep = getNode(nodeId);
+        assert.equal(afterSweep.managed_worktree?.state, 'open', 'a failed launch does not authorize disposal');
+        assert.equal(afterSweep.cwd, wt.path, 'the sweep leaves the durable launch cwd unchanged');
+        assert.ok(existsSync(wt.path), 'the isolated checkout remains available for recovery');
+        const testFleet = bindTestFleet();
+        const launchCwds = [];
+        headlessBrokerHost.launch = (id, _inv, options) => {
+            launchCwds.push(options.cwd);
+            const handle = { pid: process.pid, exited: new Promise(() => { }) };
+            testFleet.fleet.register(id, handle);
+            return handle;
+        };
+        const revived = await reviveNode(nodeId, { resume: false, capacity: 'freeze' });
+        assert.equal(revived.outcome, 'launched');
+        assert.deepEqual(launchCwds, [wt.path], 'a fresh revive launches in the retained managed checkout');
+        const closedId = 'wt-sweep-closed';
+        const closedWt = createManagedWorktree(repo, closedId);
+        createNode(node(closedId, { cwd: closedWt.path, status: 'done', managed_worktree: closedWt }));
+        closeManagedWorktree(closedId);
+        const cleanup = await reconcileManagedWorktree(closedId, { stillEligible: () => true });
+        assert.equal(cleanup.status, 'complete', 'a successful close is still physically cleaned after its engine exits');
+        assert.equal(getNode(closedId)?.cwd, repo, 'a successful close deliberately repoints future launch cwd to the repository root');
+        launchCwds.length = 0;
+        const closedRevive = await reviveNode(closedId, { resume: false, capacity: 'freeze' });
+        assert.equal(closedRevive.outcome, 'launched');
+        assert.deepEqual(launchCwds, [repo], 'a closed node still revives against the repository root');
+    }
+    finally {
+        headlessBrokerHost.launch = originalLaunch;
+        resetFleetForTests();
+        rmSync(repo, { recursive: true, force: true });
+    }
+});
+test('the sweep does not conclude a missing record while its branch survives in a moved repository', async () => {
+    const repo = mkdtempSync(join(scratchRoot, 'crtr-worktree-moved-root-'));
+    const movedRepo = join(scratchRoot, `crtr-worktree-moved-root-destination-${Date.now()}`);
+    const nodeId = 'wt-sweep-moved-root';
+    try {
+        run(['init', '-b', 'main'], repo);
+        run(['config', 'user.email', 'test@example.com'], repo);
+        run(['config', 'user.name', 'Test'], repo);
+        writeFileSync(join(repo, 'README.md'), 'hello\n');
+        run(['add', '.'], repo);
+        run(['commit', '-m', 'init'], repo);
+        const wt = createManagedWorktree(repo, nodeId);
+        createNode(node(nodeId, { cwd: wt.path, status: 'done', managed_worktree: wt }));
+        run(['worktree', 'remove', wt.path], repo);
+        renameSync(repo, movedRepo);
+        const outcome = await reconcileManagedWorktree(nodeId, { stillEligible: () => true });
+        assert.deepEqual(outcome.status === 'refused' ? outcome.reason : undefined, 'repo_unavailable');
+        assert.equal(getNode(nodeId)?.managed_worktree?.state, 'open', 'a missing recorded path cannot prove the worktree branch is gone');
+        assert.equal(gitSync(['show-ref', '--verify', '--quiet', `refs/heads/${wt.branch}`], movedRepo).status, 0, 'the moved repository still holds the managed branch');
+    }
+    finally {
+        rmSync(repo, { recursive: true, force: true });
+        rmSync(movedRepo, { recursive: true, force: true });
+    }
+});
+test('the sweep retries containment when the base upstream advances', async () => {
+    const nodeId = 'wt-sweep-upstream-advance';
+    const wt = createManagedWorktree(sourceDir, nodeId);
+    createNode(node(nodeId, { cwd: wt.path, status: 'done', managed_worktree: wt }));
+    writeFileSync(join(wt.path, 'delivered.txt'), 'delivered remotely\n');
+    run(['add', 'delivered.txt'], wt.path);
+    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'delivered work'], wt.path);
+    const refused = await reconcileManagedWorktree(nodeId, { stillEligible: () => true });
+    assert.equal(refused.status, 'refused');
+    const before = getNode(nodeId)?.managed_worktree?.sweep?.observed;
+    assert.ok(before, 'the initial refusal records the observation that caused backoff');
+    run(['push', 'origin', `${wt.branch}:main`], wt.path);
+    run(['fetch', 'origin'], sourceDir);
+    const completed = await reconcileManagedWorktree(nodeId, { stillEligible: () => true });
+    assert.equal(completed.status, 'complete', 'a newly contained branch is re-proved instead of remaining in backoff');
+    assert.equal(existsSync(wt.path), false, 'the newly contained checkout is removed');
+});
 test('the sweep refuses a managed checkout with uncommitted changes', async () => {
     const nodeId = 'wt-sweep-dirty';
     const wt = createManagedWorktree(sourceDir, nodeId);
@@ -297,6 +404,78 @@ test('autoDropCleanManagedWorktree refuses a worktree with real uncommitted chan
     assert.equal(result, null, 'real uncommitted changes must never be silently dropped');
     assert.equal(getNode(nodeId)?.managed_worktree?.state, 'open');
 });
+test('async close returns the typed lock refusal before the client socket timeout (#1024)', async () => {
+    const nodeId = 'wt-async-close-busy';
+    const wt = createManagedWorktree(sourceDir, nodeId);
+    createNode(node(nodeId, { cwd: wt.path, managed_worktree: wt }));
+    const commonDir = realpathSync(join(sourceDir, gitSync(['rev-parse', '--git-common-dir'], sourceDir).stdout.trim()));
+    const lockModule = new URL('../../exclusive-lock.ts', import.meta.url).href;
+    const child = spawn(process.execPath, ['--import', 'tsx/esm', '--input-type=module', '--eval', `
+    const { withExclusiveDirectoryLockAsync } = await import(${JSON.stringify(lockModule)});
+    await withExclusiveDirectoryLockAsync(${JSON.stringify(worktreeLockPathForCommonDir(commonDir))}, async () => {
+      console.log('locked');
+      await new Promise((resolve) => setTimeout(resolve, 40_000));
+    });
+  `], { env: { ...process.env, CRTR_HOME: home }, stdio: ['ignore', 'pipe', 'pipe'] });
+    try {
+        await new Promise((resolve, reject) => {
+            let output = '';
+            child.stdout.on('data', (chunk) => { output += chunk; if (output.includes('locked'))
+                resolve(); });
+            child.once('error', reject);
+            child.once('exit', (code) => reject(new Error(`lock holder exited before acquiring the lock (${code})`)));
+        });
+        const server = createApiServer();
+        try {
+            await new Promise((resolve) => setTimeout(resolve, 25));
+            const client = new CrtrClient({ socketPath: apiSocketPath(), autostart: false });
+            const started = Date.now();
+            await assert.rejects(client.closeWorktree(nodeId), (error) => error instanceof ApiError && error.code === 'worktree_lock_timeout');
+            assert.ok(Date.now() - started < 30_000, 'the daemon must serialize the typed busy refusal before the 30s client timeout');
+        }
+        finally {
+            await server.close();
+        }
+    }
+    finally {
+        child.kill('SIGTERM');
+    }
+});
+test('async close yields while an async repository holder runs, keeping API requests responsive (#1024)', async () => {
+    const zeroId = 'wt-async-close-zero';
+    const committedId = 'wt-async-close-committed';
+    const zero = createManagedWorktree(sourceDir, zeroId);
+    const committed = createManagedWorktree(sourceDir, committedId);
+    createNode(node(zeroId, { cwd: zero.path, managed_worktree: zero }));
+    createNode(node(committedId, { cwd: committed.path, managed_worktree: committed }));
+    writeFileSync(join(committed.path, 'committed.txt'), 'work\n');
+    run(['add', 'committed.txt'], committed.path);
+    run(['-c', 'user.email=test@example.com', '-c', 'user.name=Test', 'commit', '-m', 'work'], committed.path);
+    const commonDir = realpathSync(join(sourceDir, gitSync(['rev-parse', '--git-common-dir'], sourceDir).stdout.trim()));
+    let release;
+    const held = new Promise((resolve) => { release = resolve; });
+    const holder = withExclusiveDirectoryLockAsync(worktreeLockPathForCommonDir(commonDir), async () => { await held; });
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    const server = createApiServer();
+    try {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+        const client = new CrtrClient({ socketPath: apiSocketPath(), autostart: false });
+        const zeroClose = client.closeWorktree(zeroId);
+        const committedClose = client.closeWorktree(committedId);
+        const responsive = await Promise.race([client.listNodes().then(() => true), new Promise((resolve) => setTimeout(() => resolve(false), 250))]);
+        assert.equal(responsive, true, 'a waiting close must not block another daemon request');
+        release();
+        await holder;
+        const [zeroResult, committedResult] = await Promise.all([zeroClose, committedClose]);
+        assert.equal(zeroResult.landed_sha, zero.base_sha, 'the zero-commit close returns its actual result after the holder releases');
+        assert.equal(committedResult.landed_sha, gitSync(['rev-parse', 'HEAD'], committed.path).stdout.trim(), 'the committed close returns its actual landed result after the holder releases');
+    }
+    finally {
+        release();
+        await holder;
+        await server.close();
+    }
+});
 test('abandon preserves committed and dirty work, records its retained tip, and releases finalization', async () => {
     const nodeId = 'wt-abandon';
     const wt = createManagedWorktree(sourceDir, nodeId);

package/dist/core/__tests__/parse-argv-stdin-secret.test.js

@@ -23,6 +23,9 @@ const PROFILE_SET_SHAPED_PARAMS = [
     { kind: 'flag', name: 'name', type: 'string', required: true, constraint: 'var name' },
     { kind: 'stdin', name: 'value', required: true, constraint: 'value piped on stdin' },
 ];
+const STRING_FLAG_PARAMS = [
+    { kind: 'flag', name: 'arg', type: 'string', required: true, constraint: 'argument' },
+];
 test('a lone positional supplies the stdin body on a leaf declaring no positional param', async () => {
     const result = await parseArgv(YIELD_SHAPED_PARAMS, ['refresh against the original goal']);
     assert.equal(result['message'], 'refresh against the original goal');
@@ -42,6 +45,17 @@ test('allowPositional:false keeps a stdin-only leaf rejecting positionals by ari
         return true;
     });
 });
+test('a value bound with = may start with --', async () => {
+    const result = await parseArgv(STRING_FLAG_PARAMS, ['--arg=--help']);
+    assert.equal(result['arg'], '--help');
+});
+test('a separate flag value starting with -- is rejected as missing', async () => {
+    await assert.rejects(() => parseArgv(STRING_FLAG_PARAMS, ['--arg', '--help']), (err) => {
+        assert.equal(err.code, 'missing_parameter');
+        assert.equal(err.message, '--arg requires a value');
+        return true;
+    });
+});
 test('an extra positional on a stdin-bearing leaf is rejected without echoing it', async () => {
     const secret = 'SUPERSECRET_ARGV';
     await assert.rejects(() => parseArgv(PROFILE_SET_SHAPED_PARAMS, ['some-profile', secret, '--name', 'REVIEW_TOKEN']), (err) => {

package/dist/core/__tests__/seam/broker-attach-stream.test.js

@@ -161,3 +161,16 @@ test('G3 — a deliver whose prompt rejects acks ok:false and records deliver_fa
     assert.equal(okAck.type === 'ack' && okAck.ok, true, 'G3: an accepted prompt acks delivered:true');
     assert.equal(okAck.type === 'ack' ? okAck.detail : undefined, 'prompt');
 });
+// A message_end is only a broker/viewer relay. It must not depend on a daemon
+// read: a daemon outage after boot leaves tool results and the run settlement intact.
+test('G4 — a daemon read failure after boot does not interrupt a tool result or its settlement', async () => {
+    const c = await ctrl('g4-ctrl');
+    const pid = brokerPid();
+    await h.stopApiServer();
+    const token = tok('G4-TOOL-RESULT');
+    h.fakeCmd(id, { cmd: 'stream', text: token, updates: 0 });
+    await c.waitFrame((f) => f.type === 'tool_execution_end', 'G4 tool result relayed after the daemon server exits');
+    await c.waitFrame((f) => f.type === 'agent_settled', 'G4 run settles after the daemon server exits');
+    await delay(200);
+    assert.equal(isPidAlive(pid), true, 'G4: broker remains alive after relaying and settling the tool result');
+});

package/dist/core/__tests__/seam/broker-startup-diagnostics.test.d.ts

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