@north-light/crouter 0.3.309 → 0.3.311

package/dist/core/canvas/remote-canvas-source.js

@@ -76,6 +76,13 @@ function isValidNeighborEntry(x) {
  *  lifecycle fields local/API-backed row renderers dereference unguarded;
  *  the remaining nullable runtime
  *  fields (host_kind, parent, pi_pid, ...) are left to cast through as-is. */
+function isValidRosterEdge(x) {
+    return (isPlainObject(x) &&
+        typeof x['from_id'] === 'string' &&
+        typeof x['to_id'] === 'string' &&
+        typeof x['active'] === 'boolean' &&
+        typeof x['created'] === 'string');
+}
 function isValidNodeRow(x) {
     if (!isPlainObject(x))
         return false;
@@ -94,6 +101,7 @@ export class RemoteCanvasSource {
     exec;
     nodeCache = new Map();
     rosterCache = new Map();
+    topologyCache = null;
     viewCache = new Map();
     constructor(previewEndpoint, relayToken) {
         this.previewEndpoint = previewEndpoint;
@@ -134,6 +142,46 @@ export class RemoteCanvasSource {
         this.nodeCache.set(id, { value: res, at: Date.now() });
         return res;
     }
+    topology() {
+        if (this.topologyCache !== null && Date.now() - this.topologyCache.at < CACHE_TTL_MS)
+            return this.topologyCache.value;
+        const request = this.loadTopology();
+        this.topologyCache = { value: request, at: Date.now() };
+        return request;
+    }
+    async loadTopology() {
+        const response = await this.exec('crtr', ['--json', 'canvas', 'roster']);
+        if (!response.ok || (response.exitCode !== undefined && response.exitCode !== 0)) {
+            throw new Error('remote canvas topology is unavailable');
+        }
+        let raw;
+        try {
+            raw = JSON.parse(response.stdout.trim());
+        }
+        catch {
+            throw new Error('remote canvas topology is invalid');
+        }
+        if (!isPlainObject(raw) || !Array.isArray(raw['edges']) || !raw['edges'].every(isValidRosterEdge)) {
+            throw new Error('remote canvas topology is invalid');
+        }
+        const edges = raw['edges'];
+        const topology = { subscriptions: new Map(), subscribers: new Map() };
+        for (const edge of edges) {
+            const subscription = { node_id: edge.to_id, active: edge.active, created: edge.created };
+            const subscriber = { node_id: edge.from_id, active: edge.active, created: edge.created };
+            const subscriptions = topology.subscriptions.get(edge.from_id);
+            if (subscriptions === undefined)
+                topology.subscriptions.set(edge.from_id, [subscription]);
+            else
+                subscriptions.push(subscription);
+            const subscribers = topology.subscribers.get(edge.to_id);
+            if (subscribers === undefined)
+                topology.subscribers.set(edge.to_id, [subscriber]);
+            else
+                subscribers.push(subscriber);
+        }
+        return topology;
+    }
     /** The full passthrough object `node inspect show` produces — used by
      *  `nodeShow`'s remote branch (`src/commands/node/inspect.ts`) to return the exact
      *  same shape a local read would, without re-deriving it. */
@@ -186,12 +234,10 @@ export class RemoteCanvasSource {
         return nodes;
     }
     async subscriptionsOf(id) {
-        const reports = (await this.fetchShow(id))?.reports ?? [];
-        return reports.map((r) => ({ node_id: r.node_id, active: r.active, created: '' }));
+        return (await this.topology()).subscriptions.get(id) ?? [];
     }
     async subscribersOf(id) {
-        const managers = (await this.fetchShow(id))?.managers ?? [];
-        return managers.map((r) => ({ node_id: r.node_id, active: r.active, created: '' }));
+        return (await this.topology()).subscribers.get(id) ?? [];
     }
     async view(root) {
         const cached = this.viewCache.get(root);
@@ -214,9 +260,15 @@ export class RemoteCanvasSource {
         this.viewCache.set(root, { value: out, at: Date.now() });
         return out;
     }
+    async ticketCountsForNodes(nodeIds) {
+        // The `canvas attention map` transport's `counts` values mean all pending
+        // human tickets (page/review), not just asks.
+        if (nodeIds.length === 0)
+            return {};
+        const res = await this.execJson(['canvas', 'attention', 'map', '--nodes', nodeIds.join(',')]);
+        return isPlainObject(res) && isPlainObject(res['counts']) ? res['counts'] : {};
+    }
     async ticketCountsForView(root) {
-        // The `canvas attention map` transport is unchanged; its `counts` values now
-        // mean all pending human tickets (page/review), not just asks.
         const res = await this.execJson(['canvas', 'attention', 'map', '--view', root]);
         return isPlainObject(res) && isPlainObject(res['counts']) ? res['counts'] : {};
     }

package/dist/core/canvas/render-source.d.ts

@@ -13,8 +13,8 @@ export interface NodeTelemetry {
 export declare function readNodeTelemetry(nodeId: string): NodeTelemetry;
 /** Format a token count as `Nk` (rounded down to nearest 1 k). */
 export declare function fmtCtx(tokensIn: number | undefined): string;
-export declare function renderTreeFromSource(source: CanvasSource, rootId: string): Promise<string>;
-export declare function renderForestFromSource(source: CanvasSource): Promise<string>;
+export declare function renderTreeFromSource(source: CanvasSource, rootId: string, snapshot?: readonly NodeRow[], ticketSnapshot?: Record<string, number>, ticketUnavailable?: string): Promise<string>;
+export declare function renderForestFromSource(source: CanvasSource, snapshot?: readonly NodeRow[], ticketSnapshot?: Record<string, number>, ticketUnavailable?: string): Promise<string>;
 export interface DashboardRow {
     node_id: string;
     /** Full display label: explicit handle plus generated description. */
@@ -183,13 +183,13 @@ export declare function dashboardRowFromNodeRow(row: NodeRow, focusedNodeIds: Re
  *  entirely through the source — the openDb-free sibling of `dashboardRows`.
  *  Ticket counts come from ONE `source.ticketCountsForView(rootId)` call (the
  *  API/remote attention projection), never `countTickets` (openDb). */
-export declare function dashboardRowsFromSource(source: CanvasSource, rootId: string): Promise<DashboardRow[]>;
+export declare function dashboardRowsFromSource(source: CanvasSource, rootId: string, snapshot?: readonly NodeRow[], ticketSnapshot?: Record<string, number>): Promise<DashboardRow[]>;
 /** CHEAP boot builder over a source — one row per node across the whole canvas,
  *  fields that need no per-node meta/session read. Local API callers may supply
  *  the node ids from one `listFocuses()` query so `viewed` remains visible without
  *  coupling the canvas source to local viewer state. Remote sources ignore that
  *  set. Local disk telemetry/fault/streaming are likewise suppressed remotely. */
-export declare function dashboardRowsAllFromSource(source: CanvasSource, localFocusedNodeIds?: ReadonlySet<string>, liveOnly?: boolean): Promise<DashboardRow[]>;
+export declare function dashboardRowsAllFromSource(source: CanvasSource, localFocusedNodeIds?: ReadonlySet<string>, liveOnly?: boolean, snapshot?: readonly NodeRow[]): Promise<DashboardRow[]>;
 export declare function enrichRowsFromSource(_source: CanvasSource, rows: DashboardRow[], asks?: Record<string, number>): Promise<void>;
 /** goal (initial-prompt.md) and session parts are local disk reads — suppressed
  *  to undefined for a remote source. */

package/dist/core/canvas/render-source.js

@@ -60,9 +60,8 @@ export function fmtCtx(tokensIn) {
 // LOCAL disk reads (telemetry.json / fault.json), valid for a same-host source
 // but meaningless for a truly remote canvas, so both are suppressed when the
 // source is a `RemoteCanvasSource`.
-async function nodeLineFromSource(source, nodeId, indent, connector, remote, tickets) {
-    const node = await source.getNode(nodeId);
-    if (node === null)
+function nodeLineFromSource(node, nodeId, indent, connector, remote, tickets) {
+    if (node === undefined)
         return `${indent}${connector}? <missing meta: ${nodeId}>`;
     const hanging = remote ? null : hangingFor(node);
     const glyph = resolveNodeVisual(node.status, { hanging, frozen: isFrozenRow(node) }).glyph;
@@ -72,12 +71,12 @@ async function nodeLineFromSource(source, nodeId, indent, connector, remote, tic
     const faultSuffix = hanging !== null ? ` · ${faultSummary(hanging)}` : '';
     return `${indent}${connector}${glyph} ${fullName(node)} [${node.kind}/${node.mode}] ctx ${ctx}${askSuffix}${faultSuffix}`;
 }
-async function walkTreeFromSource(source, nodeId, indent, isLast, visited, out, remote, tickets) {
+async function walkTreeFromSource(source, nodes, nodeId, indent, isLast, visited, out, remote, tickets) {
     if (visited.has(nodeId))
         return;
     visited.add(nodeId);
     const connector = isLast ? '└─ ' : '├─ ';
-    out.push(await nodeLineFromSource(source, nodeId, indent, connector, remote, tickets));
+    out.push(nodeLineFromSource(nodes.get(nodeId), nodeId, indent, connector, remote, tickets));
     const childIndent = indent + (isLast ? '   ' : '│  ');
     let children;
     try {
@@ -95,22 +94,25 @@ async function walkTreeFromSource(source, nodeId, indent, isLast, visited, out,
             out.push(`${childIndent}${cycleConnector}↺ <cycle: ${child.node_id}>`);
             continue;
         }
-        await walkTreeFromSource(source, child.node_id, childIndent, childIsLast, visited, out, remote, tickets);
+        await walkTreeFromSource(source, nodes, child.node_id, childIndent, childIsLast, visited, out, remote, tickets);
     }
 }
-export async function renderTreeFromSource(source, rootId) {
+export async function renderTreeFromSource(source, rootId, snapshot, ticketSnapshot, ticketUnavailable) {
     const remote = source instanceof RemoteCanvasSource;
-    const node = await source.getNode(rootId);
-    if (node === null)
+    const nodes = new Map((snapshot ?? await source.listNodes()).map((node) => [node.node_id, node]));
+    const node = nodes.get(rootId);
+    if (node === undefined)
         return `? <missing node: ${rootId}>`;
-    let tickets;
-    let ticketsUnavailable = null;
-    try {
-        tickets = await source.ticketCountsForView(rootId);
-    }
-    catch (err) {
-        tickets = {};
-        ticketsUnavailable = err instanceof Error ? err.message : String(err);
+    let tickets = ticketSnapshot;
+    let ticketsUnavailable = ticketUnavailable ?? null;
+    if (tickets === undefined) {
+        try {
+            tickets = await source.ticketCountsForView(rootId);
+        }
+        catch (err) {
+            tickets = {};
+            ticketsUnavailable = err instanceof Error ? err.message : String(err);
+        }
     }
     const ctx = remote ? '0k' : fmtCtx(readNodeTelemetry(rootId).tokens_in);
     const asks = tickets[rootId] ?? 0;
@@ -132,14 +134,14 @@ export async function renderTreeFromSource(source, rootId) {
     for (let i = 0; i < children.length; i++) {
         const child = children[i];
         const isLast = i === children.length - 1;
-        await walkTreeFromSource(source, child.node_id, '', isLast, visited, out, remote, tickets);
+        await walkTreeFromSource(source, nodes, child.node_id, '', isLast, visited, out, remote, tickets);
     }
     if (ticketsUnavailable !== null)
         out.push(`Tickets: unavailable (${ticketsUnavailable}).`);
     return out.join('\n');
 }
-export async function renderForestFromSource(source) {
-    const all = await source.listNodes();
+export async function renderForestFromSource(source, snapshot, ticketSnapshot, ticketUnavailable) {
+    const all = snapshot ?? await source.listNodes();
     if (all.length === 0)
         return '(canvas is empty)';
     const roots = all.filter((n) => n.parent === null && (n.status === 'active' || n.status === 'idle'));
@@ -147,7 +149,7 @@ export async function renderForestFromSource(source) {
         return '(no live roots)';
     const parts = [];
     for (const r of roots) {
-        parts.push(await renderTreeFromSource(source, r.node_id));
+        parts.push(await renderTreeFromSource(source, r.node_id, all, ticketSnapshot, ticketUnavailable));
     }
     return parts.join('\n\n');
 }
@@ -563,44 +565,43 @@ export function dashboardRowFromNodeRow(row, focusedNodeIds, remote) {
  *  entirely through the source — the openDb-free sibling of `dashboardRows`.
  *  Ticket counts come from ONE `source.ticketCountsForView(rootId)` call (the
  *  API/remote attention projection), never `countTickets` (openDb). */
-export async function dashboardRowsFromSource(source, rootId) {
+export async function dashboardRowsFromSource(source, rootId, snapshot, ticketSnapshot) {
     const remote = source instanceof RemoteCanvasSource;
-    const tickets = await source.ticketCountsForView(rootId).catch(() => ({}));
+    const tickets = ticketSnapshot ?? await source.ticketCountsForView(rootId).catch(() => ({}));
+    const nodes = new Map((snapshot ?? await source.listNodes()).map((node) => [node.node_id, node]));
     const ids = [rootId, ...(await source.view(rootId))];
-    const rows = [];
-    for (const id of ids) {
-        const node = await source.getNode(id);
-        if (node === null)
-            continue;
+    return ids.flatMap((id) => {
+        const node = nodes.get(id);
+        if (node === undefined)
+            return [];
         const tel = remote ? {} : readNodeTelemetry(id);
-        rows.push({
-            node_id: id,
-            name: fullName(node),
-            handle: node.name,
-            description: node.description,
-            status: node.status,
-            frozen_at: node.frozen_at ?? null,
-            terminal_reason: node.terminal_reason ?? null,
-            kind: node.kind,
-            mode: node.mode,
-            ctx_tokens: tel.tokens_in ?? 0,
-            asks: tickets[id] ?? 0,
-            cwd: node.cwd,
-            profile_id: node.profile_id,
-            created: node.created,
-        });
-    }
-    return rows;
+        return [{
+                node_id: id,
+                name: fullName(node),
+                handle: node.name,
+                description: node.description,
+                status: node.status,
+                frozen_at: node.frozen_at ?? null,
+                terminal_reason: node.terminal_reason ?? null,
+                kind: node.kind,
+                mode: node.mode,
+                ctx_tokens: tel.tokens_in ?? 0,
+                asks: tickets[id] ?? 0,
+                cwd: node.cwd,
+                profile_id: node.profile_id,
+                created: node.created,
+            }];
+    });
 }
 /** CHEAP boot builder over a source — one row per node across the whole canvas,
  *  fields that need no per-node meta/session read. Local API callers may supply
  *  the node ids from one `listFocuses()` query so `viewed` remains visible without
  *  coupling the canvas source to local viewer state. Remote sources ignore that
  *  set. Local disk telemetry/fault/streaming are likewise suppressed remotely. */
-export async function dashboardRowsAllFromSource(source, localFocusedNodeIds = new Set(), liveOnly = false) {
+export async function dashboardRowsAllFromSource(source, localFocusedNodeIds = new Set(), liveOnly = false, snapshot) {
     const remote = source instanceof RemoteCanvasSource;
     const focusedNodeIds = remote ? new Set() : localFocusedNodeIds;
-    const rows = await source.listNodes(liveOnly ? { status: ['active', 'idle'] } : undefined);
+    const rows = snapshot ?? await source.listNodes(liveOnly ? { status: ['active', 'idle'] } : undefined);
     return rows.map((row) => dashboardRowFromNodeRow(row, focusedNodeIds, remote));
 }
 // Lazy enrichment (source-driven) — fold the per-node reads the cheap boot skips

package/dist/core/canvas/source.d.ts

@@ -9,6 +9,7 @@ export interface CanvasSource {
     subscriptionsOf(subscriber: string): Promise<SubscriptionRef[]>;
     subscribersOf(publisher: string): Promise<SubscriptionRef[]>;
     view(root: string): Promise<string[]>;
+    ticketCountsForNodes(nodeIds: readonly string[]): Promise<Record<string, number>>;
     ticketCountsForView(root: string): Promise<Record<string, number>>;
     hasActiveLiveSubscription(nodeId: string): Promise<boolean>;
 }
@@ -21,6 +22,7 @@ export declare class LocalCanvasSource implements CanvasSource {
     subscriptionsOf(subscriber: string): Promise<SubscriptionRef[]>;
     subscribersOf(publisher: string): Promise<SubscriptionRef[]>;
     view(root: string): Promise<string[]>;
+    ticketCountsForNodes(nodeIds: readonly string[]): Promise<Record<string, number>>;
     ticketCountsForView(root: string): Promise<Record<string, number>>;
     hasActiveLiveSubscription(nodeId: string): Promise<boolean>;
 }

package/dist/core/canvas/source.js

@@ -22,8 +22,11 @@ export class LocalCanvasSource {
     async view(root) {
         return view(root);
     }
+    async ticketCountsForNodes(nodeIds) {
+        return ticketCountsForNodes([...nodeIds]);
+    }
     async ticketCountsForView(root) {
-        return ticketCountsForNodes([root, ...view(root)]);
+        return this.ticketCountsForNodes([root, ...view(root)]);
     }
     async hasActiveLiveSubscription(nodeId) {
         return hasActiveLiveSubscription(nodeId);

package/dist/core/worktree-mutation-async.js

@@ -247,9 +247,8 @@ export async function abandonManagedWorktreeAsync(nodeId, by) {
                 cleanBase = base;
         }
         catch (error) {
-            if (!(error instanceof WorktreeError) || error.code !== 'missing_base_branch' || head !== current.base_sha)
+            if (!(error instanceof WorktreeError) || error.code !== 'missing_base_branch')
                 throw error;
-            cleanBase = current.base_sha;
         }
         const at = new Date().toISOString();
         const status = await runGit(current.path, ['status', '--porcelain'], 'status_failed', 'Inspect the worktree manually, then retry.');

package/dist/core/worktree.d.ts

@@ -76,7 +76,6 @@ export interface AbandonManagedWorktreeResult {
     worktree_path: string;
     branch_deleted: boolean;
 }
-export declare function abandonManagedWorktree(nodeId: string, by: string): AbandonManagedWorktreeResult;
 /** Recovery guidance for a vanished checkout whose refs do not prove that its
  * work is delivered. This deliberately never recommends `worktree close`:
  * that command cannot operate on the absent checkout. */

package/dist/core/worktree.js

@@ -3,7 +3,6 @@ import { createHash } from 'node:crypto';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { gitAsync, gitSync } from './git.js';
 import { crtrHome } from './canvas/paths.js';
-import { isPidAlive } from './canvas/pid.js';
 import { getNode, updateNode } from './canvas/index.js';
 import { CONFIG_FILE, CRTR_DIR_NAME, STATE_FILE } from '../types.js';
 import { withExclusiveDirectoryLock } from './exclusive-lock.js';
@@ -658,118 +657,6 @@ export function closeManagedWorktree(nodeId) {
     // the child checkout instead of the parent that created it.
     return withRepositoryWorktreeLock(existsSync(wt.path) ? wt.path : wt.repo_root, () => closeManagedWorktreeLocked(nodeId));
 }
-const ABANDON_AUTHOR_NAME = 'crtr-abandon';
-const ABANDON_AUTHOR_EMAIL = 'crtr-abandon@localhost';
-const ABANDON_SUBJECT = 'crtr-abandon';
-function persistAbandonedWorktreeState(nodeId, wt, tipSha, at, by, branch = wt.branch) {
-    updateNode(nodeId, {
-        cwd: wt.repo_root,
-        managed_worktree: {
-            ...wt,
-            state: 'abandoned',
-            abandoned: { branch, tip_sha: tipSha, at, by },
-        },
-    });
-}
-/** The disposal path for `abandon` when the recorded `crtr/*` branch is gone:
- *  ordinary PR work moved this checkout onto a real branch. Abandon never
- *  lands that branch and — unlike the ordinary path above — never invents a
- *  commit on it: a synthetic `crtr-abandon` marker on someone's real PR
- *  branch is not a trade this code may make on their behalf. So this
- *  requires the checkout already clean and not mid-operation, then removes
- *  only the checkout and preserves the actual branch and its commits exactly
- *  as they stand. The caller already confirmed the node is not running. */
-function abandonBranchMovedWorktree(nodeId, wt, actualBranch, by) {
-    if (isRebaseInProgress(wt.path)) {
-        throw new WorktreeError('rebase_in_progress', 'this managed worktree is mid-rebase', `Resolve conflicts in ${wt.path}, run \`git rebase --continue\` there, then rerun \`crtr node worktree abandon\`.`);
-    }
-    const dirty = statusPorcelain(wt.path);
-    if (dirty !== '') {
-        throw new WorktreeError('dirty_worktree', 'managed worktree has uncommitted changes', `The recorded branch ${wt.branch} no longer exists; its checkout is now on ${actualBranch} with uncommitted changes crtr will not commit on your behalf. Commit or stash them in ${wt.path}, then rerun \`crtr node worktree abandon\`.`);
-    }
-    if (registeredWorktree(wt.repo_root, wt.path, actualBranch) !== true) {
-        throw new WorktreeError('wrong_branch', `managed worktree's recorded branch ${wt.branch} no longer exists, and its checkout at ${wt.path} is not registered to ${actualBranch} either`, `Inspect ${wt.path} and its git worktree registration, then ask the user with \`crtr human send\` if you are unsure how to proceed.`);
-    }
-    const actualSha = runGit(wt.path, ['rev-parse', 'HEAD'], 'abandon_tip_failed', 'Inspect the worktree manually, then retry.');
-    // Recheck identity immediately before the destructive step.
-    if (registeredWorktree(wt.repo_root, wt.path, actualBranch) !== true || currentBranch(wt.path) !== actualBranch) {
-        throw new WorktreeError('wrong_branch', `managed worktree at ${wt.path} changed while abandoning`, `Inspect ${wt.path}, then rerun \`crtr node worktree abandon\`.`);
-    }
-    runGit(wt.repo_root, ['worktree', 'remove', wt.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-    const at = new Date().toISOString();
-    persistAbandonedWorktreeState(nodeId, wt, actualSha, at, by, actualBranch);
-    return { node_id: nodeId, branch: actualBranch, tip_sha: actualSha, worktree_path: wt.path, branch_deleted: false };
-}
-function createAbandonMarker(wt, parentSha, nodeId, at) {
-    const treeSha = runGit(wt.repo_root, ['rev-parse', `${parentSha}^{tree}`], 'abandon_tree_failed', 'Inspect the branch manually, then retry.');
-    const markerSha = runGit(wt.repo_root, ['-c', `user.name=${ABANDON_AUTHOR_NAME}`, '-c', `user.email=${ABANDON_AUTHOR_EMAIL}`, 'commit-tree', treeSha, '-p', parentSha, '-m', ABANDON_SUBJECT, '-m', `Crtr-Abandon: ${nodeId} ${at}`], 'abandon_commit_failed', 'Inspect the branch manually, then retry.');
-    runGit(wt.repo_root, ['update-ref', `refs/heads/${wt.branch}`, markerSha, parentSha], 'abandon_marker_failed', 'The branch changed while abandon was starting; inspect the worktree, then retry.');
-    return markerSha;
-}
-function abandonManagedWorktreeLocked(nodeId, by) {
-    const node = getNode(nodeId);
-    if (node === null) {
-        throw new WorktreeError('unknown_node', `unknown node: ${nodeId}`, 'Pass a real node id.');
-    }
-    const wt = openManagedWorktreeForNode(nodeId);
-    if (wt === null) {
-        const { message, next } = noManagedWorktreeMessage(nodeId, 'abandon');
-        throw new WorktreeError('no_managed_worktree', message, next);
-    }
-    if (node.status === 'active' || node.status === 'idle' || isPidAlive(node.pi_pid)) {
-        throw new WorktreeError('node_running', `node ${nodeId} is still running`, 'Stop the node before abandoning its managed worktree.');
-    }
-    if (!existsSync(wt.path)) {
-        throw new WorktreeError('worktree_missing', `managed worktree path is missing: ${wt.path}`, missingWorktreeRecoveryHint(wt));
-    }
-    const actualBranch = currentBranch(wt.path);
-    if (actualBranch !== wt.branch) {
-        const recordedRefExists = recordedBranchExists(wt.path, wt.branch);
-        if (recordedRefExists || actualBranch === 'HEAD') {
-            throw new WorktreeError('wrong_branch', `managed worktree is not on its recorded branch (expected ${wt.branch}${actualBranch === 'HEAD' ? ', found detached HEAD' : ''})`, recordedRefExists
-                ? `Check out ${wt.branch} in ${wt.path}, then rerun \`crtr node worktree abandon\`.`
-                : `The recorded branch ${wt.branch} no longer exists, and ${wt.path} is in detached HEAD, so there is no branch to preserve. Check out or create a branch there, then rerun \`crtr node worktree abandon\`.`);
-        }
-        // The recorded crtr/* branch is gone: ordinary PR work moved this checkout
-        // onto a real branch.
-        return abandonBranchMovedWorktree(nodeId, wt, actualBranch, by);
-    }
-    const at = new Date().toISOString();
-    const clean = proveCleanEmptyManagedWorktree(wt);
-    if (clean !== null && clean.branchSha === wt.base_sha) {
-        const markerSha = createAbandonMarker(wt, clean.branchSha, nodeId, at);
-        runGit(wt.repo_root, ['worktree', 'remove', wt.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-        const deleted = bestEffortDeleteBranchWithContainmentProof(wt, markerSha, `refs/heads/${wt.base_ref}`, clean.baseSha);
-        if (deleted.branchDeleted) {
-            persistClosedWorktreeState(nodeId, wt, 'complete');
-            return { node_id: nodeId, branch: wt.branch, tip_sha: markerSha, worktree_path: wt.path, branch_deleted: true };
-        }
-        const tipSha = runGit(wt.repo_root, ['rev-parse', `refs/heads/${wt.branch}`], 'abandon_tip_failed', 'Inspect the branch manually, then retry.');
-        persistAbandonedWorktreeState(nodeId, wt, tipSha, at, by);
-        return { node_id: nodeId, branch: wt.branch, tip_sha: tipSha, worktree_path: wt.path, branch_deleted: false };
-    }
-    // A clean branch with committed work already has its complete history. The
-    // abandon record supplies the disposition; an empty provenance commit would
-    // only move the local branch away from an already-pushed tip.
-    if (!isRebaseInProgress(wt.path) && statusPorcelain(wt.path) === '') {
-        runGit(wt.repo_root, ['worktree', 'remove', wt.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-        const tipSha = runGit(wt.repo_root, ['rev-parse', `refs/heads/${wt.branch}`], 'abandon_tip_failed', 'Inspect the branch manually, then retry.');
-        persistAbandonedWorktreeState(nodeId, wt, tipSha, at, by);
-        return { node_id: nodeId, branch: wt.branch, tip_sha: tipSha, worktree_path: wt.path, branch_deleted: false };
-    }
-    runGit(wt.path, ['add', '--all'], 'abandon_stage_failed', 'Inspect the worktree manually, then retry.');
-    runGit(wt.path, ['-c', `user.name=${ABANDON_AUTHOR_NAME}`, '-c', `user.email=${ABANDON_AUTHOR_EMAIL}`, 'commit', '--allow-empty', '-m', ABANDON_SUBJECT, '-m', `Crtr-Abandon: ${nodeId} ${at}`], 'abandon_commit_failed', 'Inspect the worktree manually, then retry.');
-    runGit(wt.repo_root, ['worktree', 'remove', wt.path], 'worktree_remove_failed', 'Inspect the worktree manually, then retry.');
-    const tipSha = runGit(wt.repo_root, ['rev-parse', `refs/heads/${wt.branch}`], 'abandon_tip_failed', 'Inspect the branch manually, then retry.');
-    persistAbandonedWorktreeState(nodeId, wt, tipSha, at, by);
-    return { node_id: nodeId, branch: wt.branch, tip_sha: tipSha, worktree_path: wt.path, branch_deleted: false };
-}
-export function abandonManagedWorktree(nodeId, by) {
-    const wt = openManagedWorktreeForNode(nodeId);
-    if (wt === null)
-        return abandonManagedWorktreeLocked(nodeId, by);
-    return withRepositoryWorktreeLock(wt.repo_root, () => abandonManagedWorktreeLocked(nodeId, by));
-}
 // Push-final auto-drop of a clean, zero-commit managed worktree
 /** Delete a source branch only while the ref that proved it already delivered
  *  is still at the exact inspected SHA. `containingRef` can be the recorded

package/dist/daemon/cron-run.js

@@ -35,14 +35,14 @@
 // promises for graceful-teardown drain but never blocks on a slow run.
 import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
-import { CRON_KILL_GRACE_MS, CRON_OUTPUT_HEAD_BYTES, EMPTY_STDOUT_SHA256, newHeadCapture, } from './cron/capture.js';
+import { CRON_DEATH_POLL_MS, CRON_KILL_GRACE_MS, CRON_OUTPUT_HEAD_BYTES, EMPTY_STDOUT_SHA256, newHeadCapture, } from './cron/capture.js';
 import { clearLiveRun, cronDaemonInstanceId, liveRunFor, registerLiveRun } from './cron/live-runs.js';
 import { buildArmedRunContext } from './cron/armed-context.js';
 import { decideHeldSettle, EXIT_HELD, HELD_DELIVERED } from './cron/held.js';
 import { settleRun } from './cron/settle.js';
 import { applyOverlapPolicies, expireDueCrons, } from './cron/passes.js';
 import { dueClockCrons, acquireCronRunLease, advanceCron, setCronState, } from '../core/canvas/crons.js';
-import { killProcessGroup } from '../core/canvas/pid.js';
+import { captureTeardownSnapshot, isAnyPidAlive, killProcessTreePids } from '../core/canvas/pid.js';
 import { emitEvent } from '../core/events/emit.js';
 import { nextSlotAfter } from '../core/wake.js';
 import { resolveAdmittedHostCommand } from '../core/runtime/spawn-env.js';
@@ -239,6 +239,9 @@ export function executeCron(c, opts) {
         let settled = false;
         let timer;
         let killTimer;
+        let deathTimer;
+        let closeCode;
+        let killed = false;
         let timedOut = false;
         let leaseLost = false;
         let processError = null;
@@ -259,19 +262,8 @@ export function executeCron(c, opts) {
         child.stderr?.on('data', (chunk) => {
             stderr.take(chunk);
         });
-        const killWithEscalation = (pid) => {
-            killProcessGroup(pid);
-            if (killTimer === undefined) {
-                killTimer = setTimeout(() => killProcessGroup(pid, 'SIGKILL'), CRON_KILL_GRACE_MS);
-                killTimer.unref?.();
-            }
-        };
-        // A signal, not settlement: 'close' always follows 'error'.
-        child.on('error', (err) => {
-            if (processError == null)
-                processError = err;
-        });
-        child.on('close', (code) => {
+        let teardown;
+        const settleClosedChild = (code) => {
             if (settled)
                 return;
             settled = true;
@@ -279,6 +271,8 @@ export function executeCron(c, opts) {
                 clearTimeout(timer);
             if (killTimer !== undefined)
                 clearTimeout(killTimer);
+            if (deathTimer !== undefined)
+                clearTimeout(deathTimer);
             const stdoutHead = stdout.decode();
             const stderrHead = stderr.decode();
             const live = liveRunFor(c.cron_id);
@@ -306,6 +300,46 @@ export function executeCron(c, opts) {
                 wasReplaced,
                 wasSelfCanceled,
             }).then(resolve, reject);
+        };
+        const awaitTeardownDeath = () => {
+            if (teardown === undefined || !isAnyPidAlive(teardown.tree)) {
+                if (closeCode !== undefined)
+                    settleClosedChild(closeCode);
+                return;
+            }
+            deathTimer = setTimeout(awaitTeardownDeath, CRON_DEATH_POLL_MS);
+        };
+        const killWithEscalation = (pid) => {
+            teardown ??= captureTeardownSnapshot(pid, null);
+            killProcessTreePids(teardown.tree, 'SIGTERM', teardown.identities);
+            if (killTimer === undefined) {
+                killTimer = setTimeout(() => {
+                    if (isAnyPidAlive(teardown.tree))
+                        killProcessTreePids(teardown.tree, 'SIGKILL', teardown.identities);
+                    killed = true;
+                    if (closeCode !== undefined)
+                        awaitTeardownDeath();
+                }, CRON_KILL_GRACE_MS);
+                killTimer.unref?.();
+            }
+        };
+        // A signal, not settlement: 'close' always follows 'error'.
+        child.on('error', (err) => {
+            if (processError == null)
+                processError = err;
+        });
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            closeCode = code;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (teardown !== undefined && isAnyPidAlive(teardown.tree)) {
+                if (killed)
+                    awaitTeardownDeath();
+                return;
+            }
+            settleClosedChild(code);
         });
         if (child.pid == null ||
             !acquireCronRunLease(c.cron_id, cronDaemonInstanceId, child.pid, startedAtIso, outOfBand)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.309",
+  "version": "0.3.311",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.309",
+  "version": "0.3.311",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.309",
+      "version": "0.3.311",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.309",
+      "version": "0.3.311",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.309",
+      "version": "0.3.311",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.309",
+      "version": "0.3.311",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"