@north-light/crouter 0.3.304 → 0.3.305

package/dist/core/runtime/broker/fault-retry.js

@@ -4,6 +4,7 @@ import { isContextOverflow } from '@earendil-works/pi-ai';
 import { classify } from '../../fault-classifier.js';
 import { admitProviderRetryEpisode, clearFault, clearProviderRetryEpisode, invalidateProviderRetryEpisode, isModelNotFoundError, isProviderUnconfiguredError, readFault, readProviderRetryEpisode, recordFault, recordPendingProviderRetryFault, reopenProviderRetryEpisode, } from '../fault.js';
 import { extractCoolingDeadline } from '../managed-provider-cooling.js';
+import { extractProviderFailureDetails } from '../../provider-failure.js';
 import { expandModelCandidates, modelRequestFromConfig, probeRouteAvailability } from '../../model-routes.js';
 import { operationIdContext } from '../../events/operation-id.js';
 import { emitEvent } from '../../events/emit.js';
@@ -131,6 +132,12 @@ export class FaultRetry {
         const uncompactedOverflow = isContextOverflow(last, settledSession.model?.contextWindow);
         const classified = classify('pi→provider', last);
         const coolingDeadline = extractCoolingDeadline(last);
+        const failure = extractProviderFailureDetails(last);
+        const provider = typeof last.provider === 'string' && last.provider !== '' ? last.provider : settledSession.model?.provider;
+        const model = typeof last.model === 'string' && last.model !== '' ? last.model : settledSession.model?.id;
+        const providerError = failure === undefined || provider === undefined || model === undefined
+            ? undefined
+            : { provider, model, ...failure };
         if (uncompactedOverflow) {
             clearFault(this.deps.nodeId, { link: 'pi→provider' });
             clearProviderRetryEpisode(this.deps.nodeId);
@@ -151,6 +158,7 @@ export class FaultRetry {
             anchorEntryId: !uncompactedOverflow && classified.disposition === 'auto' && episode?.anchorEntryId !== undefined
                 ? episode.anchorEntryId
                 : settledSession.sessionManager.getLeafId?.() ?? undefined,
+            ...(providerError === undefined ? {} : { providerError }),
         };
         if (faultInput.retry.disposition === 'auto')
             this.recordPendingProviderFault(settledSession, faultInput);

package/dist/core/runtime/fault.d.ts

@@ -1,4 +1,4 @@
-import { type Fault, type FaultKind, type FaultLink, type FaultRetry } from '../fault-classifier.js';
+import { type Fault, type FaultKind, type FaultLink, type FaultProviderError, type FaultRetry } from '../fault-classifier.js';
 export type { Fault, FaultKind, FaultLink, FaultRetry, FaultRetryDisposition, FaultRetryOwner } from '../fault-classifier.js';
 export declare const FAULT_QUIET_MS: number;
 export interface FaultRecordInput {
@@ -10,6 +10,7 @@ export interface FaultRecordInput {
     operation_id?: string;
     since?: string;
     anchorEntryId?: string;
+    providerError?: FaultProviderError;
 }
 /** A provider-retry episode outlives its broker-local timer. Its transcript
  * path and anchor are explicit coordinates, so replacement invalidation never

package/dist/core/runtime/fault.js

@@ -1,4 +1,5 @@
 import { envNodeId } from '../../shared/env.js';
+import { isRecord } from '../../shared/predicates.js';
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { jobDir } from '../canvas/paths.js';
@@ -33,6 +34,37 @@ function faultPriority(fault) {
 }
 const faultLinks = ['pi→provider', 'viewer↔broker', 'relay↔broker', 'viewer↔crtrd', 'broker↔crtrd', 'daemon→node', 'crtr→pi'];
 const faultKinds = ['rate-limit', 'overloaded', 'connection', 'auth', 'protocol', 'context-overflow', 'other', 'wedged', 'model-not-found'];
+function parseProviderError(value) {
+    if (!isRecord(value) || typeof value.provider !== 'string' || value.provider === '' || typeof value.model !== 'string' || value.model === '')
+        return undefined;
+    const status = typeof value.status === 'number' && Number.isFinite(value.status) ? value.status : undefined;
+    const code = typeof value.code === 'string' || typeof value.code === 'number' ? value.code : undefined;
+    const errno = typeof value.errno === 'string' ? value.errno : undefined;
+    const body = typeof value.body === 'string' ? value.body : undefined;
+    const causes = Array.isArray(value.causes)
+        ? value.causes.flatMap((item) => {
+            if (!isRecord(item))
+                return [];
+            const cause = {
+                ...(typeof item.message === 'string' ? { message: item.message } : {}),
+                ...(typeof item.status === 'number' && Number.isFinite(item.status) ? { status: item.status } : {}),
+                ...(typeof item.code === 'string' || typeof item.code === 'number' ? { code: item.code } : {}),
+                ...(typeof item.errno === 'string' ? { errno: item.errno } : {}),
+                ...(typeof item.body === 'string' ? { body: item.body } : {}),
+            };
+            return Object.keys(cause).length === 0 ? [] : [cause];
+        })
+        : undefined;
+    return {
+        provider: value.provider,
+        model: value.model,
+        ...(status === undefined ? {} : { status }),
+        ...(code === undefined ? {} : { code }),
+        ...(errno === undefined ? {} : { errno }),
+        ...(body === undefined ? {} : { body }),
+        ...(causes === undefined || causes.length === 0 ? {} : { causes }),
+    };
+}
 function parseFault(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -60,6 +92,9 @@ function parseFault(raw) {
             return null;
         if (parsed.anchorEntryId !== undefined && (typeof parsed.anchorEntryId !== 'string' || parsed.anchorEntryId === ''))
             return null;
+        const providerError = parsed.providerError === undefined ? undefined : parseProviderError(parsed.providerError);
+        if (parsed.providerError !== undefined && providerError === undefined)
+            return null;
         return {
             link: parsed.link,
             op: parsed.op,
@@ -75,6 +110,7 @@ function parseFault(raw) {
             since: parsed.since,
             operation_id: operationId,
             ...(parsed.anchorEntryId === undefined ? {} : { anchorEntryId: parsed.anchorEntryId }),
+            ...(providerError === undefined ? {} : { providerError }),
         };
     }
     catch {
@@ -166,6 +202,7 @@ function storedFault(input) {
         since: input.since ?? new Date().toISOString(),
         operation_id: resolveOperationId(input.operation_id),
         ...(typeof input.anchorEntryId === 'string' && input.anchorEntryId !== '' ? { anchorEntryId: input.anchorEntryId } : {}),
+        ...(input.providerError === undefined ? {} : { providerError: input.providerError }),
     };
 }
 function emitRecordedFault(nodeId, fault) {
@@ -182,6 +219,7 @@ function emitRecordedFault(nodeId, fault) {
             retry: fault.retry,
             message: fault.message,
             ...(fault.anchorEntryId === undefined ? {} : { anchor_entry_id: fault.anchorEntryId }),
+            ...(fault.providerError === undefined ? {} : { provider_error: fault.providerError }),
         },
     });
 }

package/dist/core/runtime/kickoff.d.ts

@@ -26,6 +26,9 @@ export declare function readYieldMessage(nodeId: string): string | null;
 export declare function clearYieldMessage(nodeId: string): void;
 /** List the node's context/ dir (filenames, sorted). Empty when absent. */
 export declare function listContextDir(nodeId: string): string[];
+/** A retained report proves this node has already done work. It must restart
+ * from current context, never by replaying its birth mandate. */
+export declare function hasRetainedReports(nodeId: string): boolean;
 export interface ReviveBearings {
     /** The one-shot yield note left by the prior self, pending boot confirmation. */
     yieldMsg: string | null;

package/dist/core/runtime/kickoff.js

@@ -99,6 +99,12 @@ export function listContextDir(nodeId) {
         return [];
     return readdirSync(dir).sort();
 }
+/** A retained report proves this node has already done work. It must restart
+ * from current context, never by replaying its birth mandate. */
+export function hasRetainedReports(nodeId) {
+    const dir = reportsDir(nodeId);
+    return existsSync(dir) && readdirSync(dir).some((file) => file.endsWith('.md'));
+}
 /** Capture revive bearings for `meta`: read the pending yield note, advance the
  *  feed cursor past unread reports, and capture external persona framing.
  *  Revive paths call it once, then pass the result to the pure kickoff builder. */
@@ -113,9 +119,23 @@ export function drainBearings(meta) {
     let unreadDigest = null;
     if (entries.length > 0) {
         writeCursor(nodeId, entries.at(-1).entry_id);
-        // The launch-argv seam carries one message, so a mixed batch's split parts
-        // join back into this block's body; the kickoff is one whole envelope.
-        unreadDigest = coalesce(entries).map((delivery) => delivery.text).join('\n\n');
+        // The launch argv carries one message. Keep coalescing card-free runs, but
+        // start a new batch at each entry with cards. A batch's cards are therefore
+        // directly ahead of its coalesced text, so they cannot leap an earlier body.
+        const cardsFor = (entry) => {
+            const cards = entry.data?.['cards'];
+            return Array.isArray(cards) ? cards.filter((card) => typeof card === 'string') : [];
+        };
+        const segments = [];
+        for (const entry of entries) {
+            if (cardsFor(entry).length > 0 || segments.length === 0)
+                segments.push([]);
+            segments.at(-1).push(entry);
+        }
+        unreadDigest = segments.map((segment) => [
+            ...cardsFor(segment[0]),
+            coalesce(segment).map((delivery) => delivery.text).join('\n\n'),
+        ].join('\n\n')).join('\n\n');
     }
     const drift = personaDrift(nodeId);
     const driftGuidance = drift?.guidance === undefined || drift.guidance === ''
@@ -261,7 +281,7 @@ export function buildReviveKickoff(meta, bearings, wakeReason) {
     // (audit 2026-06-09, Bug 4: mq45b6ch-9ecc2f03), whose only mandate on disk IS
     // the goal. Surface the goal then. When a roadmap exists it stays the sole
     // source of truth (the goal is usually stale by comparison) — unchanged.
-    if (!hasRoadmapBody) {
+    if (!hasRoadmapBody && !hasRetainedReports(nodeId)) {
         const goal = readGoal(nodeId);
         if (goal !== null && goal.trim() !== '') {
             parts.push(`<goal file="${goalPath(nodeId)}">\n${goal.trim()}\n</goal>`);

package/dist/core/runtime/reopen.d.ts

@@ -25,14 +25,14 @@ export declare function commitReopen(nodeId: string, expectedFinalReport: string
  * unlatched node is valid here — it still becomes resident. Writing lifecycle
  * first leaves a failed latch CAS with the canonical-final pointer intact.
  * Both writes finish before either delivery channel begins. */
-export declare function commitReopenResident(nodeId: string): void;
+export declare function commitReopenResident(nodeId: string, expectedFinalReport?: string): string | null;
 /** Convenience wrapper for a doorway with NO intervening fallible step between
  *  the gate check and the reopen clear (`node lifecycle revive` has nothing
  *  fallible between the gate and `reviveNode`). Validates and, when `reopen`,
  *  clears in one call.
  *
  *  - `reopen` false + latched → throws `node_finalized`.
- *  - `reopen` true + latched → CAS-clears the latch (side effect) and returns.
+ *  - `reopen` true + latched → makes the node resident and CAS-clears the latch (side effect) and returns.
  *  - `reopen` true + not latched → throws `not_finalized`.
  *  - `reopen` false + not latched → no-op (the common case). */
 export declare function assertReopenGate(nodeId: string, reopen: boolean): void;

package/dist/core/runtime/reopen.js

@@ -104,7 +104,7 @@ export function commitReopen(nodeId, expectedFinalReport) {
  * unlatched node is valid here — it still becomes resident. Writing lifecycle
  * first leaves a failed latch CAS with the canonical-final pointer intact.
  * Both writes finish before either delivery channel begins. */
-export function commitReopenResident(nodeId) {
+export function commitReopenResident(nodeId, expectedFinalReport) {
     const finalReport = currentFinalReport(nodeId);
     updateNode(nodeId, { lifecycle: 'resident' });
     // A reopened node that is still parked in a terminal status has to come back
@@ -116,7 +116,8 @@ export function commitReopenResident(nodeId) {
         transition(nodeId, 'revive');
     }
     if (finalReport !== null)
-        commitReopen(nodeId, finalReport);
+        commitReopen(nodeId, expectedFinalReport ?? finalReport);
+    return finalReport;
 }
 /** Convenience wrapper for a doorway with NO intervening fallible step between
  *  the gate check and the reopen clear (`node lifecycle revive` has nothing
@@ -124,12 +125,13 @@ export function commitReopenResident(nodeId) {
  *  clears in one call.
  *
  *  - `reopen` false + latched → throws `node_finalized`.
- *  - `reopen` true + latched → CAS-clears the latch (side effect) and returns.
+ *  - `reopen` true + latched → makes the node resident and CAS-clears the latch (side effect) and returns.
  *  - `reopen` true + not latched → throws `not_finalized`.
  *  - `reopen` false + not latched → no-op (the common case). */
 export function assertReopenGate(nodeId, reopen) {
     if (reopen) {
-        commitReopen(nodeId, assertFinalizedForReopen(nodeId));
+        const expectedFinalReport = assertFinalizedForReopen(nodeId);
+        commitReopenResident(nodeId, expectedFinalReport);
         return;
     }
     assertNotFinalized(nodeId);

package/dist/core/runtime/revive.js

@@ -31,7 +31,7 @@ import { isParked, transition } from './lifecycle.js';
 import { fanDoctrineWake } from './close.js';
 import { InputError } from '../io.js';
 import { buildPiArgv } from './launch.js';
-import { buildReviveKickoff, drainBearings, readGoal, readYieldMessage, RUNTIME_RESTART_CONTINUATION } from './kickoff.js';
+import { buildReviveKickoff, drainBearings, hasRetainedReports, readGoal, readYieldMessage, RUNTIME_RESTART_CONTINUATION } from './kickoff.js';
 import { readRoadmap } from './roadmap.js';
 import { encodeKickoffOrigin, KICKOFF_ORIGIN_ENV } from './stamp/protocol.js';
 import { headlessBrokerHost } from './host.js';
@@ -105,7 +105,7 @@ function resumableSessionArgs(nodeId, meta, resume) {
 }
 // Return type
 /** A relaunch that has NO transcript to resume or branch from, and no durable
- *  work state on disk (no roadmap, no yield note), is not a revive at all — the
+ *  work state on disk (no roadmap, yield note, or retained report), is not a revive at all — the
  *  node never got a conversation off the ground, so there is no "previous
  *  in-memory context" that was lost. pi does not write a `.jsonl` until the
  *  first turn, so an idle node the user never messaged is the common case: it
@@ -116,7 +116,7 @@ function resumableSessionArgs(nodeId, meta, resume) {
  *  a BIRTH instead: replay the spawn mandate when it has one, or boot with no
  *  prompt at all and leave it sitting exactly where it was. */
 function isUnstartedBirth(nodeId) {
-    return readRoadmap(nodeId) === null && readYieldMessage(nodeId) === null;
+    return readRoadmap(nodeId) === null && readYieldMessage(nodeId) === null && !hasRetainedReports(nodeId);
 }
 /** Whether a fresh context window would have anything on disk to stand on: a
  *  goal, a roadmap, or both. The negative is what makes a fresh cycle worse

package/dist/core/runtime/tmux-bindings.js

@@ -586,14 +586,25 @@ function reconcileTmuxBindings(bindingSnapshot, passthroughSnapshot = []) {
         }
     }
     // Restore every wrapper crouter still owns before the ordinary binding sweep.
-    // A live line that differs from the fingerprint is a user's later rebind: it
-    // is protected from this and every later reconciliation until they toggle the
-    // passthrough preference off and on again.
+    // A live line that matches neither the fingerprint nor the original crouter
+    // recorded is a user's later rebind: it is protected from this and every later
+    // reconciliation until they toggle the passthrough preference off and on again.
+    //
+    // A live line equal to the ORIGINAL is not a rebind. It is the user's own tmux
+    // config re-sourced over the wrapper, which every `source-file` and every fresh
+    // tmux server does. Relinquishing there disarmed passthrough silently and
+    // permanently for anyone whose config binds a key crouter wraps, so that case
+    // falls through with nothing to restore — the wrap pass below re-reads the live
+    // line as the original and wraps it again. It also releases a key already stuck
+    // relinquished: matching the recorded original is proof the user did not rebind
+    // it to something of their own.
     const protectedRootKeys = new Set();
     const wrappers = [];
     for (const prior of manifest.wrappers) {
         const desired = desiredWrappers.get(prior.key);
         const live = bindingAt(ROOT_TABLE, prior.key);
+        if (live !== null && live === prior.original)
+            continue;
         if (prior.state === 'relinquished' || live !== prior.wrapper) {
             protectedRootKeys.add(prior.key);
             if (desired !== undefined) {

package/dist/core/termrender/version.d.ts

@@ -1 +1 @@
-export declare const TERMRENDER_VERSION = "4.12.11";
+export declare const TERMRENDER_VERSION = "4.12.12";

package/dist/core/termrender/version.js

@@ -1 +1 @@
-export const TERMRENDER_VERSION = '4.12.11';
+export const TERMRENDER_VERSION = '4.12.12';

package/dist/core/worktree-close.js

@@ -100,18 +100,21 @@ async function landIntoBaseCheckout(baseCheckout, branch, baseSha, landedSha) {
     const stashSha = after.status === 0 ? after.stdout.trim() : null;
     if (stashSha === null || stashSha === beforeSha)
         return merge();
+    const recovery = `local changes from ${baseCheckout} are retained in stash ${stashSha}; recover them with \`git -C ${shellQuote(baseCheckout)} stash apply ${stashSha}\` and resolve any conflict.`;
     const landed = await merge();
     if (!landed.ok) {
-        if ((await gitAsync(['stash', 'apply', stashSha], baseCheckout)).status === 0)
+        if ((await gitAsync(['stash', 'apply', stashSha], baseCheckout)).status === 0) {
             await dropStashIfStillTip(baseCheckout, stashSha);
-        return landed;
+            return landed;
+        }
+        return { ok: false, detail: `${landed.detail}\n${recovery}` };
     }
     if ((await gitAsync(['stash', 'apply', stashSha], baseCheckout)).status === 0) {
         await dropStashIfStillTip(baseCheckout, stashSha);
         return { ok: true };
     }
     await gitAsync(['reset', '--hard', landedSha], baseCheckout);
-    return { ok: true, stash: `local changes in ${baseCheckout} conflicted with the landed commits and were PRESERVED as stash ${stashSha}; nothing was lost. Re-apply them with \`git -C ${shellQuote(baseCheckout)} stash apply ${stashSha}\` and resolve the conflict.` };
+    return { ok: true, stash: `the shared base checkout was reset to landed commit ${landedSha} because local changes conflicted with it. ${recovery}` };
 }
 async function closeLocked(nodeId) {
     const node = getNode(nodeId);

package/dist/core/worktree-sweep.js

@@ -23,6 +23,7 @@ import { withExclusiveDirectoryLockAsync } from './exclusive-lock.js';
 import { gitAsync } from './git.js';
 import { proveBranchContained, upstreamTip } from './worktree-containment.js';
 import { parseStatusPorcelain, planLandIntoCheckout, refDeleteTransactionStdin } from './worktree-landing.js';
+import { shellQuote } from '../shared/shell-quote.js';
 import { WORKTREE_LOCK_WAIT_MS, checkoutPathForBranchInList, persistClosedWorktreeState, samePath, worktreeLockPathForCommonDir } from './worktree.js';
 /** Escalating recheck interval, in minutes, indexed by consecutive refusal. The
  *  last tier is the cap AND the quarantine threshold: at that point the record
@@ -196,18 +197,21 @@ async function landIntoBaseCheckoutAsync(baseCheckout, branch, baseSha, landedSh
     const stashSha = await revParseRef(baseCheckout, 'refs/stash');
     if (stashSha === null || stashSha === beforeSha)
         return merge(); // nothing was saved
+    const recovery = `local changes from ${baseCheckout} are retained in stash ${stashSha}; recover them with \`git -C ${shellQuote(baseCheckout)} stash apply ${stashSha}\` and resolve any conflict.`;
     const landed = await merge();
     if (!landed.ok) {
-        if ((await gitAsync(['stash', 'apply', stashSha], baseCheckout)).status === 0)
+        if ((await gitAsync(['stash', 'apply', stashSha], baseCheckout)).status === 0) {
             await dropStashIfStillTip(baseCheckout, stashSha);
-        return landed;
+            return landed;
+        }
+        return { ok: false, detail: `${landed.detail}\n${recovery}` };
     }
     if ((await gitAsync(['stash', 'apply', stashSha], baseCheckout)).status === 0) {
         await dropStashIfStillTip(baseCheckout, stashSha);
         return { ok: true };
     }
     await gitAsync(['reset', '--hard', landedSha], baseCheckout);
-    return { ok: true, stash: `local changes in ${baseCheckout} conflicted with the landed commits and were PRESERVED as stash ${stashSha}; re-apply them with \`git -C ${baseCheckout} stash apply ${stashSha}\`.` };
+    return { ok: true, stash: `the shared base checkout was reset to landed commit ${landedSha} because local changes conflicted with it. ${recovery}` };
 }
 async function dropStashIfStillTip(cwd, stashSha) {
     if ((await revParseRef(cwd, 'refs/stash')) === stashSha)

package/dist/core/worktree.js

@@ -412,13 +412,16 @@ function landIntoBaseCheckout(baseCheckout, branch, baseSha, landedSha) {
     const stashSha = after.status === 0 ? after.stdout.trim() : null;
     if (stashSha === null || stashSha === beforeSha)
         return merge(); // nothing was saved
+    const recovery = `local changes from ${baseCheckout} are retained in stash ${stashSha}; recover them with \`git -C ${shellQuote(baseCheckout)} stash apply ${stashSha}\` and resolve any conflict.`;
     const landed = merge();
     if (!landed.ok) {
         // The failed merge left the tree exactly as the stash found it, so this
         // re-apply is clean; restore before surfacing the refusal.
-        if (gitSync(['stash', 'apply', stashSha], baseCheckout).status === 0)
+        if (gitSync(['stash', 'apply', stashSha], baseCheckout).status === 0) {
             dropStashIfStillTip(baseCheckout, stashSha);
-        return landed;
+            return landed;
+        }
+        return { ok: false, detail: `${landed.detail}\n${recovery}` };
     }
     if (gitSync(['stash', 'apply', stashSha], baseCheckout).status === 0) {
         dropStashIfStillTip(baseCheckout, stashSha);
@@ -427,7 +430,7 @@ function landIntoBaseCheckout(baseCheckout, branch, baseSha, landedSha) {
     gitSync(['reset', '--hard', landedSha], baseCheckout);
     return {
         ok: true,
-        stash: `local changes in ${baseCheckout} conflicted with the landed commits and were PRESERVED as stash ${stashSha}; nothing was lost. Re-apply them with \`git -C ${shellQuote(baseCheckout)} stash apply ${stashSha}\` and resolve the conflict.`,
+        stash: `the shared base checkout was reset to landed commit ${landedSha} because local changes conflicted with it. ${recovery}`,
     };
 }
 /** Drop a stash entry only while it is still the tip `stash@{0}` names, so a

package/dist/daemon/api/__tests__/reopen-delivery.test.js

@@ -8,7 +8,9 @@ import { closeDb } from '../../../core/canvas/db.js';
 import { viewSocketPath } from '../../../core/canvas/paths.js';
 import { readInboxSince } from '../../../core/feed/inbox.js';
 import { headlessBrokerHost } from '../../../core/runtime/host.js';
+import { bindTestFleet } from '../../../core/__tests__/helpers/fleet.js';
 import { messageRoutes } from '../handlers/messages.js';
+import { nodeRoutes } from '../handlers/nodes.js';
 let home;
 const priorHome = process.env['CRTR_HOME'];
 before(() => {
@@ -20,6 +22,7 @@ before(() => {
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    bindTestFleet();
 });
 after(() => {
     closeDb();
@@ -57,6 +60,19 @@ async function sendMessage(id, body) {
     };
     return messageRoutes[0].handler(ctx);
 }
+async function revive(id, body) {
+    const ctx = {
+        method: 'POST',
+        path: `/v1/nodes/${id}/revive`,
+        params: { id },
+        query: new URLSearchParams(),
+        body,
+    };
+    const route = nodeRoutes.find((candidate) => candidate.pattern === '/v1/nodes/:id/revive');
+    if (route === undefined)
+        throw new Error('missing node revive route');
+    return route.handler(ctx);
+}
 async function startLiveBroker(id, failDelivery = false) {
     let observed = null;
     const server = createServer((socket) => {
@@ -170,6 +186,21 @@ test('reopen makes live terminal, finalized terminal, and parked targets residen
         headlessBrokerHost.launch = originalLaunch;
     }
 });
+test('standalone revive reopen restores the same resident lifecycle before booting', async () => {
+    const id = 'standalone-reopen';
+    createNode(node(id, 'terminal', 'done'));
+    finalize(id);
+    const originalLaunch = headlessBrokerHost.launch;
+    headlessBrokerHost.launch = (() => ({ pid: 0x7ffffffe, exited: Promise.resolve({ code: 0, signal: null }) }));
+    try {
+        const result = await revive(id, { reopen: true });
+        assert.equal(result.status, 200, 'standalone revive accepts an explicit reopen');
+    }
+    finally {
+        headlessBrokerHost.launch = originalLaunch;
+    }
+    assertReopened(id);
+});
 test('a reopen commit failure delivers nothing', async () => {
     const id = 'commit-failure';
     createNode(node(id, 'terminal', 'done'));

package/dist/daemon/api/__tests__/seam/leaf-api-parity.test.js

@@ -19,7 +19,7 @@
 // in-process server exactly as a real `crtr push` CLI process would.
 import { test, before, after } from 'node:test';
 import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createHeadlessHarness } from '../../../../core/__tests__/helpers/harness.js';
@@ -87,16 +87,19 @@ async function runPushAs(caller, tier, body, input = {}) {
     }
 }
 // The `node worktree close` leaf, resolved from the real command tree exactly as
-// the CLI dispatcher would, and driven as the given caller node.
-async function runCloseAs(caller) {
+// the CLI dispatcher would.
+function closeLeaf() {
     const worktree = registerNode().children.find((c) => c.name === 'worktree');
     assert.ok(worktree !== undefined && worktree.kind === 'branch', 'node worktree branch resolves');
     const close = worktree.children.find((c) => c.name === 'close');
     assert.ok(close !== undefined && close.kind === 'leaf', 'node worktree close leaf resolves');
+    return close;
+}
+async function runCloseAs(caller) {
     const prev = process.env['CRTR_NODE_ID'];
     process.env['CRTR_NODE_ID'] = caller;
     try {
-        return (await close.run({}));
+        return (await closeLeaf().run({}));
     }
     finally {
         if (prev === undefined)
@@ -300,6 +303,35 @@ test('`crtr push final` keeps an absent managed worktree open when its branch is
         rmSync(repo, { recursive: true, force: true });
     }
 });
+test('`crtr node worktree close` warns with the retained stash SHA when base-checkout changes conflict (#1066)', async () => {
+    const repo = initRepo();
+    try {
+        writeFileSync(join(repo, 'conflict.txt'), 'base\n');
+        writeFileSync(join(repo, 'disjoint.txt'), 'base\n');
+        git(['add', '.'], repo);
+        git(['commit', '-m', 'tracked base files'], repo);
+        const id = 'wt-close-stash-warning';
+        const wt = createManagedWorktree(repo, id);
+        createNode(worktreeNode(id, wt.path, wt));
+        writeFileSync(join(wt.path, 'conflict.txt'), 'child\n');
+        git(['add', 'conflict.txt'], wt.path);
+        git(['commit', '-m', 'child conflict'], wt.path);
+        writeFileSync(join(repo, 'conflict.txt'), 'base live edit\n');
+        writeFileSync(join(repo, 'disjoint.txt'), 'disjoint live edit\n');
+        const out = await runCloseAs(id);
+        const stashSha = gitSync(['rev-parse', 'refs/stash'], repo).stdout.trim();
+        const rendered = closeLeaf().render?.(out) ?? '';
+        assert.match(out['base_checkout_stash'], new RegExp(`stash ${stashSha}`), 'the API result identifies the exact retained stash');
+        assert.match(rendered, new RegExp(`stash ${stashSha}`), 'the CLI output identifies the exact retained stash');
+        assert.match(rendered, new RegExp(`git -C '${realpathSync(repo)}' stash apply ${stashSha}`), 'the CLI output gives the exact recovery command');
+        assert.match(rendered, /shared base checkout was reset to landed commit/, 'the CLI output states that the shared checkout was reset');
+        assert.doesNotMatch(rendered, /nothing was lost/i, 'the CLI does not claim all concurrent work was preserved');
+        assert.equal(readFileSync(join(repo, 'disjoint.txt'), 'utf8'), 'base\n', 'the reset removes the disjoint live edit from the checkout but leaves it in the reported stash');
+    }
+    finally {
+        rmSync(repo, { recursive: true, force: true });
+    }
+});
 // `node worktree close` error parity — the SPECIFIC WorktreeError code + its
 // `next` remediation round-trip verbatim through the server → ApiError → the
 // bespoke CLI mapper in node-worktree.ts, instead of collapsing to a generic

package/dist/daemon/api/handlers/messages.js

@@ -1,6 +1,7 @@
 // Message handler (spec §6.2). `POST /v1/nodes/{id}/messages` delivers an
 // inbox message now (201) or fresh-revives with no inbox entry. `{id}` is the
 // target node.
+import { join } from 'node:path';
 import { appendInbox, cancelPendingHumanMessages } from '../../../core/feed/inbox.js';
 import { reviveNode } from '../../../core/runtime/revive.js';
 import { BrokerUnreachableError } from '../../../core/runtime/broker-request.js';
@@ -8,9 +9,10 @@ import { isBrokerLive } from '../../../core/runtime/model-swap.js';
 import { deliverLive, interruptLive } from '../../../core/runtime/interactive-deliver.js';
 import { isProfilePaused } from '../../../core/profiles/manifest.js';
 import { getNode, withFreshTerminalGuard } from '../../../core/canvas/canvas.js';
+import { reportsDir } from '../../../core/canvas/paths.js';
 import { withCanvasWrite } from '../../../core/canvas/db.js';
 import { cancelCronsOnWake } from '../../../core/canvas/crons.js';
-import { assertNotFinalized, assertFinalizedForReopen, commitReopen, commitReopenResident, } from '../../../core/runtime/reopen.js';
+import { assertNotFinalized, assertFinalizedForReopen, commitReopenResident, } from '../../../core/runtime/reopen.js';
 import { writeOutputSchema } from '../../../core/runtime/structured-output.js';
 import { appendSituationalContext, formatSituationalProse } from '../../../core/runtime/situational-context.js';
 import { formatDataCard } from '../../../shared/generated-context.js';
@@ -162,6 +164,12 @@ function parseSchema(raw) {
 function label(text) {
     return text.split('\n')[0].slice(0, 120);
 }
+function previousFinalReportCard(nodeId, finalReport) {
+    if (finalReport === null)
+        return '';
+    const path = join(reportsDir(nodeId), finalReport);
+    return formatDataCard('reopen-final-report', { path }, 'This node previously completed work. Read this final report before acting on the new instruction.');
+}
 /** The fail-loud rejection for a deferred immediate message aimed at a
  *  target with no natural cycle ahead of it (done/canceled/finalized). Thrown as
  *  an InputError so `toErrorBody` round-trips the FULL structured payload
@@ -212,7 +220,7 @@ async function handleMessage(ctx) {
         ? parseSchema(req.output_schema)
         : null;
     // Fresh revive: no inbox entry, resume:false (spec §7.7).
-    // Mirrors the CLI's immediate --fresh: validate/clear the finalization latch
+    // Mirrors the CLI's immediate --fresh: validate the finalization latch
     // (--reopen) and upsert the situational sidecar BEFORE the revive, so the
     // fresh kickoff picks up the update. The goal/roadmap recoverable-state guard
     // stays a pure CLI-side pre-check.
@@ -224,7 +232,7 @@ async function handleMessage(ctx) {
         if (hasSidecar)
             appendSituationalContext(id, sidecar);
         if (req.reopen)
-            commitReopen(id, expectedFinalReport);
+            commitReopenResident(id, expectedFinalReport);
         // A fresh revive appends no inbox entry, so nothing survives a freeze for
         // the daemon to act on later: at the cap the caller is told, not ignored.
         const result = await reviveNode(id, { resume: false, capacity: 'refuse' });
@@ -243,8 +251,9 @@ async function handleMessage(ctx) {
     // An interactive reopen commits before even choosing its engine-or-inbox
     // route. A live transport race then falls back with this same committed state.
     let reopenCommitted = false;
+    let previousFinalCard = '';
     if (req.delivery === 'interactive' && req.reopen) {
-        commitReopenResident(id);
+        previousFinalCard = previousFinalReportCard(id, commitReopenResident(id));
         reopenCommitted = true;
     }
     // --- Interactive delivery: route via the LIVE broker's serialized frame
@@ -258,7 +267,11 @@ async function handleMessage(ctx) {
             if (hasSidecar)
                 appendSituationalContext(id, sidecar);
             await deliverLive(id, req.body, {
-                cards: [...(hasSidecar ? [sidecar] : []), ...oneShotCards],
+                cards: [
+                    ...(previousFinalCard === '' ? [] : [previousFinalCard]),
+                    ...(hasSidecar ? [sidecar] : []),
+                    ...oneShotCards,
+                ],
                 // Same authorship the durable route would record for this send, so a
                 // reader cannot tell live from inbox delivery by the stamp.
                 origin: from === 'human'
@@ -295,9 +308,13 @@ async function handleMessage(ctx) {
         if (hasSidecar)
             appendSituationalContext(id, sidecar);
         if (req.reopen && !reopenCommitted) {
-            commitReopenResident(id);
+            previousFinalCard = previousFinalReportCard(id, commitReopenResident(id));
         }
-        const cards = oneShotCards.length > 0 ? { cards: oneShotCards } : {};
+        const cards = [
+            ...(previousFinalCard === '' ? [] : [previousFinalCard]),
+            ...oneShotCards,
+        ];
+        const cardData = cards.length > 0 ? { cards } : {};
         if (hasBody || schema !== null) {
             const messageBody = hasBody
                 ? req.body
@@ -307,7 +324,7 @@ async function handleMessage(ctx) {
                 tier,
                 kind: 'message',
                 label: label(messageBody),
-                data: { body: messageBody, ...(hasSidecar ? { situational: true } : {}), ...cards },
+                data: { body: messageBody, ...(hasSidecar ? { situational: true } : {}), ...cardData },
             });
         }
         // Context-only: a hidden wake marker excluded from the visible digest. Its
@@ -318,7 +335,7 @@ async function handleMessage(ctx) {
             tier,
             kind: 'message',
             label: hasSidecar ? '(ambient context updated)' : '(context delivered)',
-            data: { ...(hasSidecar ? { situational: true } : {}), situationalOnly: true, ...cards },
+            data: { ...(hasSidecar ? { situational: true } : {}), situationalOnly: true, ...cardData },
         });
     };
     // Deferred guard: a done/canceled/finalized target has no natural