@herbertgao/pi-extensions 2026.9.19 → 2026.10.0

package/node_modules/{@herbertgao/resume-from → resume-from}/dist/import/discovery/contract.d.ts

@@ -33,26 +33,31 @@ export interface SelectionError {
     /** What failed, and what the user can do next. */
     message: string;
 }
-/** One home that could not be searched. The listing continues without it. */
+/** One home or session that could not be included. The listing continues without it. */
 export interface HomeFailure {
     home: HomePath;
     agent: AgentId;
-    /** Why the home was skipped, in one line. */
+    /** Why the home or session was skipped, in one line. */
     message: string;
 }
 /** What a listing produced, including what it could not read. */
 export interface Listing {
     /** Newest first, across every agent and home (FR-14, FR-15). */
     rows: SessionDescriptor[];
-    /** Homes that were skipped. Reported to the user, never silent. */
+    /** Homes or sessions that were skipped. Reported to the user, never silent. */
     failures: HomeFailure[];
 }
+/** Fresh destination facts resolved by the caller for this listing only. */
+export interface DiscoveryDestination {
+    canonicalCwd: string;
+    identity: RepoIdentity;
+}
 /** Finds, filters, orders and loads source sessions. It never writes. */
 export interface SessionFinder {
     /** Newest first (FR-14), only sessions of the current repository (FR-13). */
-    list(scope: SearchScope): Promise<Listing>;
+    list(scope: SearchScope, destination?: DiscoveryDestination): Promise<Listing>;
     /** Resolves a choice against the same ordering list() produced. Rejects with SelectionError. */
-    resolve(scope: SearchScope, input: SelectionInput): Promise<SessionDescriptor>;
+    resolve(scope: SearchScope, input: SelectionInput, destination?: DiscoveryDestination): Promise<SessionDescriptor>;
     /** Reads one session into the neutral vocabulary, through its source adapter. */
     load(descriptor: SessionDescriptor): Promise<CanonicalSession>;
 }

package/node_modules/{@herbertgao/resume-from → resume-from}/dist/import/discovery/finder.d.ts

@@ -1,4 +1,4 @@
-import type { ImportConfig, SessionFinder } from "./contract.js";
+import type { ImportConfig, RepoReader, SessionFinder } from "./contract.js";
 import { type SourceAdapter } from "./homes.js";
 export type { SourceAdapter };
 /** Everything the finder needs. The adapter list arrives from `src/import/`; it holds none. */
@@ -6,5 +6,6 @@ export interface DiscoveryDeps {
     adapters: readonly SourceAdapter[];
     /** Only `extraHomes` is read. */
     config: Pick<ImportConfig, "extraHomes">;
+    repo: Pick<RepoReader, "identify" | "checkCancellation">;
 }
 export declare function createSessionFinder(deps: DiscoveryDeps): SessionFinder;

package/node_modules/resume-from/dist/import/discovery/finder.js

