@north-light/crouter 0.3.304 → 0.3.306

package/dist/core/provider-failure.d.ts

@@ -0,0 +1,30 @@
+export declare const PROVIDER_FAILURE_DIAGNOSTIC = "crtr:provider-failure";
+export interface ProviderFailureCause {
+    message?: string;
+    status?: number;
+    code?: string | number;
+    errno?: string;
+    body?: string;
+}
+export interface ProviderFailureDetails {
+    status?: number;
+    code?: string | number;
+    errno?: string;
+    body?: string;
+    causes?: ProviderFailureCause[];
+}
+export interface NormalizedProviderFailure extends ProviderFailureDetails {
+    message: string;
+}
+/** Converts an arbitrary provider failure into serializable facts before an SDK stream flattens it to `errorMessage`. */
+export declare function normalizeProviderFailure(error: unknown, observed?: {
+    status?: number;
+}): NormalizedProviderFailure;
+/** The stable diagnostic carrier for normalized provider error facts on an assistant error message. */
+export declare function providerFailureDiagnostic(details: ProviderFailureDetails): {
+    type: string;
+    timestamp: number;
+    details: Record<string, unknown>;
+};
+/** Reads provider facts from the assistant-message diagnostic without trusting arbitrary nested error objects. */
+export declare function extractProviderFailureDetails(message: unknown): ProviderFailureDetails | undefined;

package/dist/core/provider-failure.js

@@ -0,0 +1,86 @@
+import { isRecord } from '../shared/predicates.js';
+export const PROVIDER_FAILURE_DIAGNOSTIC = 'crtr:provider-failure';
+const CAUSE_LIMIT = 8;
+function text(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+function status(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function code(value) {
+    return typeof value === 'string' || typeof value === 'number' ? value : undefined;
+}
+function record(value) {
+    return isRecord(value) ? value : undefined;
+}
+function failureCause(value) {
+    const message = text(value['errorMessage']) ?? text(value['message']) ?? text(value['reason']) ?? text(value['statusText']);
+    const cause = {
+        ...(message === undefined ? {} : { message }),
+        ...(status(value['status']) === undefined ? {} : { status: status(value['status']) }),
+        ...(code(value['code']) === undefined ? {} : { code: code(value['code']) }),
+        ...(text(value['errno']) === undefined ? {} : { errno: text(value['errno']) }),
+        ...(text(value['body']) === undefined ? {} : { body: text(value['body']) }),
+    };
+    return Object.keys(cause).length === 0 ? undefined : cause;
+}
+/** Converts an arbitrary provider failure into serializable facts before an SDK stream flattens it to `errorMessage`. */
+export function normalizeProviderFailure(error, observed = {}) {
+    const root = record(error);
+    const rootCause = root === undefined ? undefined : failureCause(root);
+    const causes = [];
+    const seen = new Set([error]);
+    let current = root === undefined ? undefined : record(root['cause']);
+    while (current !== undefined && !seen.has(current) && causes.length < CAUSE_LIMIT) {
+        seen.add(current);
+        const cause = failureCause(current);
+        if (cause !== undefined)
+            causes.push(cause);
+        current = record(current['cause']);
+    }
+    const message = rootCause?.message ?? (error instanceof Error ? error.message : undefined) ?? String(error ?? 'Provider request failed');
+    return {
+        message,
+        ...((observed.status ?? rootCause?.status) === undefined ? {} : { status: observed.status ?? rootCause?.status }),
+        ...(rootCause?.code === undefined ? {} : { code: rootCause.code }),
+        ...(rootCause?.errno === undefined ? {} : { errno: rootCause.errno }),
+        ...(rootCause?.body === undefined ? {} : { body: rootCause.body }),
+        ...(causes.length === 0 ? {} : { causes }),
+    };
+}
+/** The stable diagnostic carrier for normalized provider error facts on an assistant error message. */
+export function providerFailureDiagnostic(details) {
+    return { type: PROVIDER_FAILURE_DIAGNOSTIC, timestamp: Date.now(), details: { ...details } };
+}
+function providerFailureDetails(value) {
+    const diagnostics = record(value)?.['diagnostics'];
+    if (!Array.isArray(diagnostics))
+        return undefined;
+    for (const diagnostic of diagnostics) {
+        const diagnosticRecord = record(diagnostic);
+        if (diagnosticRecord?.['type'] !== PROVIDER_FAILURE_DIAGNOSTIC)
+            continue;
+        const details = record(diagnosticRecord['details']);
+        if (details === undefined)
+            continue;
+        const causes = Array.isArray(details['causes'])
+            ? details['causes'].flatMap((item) => {
+                const cause = record(item);
+                const normalized = cause === undefined ? undefined : failureCause(cause);
+                return normalized === undefined ? [] : [normalized];
+            })
+            : undefined;
+        return {
+            ...(status(details['status']) === undefined ? {} : { status: status(details['status']) }),
+            ...(code(details['code']) === undefined ? {} : { code: code(details['code']) }),
+            ...(text(details['errno']) === undefined ? {} : { errno: text(details['errno']) }),
+            ...(text(details['body']) === undefined ? {} : { body: text(details['body']) }),
+            ...(causes === undefined || causes.length === 0 ? {} : { causes }),
+        };
+    }
+    return undefined;
+}
+/** Reads provider facts from the assistant-message diagnostic without trusting arbitrary nested error objects. */
+export function extractProviderFailureDetails(message) {
+    return providerFailureDetails(message);
+}

package/dist/core/runtime/bearings-render.js

@@ -57,8 +57,8 @@ function directoryListingLines(cwd) {
         return ['Directory listing: unavailable (cwd missing or unreadable).'];
     }
 }
-function runCommand(cwd, cmd, args) {
-    const result = spawnSync(cmd, args, { cwd, encoding: 'utf8' });
+function runCommand(cwd, cmd, args, env) {
+    const result = spawnSync(cmd, args, { cwd, encoding: 'utf8', ...(env === undefined ? {} : { env }) });
     if (result.error !== undefined) {
         return { ok: false, stdout: '', stderr: result.error.message };
     }
@@ -68,8 +68,17 @@ function runCommand(cwd, cmd, args) {
         stderr: (result.stderr ?? '').trim(),
     };
 }
+/** This snapshot renders on every node boot and every revive, which makes it the
+ *  most frequent git caller in the runtime — and boot is exactly when a process
+ *  gets killed. `git status` would take `.git/index.lock` to refresh the stat
+ *  cache; suppressing that optional lock keeps an interrupted render from
+ *  orphaning a lock that then blocks every writer in the user's checkout.
+ *  Only optional locks are affected, and the output is unchanged. */
+function gitEnv() {
+    return { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
+}
 function runGit(cwd, args) {
-    const result = runCommand(cwd, 'git', args);
+    const result = runCommand(cwd, 'git', args, gitEnv());
     return result.ok ? result.stdout : '';
 }
 function parseWorktrees(lines) {
@@ -98,7 +107,7 @@ function parseWorktrees(lines) {
  *  benign state. Every other probe here is genuinely optional and already
  *  falls back to 'unknown'/'HEAD'/a zero count on failure, which stays as-is. */
 function gitSnapshotLines(cwd) {
-    const probe = runCommand(cwd, 'git', ['rev-parse', '--is-inside-work-tree']);
+    const probe = runCommand(cwd, 'git', ['rev-parse', '--is-inside-work-tree'], gitEnv());
     if (!probe.ok) {
         if (/not a git repository/i.test(probe.stderr)) {
             return ['Git: not a git repository.'];

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'));