@@ -0,0 +1,269 @@
+// The source side of the tool: find the sessions of this repository, order them, resolve the
+// user's choice, and load it. It never writes and never calls a model (NG-1, AC-4, FR-8).
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+import { SessionSelectionError } from "./errors.js";
+import { buildSearchList, canonicalPath, isDirectory, } from "./homes.js";
+import { compareDescriptors } from "./ordering.js";
+const NEXT_STEP = "Run the list again to see the sessions available in this repository.";
+function reasonLine(reason) {
+    const text = reason instanceof Error ? reason.message : String(reason);
+    return text.split("\n")[0] ?? "unknown error";
+}
+/** One recorded directory against this destination: the same directory, or the same repository. */
+function isMatch(evidence, destination) {
+    return (evidence.directory === destination?.directory ||
+        (evidence.commonDir !== null && evidence.commonDir === destination?.commonDir));
+}
+function isCancellation(reason) {
+    return reason instanceof Error && reason.name === "AbortError";
+}
+export function createSessionFinder(deps) {
+    async function collect(target, destination, lookup) {
+        deps.repo.checkCancellation();
+        // A home the user named must never fail silently: adapters swallow a missing
+        // directory (an absent default home is normal), but a typo'd --home is not (FR-2).
+        if (target.named === true && !(await isDirectory(target.home))) {
+            deps.repo.checkCancellation();
+            return {
+                rows: [],
+                failures: [
+                    {
+                        home: target.home,
+                        agent: target.agent,
+                        message: "home not searched: no such directory",
+                    },
+                ],
+            };
+        }
+        let found;
+        try {
+            deps.repo.checkCancellation();
+            found = await target.adapter.listSessions(target.home);
+            deps.repo.checkCancellation();
+        }
+        catch (reason) {
+            deps.repo.checkCancellation();
+            if (isCancellation(reason))
+                throw reason;
+            // One bad home never empties the listing.
+            return {
+                rows: [],
+                failures: [
+                    {
+                        home: target.home,
+                        agent: target.agent,
+                        message: `home not searched: ${reasonLine(reason)}`,
+                    },
+                ],
+            };
+        }
+        const rows = [];
+        const failures = [];
+        for (const descriptor of found) {
+            deps.repo.checkCancellation();
+            let diagnostic = null;
+            try {
+                let matched = false;
+                let conflictingGitIdentity = false;
+                let existing = false;
+                // Do not accept early: a later candidate can disprove the membership.
+                for (const candidate of descriptor.repoPaths) {
+                    const evidence = await lookup(candidate);
+                    if (evidence === null)
+                        continue;
+                    existing = true;
+                    matched ||= isMatch(evidence, destination);
+                    if (evidence.commonDir !== null) {
+                        conflictingGitIdentity ||= evidence.commonDir !== destination?.commonDir;
+                    }
+                }
+                // The primary decision (FR-13): a match includes, a conflict excludes, and a match never
+                // overrides a conflict.
+                const matchedHere = matched && !conflictingGitIdentity;
+                // The start directory is a last resort: it settles the case where no recorded candidate
+                // matched at all, and it never overrides a match or a conflict (issue #5).
+                const startDirectory = descriptor.startDirectory;
+                // A start directory that is already a recorded candidate adds nothing: the loop above looked
+                // it up with the same rule. Skipping it keeps the fallback from spending a second lookup on
+                // every session it cannot list (adapters whose header directory is their only candidate).
+                const startIsCandidate = startDirectory !== null && descriptor.repoPaths.includes(startDirectory);
+                const startEvidence = matchedHere || conflictingGitIdentity || startDirectory === null || startIsCandidate
+                    ? null
+                    : await lookup(startDirectory);
+                const startedHere = startEvidence !== null && isMatch(startEvidence, destination);
+                if (matchedHere || startedHere) {
+                    rows.push(descriptor);
+                }
+                else if (conflictingGitIdentity) {
+                    diagnostic =
+                        "has conflicting repository identity evidence; its recorded directories cannot unambiguously belong to this destination";
+                }
+                else if (descriptor.repoPaths.length === 0) {
+                    diagnostic = "records no repository, so it cannot be listed here";
+                }
+                else {
+                    diagnostic = existing
+                        ? "has unresolved recorded directories with no matching repository evidence"
+                        : "has only missing recorded directories; repository membership cannot be established";
+                }
+            }
+            catch (reason) {
+                deps.repo.checkCancellation();
+                if (isCancellation(reason))
+                    throw reason;
+                diagnostic = `repository lookup failed: ${reasonLine(reason)}`;
+            }
+            if (diagnostic !== null) {
+                failures.push({
+                    home: target.home,
+                    agent: target.agent,
+                    message: `session ${descriptor.ref.id} ${diagnostic}`,
+                });
+            }
+        }
+        return { rows, failures };
+    }
+    /** The single listing both `list` and `resolve` use, so the two always agree (FR-10). */
+    async function buildListing(scope, supplied) {
+        deps.repo.checkCancellation();
+        // Both caches live for this listing only. The spelling cache shares missing paths and
+        // filesystem failures; the canonical cache also shares Git lookups through symlink aliases.
+        const directories = new Map();
+        const identities = new Map();
+        const lookup = async (directory) => {
+            deps.repo.checkCancellation();
+            const absolute = resolve(directory);
+            let pending = directories.get(absolute);
+            if (!pending) {
+                pending = (async () => {
+                    let canonical;
+                    try {
+                        canonical = await realpath(absolute);
+                        deps.repo.checkCancellation();
+                    }
+                    catch (reason) {
+                        if (reason.code === "ENOENT") {
+                            // The reader still observes cancellation on missing-path short circuits.
+                            await deps.repo.identify(absolute);
+                            return null;
+                        }
+                        throw reason;
+                    }
+                    let identity = identities.get(canonical);
+                    if (!identity) {
+                        identity = Promise.resolve().then(() => deps.repo.identify(canonical));
+                        identities.set(canonical, identity);
+                    }
+                    return { directory: canonical, commonDir: (await identity).commonDir };
+                })();
+                directories.set(absolute, pending);
+            }
+            const evidence = await pending;
+            deps.repo.checkCancellation();
+            return evidence;
+        };
+        let destination;
+        try {
+            if (supplied !== undefined) {
+                const canonical = await realpath(scope.repoRoot);
+                deps.repo.checkCancellation();
+                if (canonical !== supplied.canonicalCwd) {
+                    throw new Error("Destination evidence does not match the requested directory");
+                }
+                identities.set(canonical, Promise.resolve(supplied.identity));
+                directories.set(resolve(scope.repoRoot), Promise.resolve({
+                    directory: canonical,
+                    commonDir: supplied.identity.commonDir,
+                }));
+            }
+            destination = await lookup(scope.repoRoot);
+        }
+        catch (reason) {
+            deps.repo.checkCancellation();
+            if (isCancellation(reason))
+                throw reason;
+            throw new Error(`Destination repository lookup failed: ${reasonLine(reason)}`, {
+                cause: reason,
+            });
+        }
+        const targets = await buildSearchList(deps.adapters, deps.config, scope);
+        deps.repo.checkCancellation();
+        const collected = await Promise.all(targets.map((target) => collect(target, destination, lookup)));
+        deps.repo.checkCancellation();
+        const rows = [];
+        const failures = [];
+        for (const part of collected) {
+            rows.push(...part.rows);
+            failures.push(...part.failures);
+        }
+        rows.sort(compareDescriptors);
+        return { rows, failures };
+    }
+    async function resolveRow(rows, row, diagnostics) {
+        const chosen = Number.isInteger(row) && row >= 1 ? rows[row - 1] : undefined;
+        if (!chosen) {
+            throw new SessionSelectionError(String(row), `Row ${row} is not in this repository's session list, which has ${rows.length} row(s). ${NEXT_STEP}${diagnostics}`);
+        }
+        return chosen;
+    }
+    return {
+        async list(scope, destination) {
+            return await buildListing(scope, destination);
+        },
+        async resolve(scope, input, destination) {
+            const { rows, failures } = await buildListing(scope, destination);
+            const diagnostics = failures.length === 0
+                ? ""
+                : ` Skipped: ${failures.map((failure) => `${failure.agent} at "${failure.home}": ${failure.message}`).join("; ")}.`;
+            switch (input.by) {
+                case "row":
+                    return await resolveRow(rows, input.row, diagnostics);
+                case "session-id": {
+                    const matches = rows.filter((row) => row.ref.id === input.id);
+                    const found = matches[0];
+                    if (!found) {
+                        throw new SessionSelectionError(input.id, `No session "${input.id}" belongs to this repository. ${NEXT_STEP}${diagnostics}`);
+                    }
+                    if (matches.length > 1) {
+                        const locations = matches
+                            .map((row) => `${row.ref.agent} at "${row.ref.home}" (${row.filePath})`)
+                            .join("; ");
+                        throw new SessionSelectionError(input.id, `Session ID "${input.id}" matches ${matches.length} sessions: ${locations}. ` +
+                            "Select a numbered row or exact file path, or narrow the search with an agent and --home.");
+                    }
+                    return found;
+                }
+                case "file-path": {
+                    const wanted = await canonicalPath(input.path);
+                    deps.repo.checkCancellation();
+                    for (const row of rows) {
+                        const filePath = await canonicalPath(row.filePath);
+                        deps.repo.checkCancellation();
+                        if (filePath === wanted)
+                            return row;
+                    }
+                    // Selection by path is a convenience, not a way around the repository filter (NG-9).
+                    throw new SessionSelectionError(input.path, `"${input.path}" is not a session of this repository. ${NEXT_STEP}${diagnostics}`);
+                }
+            }
+        },
+        async load(descriptor) {
+            deps.repo.checkCancellation();
+            const adapter = deps.adapters.find((candidate) => {
+                const capabilities = candidate.capabilities();
+                return capabilities.agent === descriptor.ref.agent && capabilities.roles.includes("source");
+            });
+            if (!adapter) {
+                throw new Error(`no source adapter for agent "${descriptor.ref.agent}"`);
+            }
+            // Returned unchanged: the rules of sections D and E belong to src/import/transfer/.
+            try {
+                return await adapter.loadSession(descriptor);
+            }
+            finally {
+                deps.repo.checkCancellation();
+            }
+        },
+    };
+}

package/node_modules/{@herbertgao/resume-from → resume-from}/dist/import/landing/contract.d.ts

@@ -1,5 +1,5 @@
-import type { AdapterRole, AgentAdapter, AgentCapabilities, AgentRuntime, LandingLevel, ProvenanceSupport, SelectionLevel, SerializedSession, StoredSessionFacts, SwitchOutcome, ValidationDefect } from "../../adapters/contract.js";
-export type { AdapterRole, AgentAdapter, AgentCapabilities, AgentRuntime, LandingLevel, ProvenanceSupport, SelectionLevel, SerializedSession, StoredSessionFacts, SwitchOutcome, ValidationDefect, };
+import type { AdapterRole, AgentAdapter, AgentCapabilities, AgentRuntime, LandingLevel, ProvenanceSupport, SelectionLevel, SerializationContext, SerializedSession, StoredSessionFacts, SwitchOutcome, ValidationDefect } from "../../adapters/contract.js";
+export type { AdapterRole, AgentAdapter, AgentCapabilities, AgentRuntime, LandingLevel, ProvenanceSupport, SelectionLevel, SerializationContext, SerializedSession, StoredSessionFacts, SwitchOutcome, ValidationDefect, };
 import type { DropReason, PinReason, TransferPlan, TurnDrop, TurnPin } from "../transfer/contract.js";
 export type { DropReason, PinReason, TransferPlan, TurnDrop, TurnPin };
 import type { Bytes, CommitError, CommitHandle, CommitRefusal, FileCommitter, PendingFile } from "../../platform/store/contract.js";
@@ -40,5 +40,5 @@ export interface SessionLander {
      * Runs after the user confirmed the preview (FR-20).
      * Rejects with a LandingError, leaving the target home unchanged.
      */
-    land(plan: TransferPlan, adapter: AgentAdapter, committer: FileCommitter, runtime: AgentRuntime, importedAt: string): Promise<LandingResult>;
+    land(plan: TransferPlan, adapter: AgentAdapter, committer: FileCommitter, runtime: AgentRuntime, importedAt: string, context: SerializationContext): Promise<LandingResult>;
 }

package/node_modules/{@herbertgao/resume-from → resume-from}/dist/import/landing/lander.js

@@ -39,7 +39,7 @@ function failAfterCommit(createdPaths, stage, what, home) {
         : `The committed paths were preserved because automatic removal could delete replacements. Inspect them before retrying: ${createdPaths.join(", ")}.`;
     return new LandingFailure(stage, `${what} ${preserved} ${RETRY}`);
 }
-async function runLanding(plan, adapter, committer, runtime, importedAt, buildCommand) {
+async function runLanding(plan, adapter, committer, runtime, importedAt, context, buildCommand) {
     const home = plan.target.home;
     const target = plan.target.agent;
     // Second gate: the preview should already have stopped this plan (FR-33).
@@ -56,7 +56,7 @@ async function runLanding(plan, adapter, committer, runtime, importedAt, buildCo
     };
     let serialized;
     try {
-        serialized = adapter.serialize(session, plan.target, marker);
+        serialized = adapter.serialize(session, plan.target, marker, context);
     }
     catch (cause) {
         throw new LandingFailure("serialize", `The ${target} adapter could not turn the plan into its own session format: ${reasonOf(cause)}. Nothing was written to ${home}. ${RETRY}`);
@@ -128,6 +128,6 @@ async function runLanding(plan, adapter, committer, runtime, importedAt, buildCo
 export function createSessionLander(options = {}) {
     const buildCommand = options.handoverCommand ?? describeSession;
     return {
-        land: (plan, adapter, committer, runtime, importedAt) => runLanding(plan, adapter, committer, runtime, importedAt, buildCommand),
+        land: (plan, adapter, committer, runtime, importedAt, context) => runLanding(plan, adapter, committer, runtime, importedAt, context, buildCommand),
     };
 }

package/node_modules/resume-from/dist/import/pipeline.d.ts

@@ -0,0 +1,28 @@
+import type { RepoIdentity } from "../platform/repo/contract.js";
+import type { AgentAdapter, FileCommitter, ImportConfig, ImportPipeline, PreviewBuilder, SessionDescriptor, SessionFinder, SessionLander, TokenEstimator, TransferRules } from "./contract.js";
+/** Fresh destination facts for one request; native spelling stays distinct from canonical identity. */
+export interface DestinationContext {
+    cwd: string;
+    canonicalCwd: string;
+    identity: RepoIdentity;
+}
+/** The four stages, and the services they are driven with. `wiring.ts` builds them. */
+export interface PipelineStages {
+    /** Observe the repository reader's cancellation even when no Git lookup is needed. */
+    checkCancellation(): void;
+    finder: SessionFinder;
+    rules: TransferRules;
+    /** Resolve fresh destination facts, without replacing the host's native cwd spelling. */
+    destinationFor(cwd: string): Promise<DestinationContext>;
+    /** A preview builder that reads the repository the request names. */
+    previewFor(destination: DestinationContext, descriptor: SessionDescriptor): PreviewBuilder;
+    lander: SessionLander;
+    /** Every adapter the composition root constructed. This module only looks one up. */
+    adapters: readonly AgentAdapter[];
+    config: ImportConfig;
+    estimator: TokenEstimator;
+    committer: FileCommitter;
+    /** ISO-8601 UTC. Only the landing reads it, so a preview and a commit agree (FR-47). */
+    now(): string;
+}
+export declare function createPipelineFromStages(stages: PipelineStages): ImportPipeline;

package/node_modules/{@herbertgao/resume-from → resume-from}/dist/import/pipeline.js

@@ -9,7 +9,7 @@ const PREVIEW_AGAIN = "Preview it again, then confirm.";
 const IMPORT_AGAIN = "Fix the cause, then run the import again.";
 function scopeOf(request) {
     return {
-        repoRoot: request.repoRoot,
+        repoRoot: request.destinationCwd,
         onlyAgent: request.onlyAgent,
         onlyHome: request.onlyHome,
     };
@@ -34,9 +34,21 @@ function isLandingError(cause) {
     return cause instanceof Error && "stage" in cause && "defects" in cause;
 }
 export function createPipelineFromStages(stages) {
-    async function resolve(request) {
+    async function destinationFor(cwd) {
         try {
-            return await stages.finder.resolve(scopeOf(request), request.selection);
+            const destination = await stages.destinationFor(cwd);
+            if (destination.identity.isBare) {
+                throw new Error("A bare repository cannot be an import destination. Run the import from a linked worktree instead.");
+            }
+            return destination;
+        }
+        catch (cause) {
+            throw new ImportFailure("preview", `The destination ${cwd} could not be used: ${reasonOf(cause)} Nothing was written. Check the destination directory and preview again.`, { cause });
+        }
+    }
+    async function resolve(request, destination) {
+        try {
+            return await stages.finder.resolve(scopeOf(request), request.selection, destination);
         }
         catch (cause) {
             throw new ImportFailure("discovery", `The session could not be chosen: ${reasonOf(cause)}`, {
@@ -58,7 +70,8 @@ export function createPipelineFromStages(stages) {
      * processes, and a plan cannot travel between them.
      */
     async function compute(request) {
-        const descriptor = await resolve(request);
+        const destination = await destinationFor(request.destinationCwd);
+        const descriptor = await resolve(request, destination);
         const session = await load(descriptor);
         let plan;
         try {
@@ -69,14 +82,19 @@ export function createPipelineFromStages(stages) {
         }
         let report;
         try {
-            report = await stages.previewFor(request.repoRoot).build(plan);
+            report = await stages.previewFor(destination, descriptor).build(plan);
+            stages.checkCancellation();
         }
         catch (cause) {
             throw new ImportFailure("preview", `The preview of session ${descriptor.ref.id} could not be built: ${reasonOf(cause)}. Nothing was written. ${IMPORT_AGAIN}`, { cause });
         }
-        const token = confirmationToken(descriptor, plan, report);
+        const token = confirmationToken(descriptor, plan, report, {
+            canonicalCwd: destination.canonicalCwd,
+            commonDir: destination.identity.commonDir,
+        });
         return {
             descriptor,
+            destination,
             plan,
             report: { ...report, confirmationToken: token },
         };
@@ -84,10 +102,11 @@ export function createPipelineFromStages(stages) {
     return {
         async list(request) {
             try {
-                return await stages.finder.list(scopeOf(request));
+                const destination = await destinationFor(request.destinationCwd);
+                return await stages.finder.list(scopeOf(request), destination);
             }
             catch (cause) {
-                throw new ImportFailure("discovery", `The sessions of this repository could not be listed: ${reasonOf(cause)}. Check that ${request.repoRoot} is readable, then run the list again.`, { cause });
+                throw new ImportFailure("discovery", `The sessions of this repository could not be listed: ${reasonOf(cause)}. Check that ${request.destinationCwd} is readable, then run the list again.`, { cause });
             }
         },
         async preview(request) {
@@ -99,9 +118,9 @@ export function createPipelineFromStages(stages) {
         },
         async commit(request, runtime, suppliedToken) {
             const adapter = targetAdapter(stages.adapters, request.target);
-            const { descriptor, plan, report } = await compute(request);
+            const { descriptor, destination, plan, report } = await compute(request);
             if (!confirmationMatches(report.confirmationToken, suppliedToken)) {
-                throw new ImportFailure("confirmation", `The source session or preview changed after confirmation. Nothing was written to ${request.target.home}. ${PREVIEW_AGAIN}`);
+                throw new ImportFailure("confirmation", `The source session, destination, or preview changed after confirmation. Nothing was written to ${request.target.home}. ${PREVIEW_AGAIN}`);
             }
             if (plan.blockedReason !== null) {
                 // blockedReason already ends in a sentence and carries the cause-specific
@@ -115,7 +134,8 @@ export function createPipelineFromStages(stages) {
                 throw new ImportFailure("source-changed", `The source session ${descriptor.ref.id} changed after the preview: ${descriptor.filePath} was last written at ${descriptor.updatedAt}, and the conversation the preview showed ends at ${plan.provenance.updatedAt}. Nothing was written. ${PREVIEW_AGAIN}`);
             }
             try {
-                return await stages.lander.land(plan, adapter, stages.committer, runtime, stages.now());
+                stages.checkCancellation();
+                return await stages.lander.land(plan, adapter, stages.committer, runtime, stages.now(), destination);
             }
             catch (cause) {
                 // The landing states what failed and what to do next for every one of its stages;

package/node_modules/{@herbertgao/resume-from → resume-from}/dist/import/preview/builder.d.ts

@@ -1,6 +1,6 @@
-import type { PreviewBuilder, RepoReader } from "./contract.js";
+import type { PreviewBuilder, RepoIdentity, RepoReader } from "./contract.js";
 /**
  * Builds the preview from a plan and the repository state read at the moment of the call.
  * It writes nothing (FR-16) and renders one shape for every direction (FR-21).
  */
-export declare function createPreviewBuilder(repo: RepoReader, cwd: string): PreviewBuilder;
+export declare function createPreviewBuilder(repo: RepoReader, cwd: string, canonicalCwd?: string, identity?: RepoIdentity, recordedDirectories?: readonly string[]): PreviewBuilder;

package/node_modules/{@herbertgao/resume-from → resume-from}/dist/import/preview/builder.js

@@ -1,17 +1,18 @@
 import { formatTokens, oneLine, plural } from "./format.js";
-import { planWarnings, repoWarning, sortWarnings } from "./warnings.js";
+import { directoryWarning, planWarnings, repoWarning, sortWarnings } from "./warnings.js";
 /** Paths are longer than titles and are not shortened to the same length. */
 const MAX_PATH_LENGTH = 160;
 const MAX_REASON_LENGTH = 200;
 const UNTITLED = "(untitled)";
 // Each blockedReason now carries its own cause-specific advice (FR-33, FR-56), so no
 // single fallback string is accurate for all block causes.
-function headerLines(plan) {
+function headerLines(plan, canonicalCwd) {
     const source = plan.provenance.ref;
     const title = oneLine(plan.provenance.title) || UNTITLED;
     return [
         `Source: ${source.agent} — ${title} (${oneLine(source.home, MAX_PATH_LENGTH)})`,
         `Target: ${plan.target.agent} (${oneLine(plan.target.home, MAX_PATH_LENGTH)})`,
+        `Destination: ${oneLine(canonicalCwd, Number.POSITIVE_INFINITY)}`,
         countLine(plan),
     ];
 }
@@ -44,15 +45,18 @@ function blockedLines(blockedReason) {
  * Builds the preview from a plan and the repository state read at the moment of the call.
  * It writes nothing (FR-16) and renders one shape for every direction (FR-21).
  */
-export function createPreviewBuilder(repo, cwd) {
+export function createPreviewBuilder(repo, cwd, canonicalCwd = cwd, identity, recordedDirectories = []) {
     return {
         async build(plan) {
             const collected = planWarnings(plan);
-            const fromRepo = await repoWarning(plan, repo, cwd);
+            const fromDirectory = await directoryWarning(recordedDirectories, canonicalCwd);
+            if (fromDirectory !== null)
+                collected.push(fromDirectory);
+            const fromRepo = await repoWarning(plan, repo, cwd, identity);
             if (fromRepo !== null)
                 collected.push(fromRepo);
             const warnings = sortWarnings(collected);
-            const header = headerLines(plan);
+            const header = headerLines(plan, canonicalCwd);
             const budgetLine = `Budget: ${formatTokens(plan.estimatedTokens)} tokens of a ${formatTokens(plan.target.windowTokens)} window`;
             const drops = dropLines(plan);
             const blocked = plan.blockedReason !== null;

package/node_modules/resume-from/dist/import/preview/warnings.d.ts

@@ -0,0 +1,14 @@
+import type { PreviewWarning, RepoIdentity, RepoReader, TransferPlan } from "./contract.js";
+/** Orders warnings by kind, keeping the order they were added within one kind. */
+export declare function sortWarnings(warnings: PreviewWarning[]): PreviewWarning[];
+/**
+ * Compares the source commit with the destination HEAD (FR-37, FR-38). Returned
+ * unresolved identities and unavailable commits produce non-blocking unknown-state
+ * warnings (FR-36, FR-39). Rejected operational lookups, including cancellation,
+ * propagate so the pipeline stops before any import write.
+ */
+export declare function repoWarning(plan: TransferPlan, repo: RepoReader, cwd: string, identified?: RepoIdentity): Promise<PreviewWarning | null>;
+/** Missing historical paths are neutral; only an existing canonical path proves a difference. */
+export declare function directoryWarning(recordedDirectories: readonly string[], canonicalCwd: string): Promise<PreviewWarning | null>;
+/** The warnings that come from the plan alone. */
+export declare function planWarnings(plan: TransferPlan): PreviewWarning[];

package/node_modules/{@herbertgao/resume-from → resume-from}/dist/import/preview/warnings.js

@@ -1,3 +1,4 @@
+import { realpath } from "node:fs/promises";
 import { formatTokens, plural, sameCommit, shortCommit } from "./format.js";
 /** Repository warnings sort first (FR-19); the rest follow this order. */
 const KIND_ORDER = ["repo-state", "budget", "broken-tail", "capability"];
@@ -22,26 +23,20 @@ function describeGap({ ahead, behind }) {
     return "";
 }
 /**
- * Compares the source commit with the current HEAD (FR-37, FR-38). A repository that
- * cannot be read, or a commit this tree does not have, is said to be unknown — never
- * guessed and never left out (FR-36). None of these block (FR-39).
+ * Compares the source commit with the destination HEAD (FR-37, FR-38). Returned
+ * unresolved identities and unavailable commits produce non-blocking unknown-state
+ * warnings (FR-36, FR-39). Rejected operational lookups, including cancellation,
+ * propagate so the pipeline stops before any import write.
  */
-export async function repoWarning(plan, repo, cwd) {
-    const unreadable = repoState(`${GLYPH} The repository state could not be read, so the source commit is ${NOT_KNOWN}.`);
-    let identity;
-    try {
-        identity = await repo.identify(cwd);
-    }
-    catch {
-        return unreadable;
-    }
+export async function repoWarning(plan, repo, cwd, identified) {
+    const identity = identified ?? (await repo.identify(cwd));
     const sourceCommit = plan.provenance.repo.commit;
     if (sourceCommit === null || sourceCommit.trim() === "") {
         return repoState(`${GLYPH} The source session did not record a commit, so the repository state is ${NOT_KNOWN}.`);
     }
     const source = shortCommit(sourceCommit);
     if (identity.root === null) {
-        return repoState(`${GLYPH} Source ran at ${source}. This directory is not a repository, so the repository state is ${NOT_KNOWN}.`);
+        return repoState(`${GLYPH} Source ran at ${source}. This directory's repository identity is unresolved, so the repository state is ${NOT_KNOWN}.`);
     }
     if (identity.head === null) {
         return repoState(`${GLYPH} Source ran at ${source}. This repository has no commit yet, so the repository state is ${NOT_KNOWN}.`);
@@ -49,18 +44,29 @@ export async function repoWarning(plan, repo, cwd) {
     if (sameCommit(sourceCommit, identity.head))
         return null;
     const head = shortCommit(identity.head);
-    let distance;
-    try {
-        distance = await repo.distanceFrom(sourceCommit);
-    }
-    catch {
-        return unreadable;
-    }
+    const distance = await repo.distanceFrom(cwd, sourceCommit);
     if (!distance.known) {
         return repoState(`${GLYPH} Source ran at ${source}, which is ${NOT_KNOWN}. The tree is now at ${head}.`);
     }
     return repoState(`${GLYPH} Source ran at ${source}. The tree is now at ${head}${describeGap(distance)}.`);
 }
+/** Missing historical paths are neutral; only an existing canonical path proves a difference. */
+export async function directoryWarning(recordedDirectories, canonicalCwd) {
+    let differs = false;
+    for (const directory of recordedDirectories) {
+        try {
+            if ((await realpath(directory)) !== canonicalCwd)
+                differs = true;
+        }
+        catch (cause) {
+            if (cause.code !== "ENOENT")
+                throw cause;
+        }
+    }
+    return differs
+        ? repoState(`${GLYPH} The source session records a different directory. Conversation import does not transfer uncommitted work, switch branches, or recreate removed worktrees.`)
+        : null;
+}
 /** The warnings that come from the plan alone. */
 export function planWarnings(plan) {
     const warnings = [];