@herbertgao/pi-extensions 2026.8.8 → 2026.8.10

package/node_modules/resume-from/dist/import/discovery/contract.d.ts

@@ -0,0 +1,58 @@
+import type { AdapterRole, AgentAdapter, AgentCapabilities, LandingLevel, ProvenanceSupport, SelectionLevel } from "../../adapters/contract.js";
+export type { AdapterRole, AgentAdapter, AgentCapabilities, LandingLevel, ProvenanceSupport, SelectionLevel, };
+import type { HomeEntry, ImportConfig } from "../../platform/config/contract.js";
+export type { HomeEntry, ImportConfig };
+import type { RepoIdentity, RepoReader } from "../../platform/repo/contract.js";
+export type { RepoIdentity, RepoReader };
+import type { AgentId, CanonicalSession, CanonicalTurn, HomePath, RepoSnapshot, SessionDescriptor, SessionId, SessionRef, SourceProvenance, ToolCallRecord, ToolEffect, TurnKind, TurnRole } from "../../session/contract.js";
+export type { AgentId, CanonicalSession, CanonicalTurn, HomePath, RepoSnapshot, SessionDescriptor, SessionId, SessionRef, SourceProvenance, ToolCallRecord, ToolEffect, TurnKind, TurnRole, };
+/** How the user named the session to import (FR-12). */
+export type SelectionInput = {
+    by: "row";
+    row: number;
+} | {
+    by: "session-id";
+    id: SessionId;
+} | {
+    by: "file-path";
+    path: string;
+};
+/** Which homes to search (FR-2, FR-5, FR-13, FR-15). */
+export interface SearchScope {
+    /** Absolute path of the repository the listing is filtered to (FR-13). */
+    repoRoot: string;
+    /** When set, only this agent is searched (FR-15). */
+    onlyAgent: AgentId | null;
+    /** When set, only this home is searched (FR-2). */
+    onlyHome: HomePath | null;
+}
+/** Why a selection could not be resolved (FR-56). */
+export interface SelectionError {
+    /** What the user gave: the row, the session ID, or the path. */
+    input: string;
+    /** What failed, and what the user can do next. */
+    message: string;
+}
+/** One home that could not be searched. The listing continues without it. */
+export interface HomeFailure {
+    home: HomePath;
+    agent: AgentId;
+    /** Why the home 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. */
+    failures: HomeFailure[];
+}
+/** 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>;
+    /** Resolves a choice against the same ordering list() produced. Rejects with SelectionError. */
+    resolve(scope: SearchScope, input: SelectionInput): Promise<SessionDescriptor>;
+    /** Reads one session into the neutral vocabulary, through its source adapter. */
+    load(descriptor: SessionDescriptor): Promise<CanonicalSession>;
+}

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

@@ -0,0 +1,4 @@
+// GENERATED from src/import/discovery/module.md — the Public Contract section is the normative home.
+// Declarations only: no behaviour, no defaults. If this file and module.md disagree,
+// the document wins and this file is corrected.
+export {};

package/node_modules/resume-from/dist/import/discovery/errors.d.ts

@@ -0,0 +1,9 @@
+import type { SelectionError } from "./contract.js";
+/**
+ * What `resolve` rejects with. It is an `Error` so a stack survives, and a `SelectionError`
+ * so the host can print what the user gave and what to do next (FR-56).
+ */
+export declare class SessionSelectionError extends Error implements SelectionError {
+    readonly input: string;
+    constructor(input: string, message: string);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * What `resolve` rejects with. It is an `Error` so a stack survives, and a `SelectionError`
+ * so the host can print what the user gave and what to do next (FR-56).
+ */
+export class SessionSelectionError extends Error {
+    input;
+    constructor(input, message) {
+        super(message);
+        this.name = "SessionSelectionError";
+        this.input = input;
+    }
+}

package/node_modules/resume-from/dist/import/discovery/finder.d.ts

@@ -0,0 +1,10 @@
+import type { ImportConfig, 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. */
+export interface DiscoveryDeps {
+    adapters: readonly SourceAdapter[];
+    /** Only `extraHomes` is read. */
+    config: Pick<ImportConfig, "extraHomes">;
+}
+export declare function createSessionFinder(deps: DiscoveryDeps): SessionFinder;

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

@@ -0,0 +1,129 @@
+// 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 { 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";
+}
+export function createSessionFinder(deps) {
+    async function collect(target, repoRoot) {
+        // 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))) {
+            return {
+                rows: [],
+                failures: [
+                    {
+                        home: target.home,
+                        agent: target.agent,
+                        message: "home not searched: no such directory",
+                    },
+                ],
+            };
+        }
+        let found;
+        try {
+            found = await target.adapter.listSessions(target.home);
+        }
+        catch (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) {
+            if (descriptor.repoPath === null) {
+                // Out of scope, but never silent: the tool cannot show that it belongs here.
+                failures.push({
+                    home: target.home,
+                    agent: target.agent,
+                    message: `session ${descriptor.ref.id} records no repository, so it cannot be listed here`,
+                });
+                continue;
+            }
+            if ((await canonicalPath(descriptor.repoPath)) === repoRoot)
+                rows.push(descriptor); // FR-13
+        }
+        return { rows, failures };
+    }
+    /** The single listing both `list` and `resolve` use, so the two always agree (FR-10). */
+    async function buildListing(scope) {
+        const targets = await buildSearchList(deps.adapters, deps.config, scope);
+        const repoRoot = await canonicalPath(scope.repoRoot);
+        const collected = await Promise.all(targets.map((target) => collect(target, repoRoot)));
+        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) {
+        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}`);
+        }
+        return chosen;
+    }
+    return {
+        async list(scope) {
+            return await buildListing(scope);
+        },
+        async resolve(scope, input) {
+            const { rows } = await buildListing(scope);
+            switch (input.by) {
+                case "row":
+                    return await resolveRow(rows, input.row);
+                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}`);
+                    }
+                    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);
+                    for (const row of rows) {
+                        if ((await canonicalPath(row.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}`);
+                }
+            }
+        },
+        async load(descriptor) {
+            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/.
+            return await adapter.loadSession(descriptor);
+        },
+    };
+}

package/node_modules/resume-from/dist/import/discovery/homes.d.ts

@@ -0,0 +1,23 @@
+import type { AgentAdapter, AgentId, HomePath, ImportConfig, SearchScope } from "./contract.js";
+/**
+ * The source-role subset of `AgentAdapter` this module uses. The target-role methods
+ * exist on the port but are never called here (module.md, Public Contract).
+ */
+export type SourceAdapter = Pick<AgentAdapter, "capabilities" | "listSessions" | "loadSession">;
+/** One home to search, with the adapter that can read it. */
+export interface SearchTarget {
+    agent: AgentId;
+    /** Resolved absolute path. */
+    home: HomePath;
+    adapter: SourceAdapter;
+    /** Set when the user named this home and no configuration lists it (FR-2). */
+    named?: boolean;
+}
+/** True when the path exists and is a directory. Symlinks are followed. */
+export declare function isDirectory(target: string): Promise<boolean>;
+/** Expands a leading `~` and makes the path absolute. */
+export declare function expandHome(value: string): string;
+/** Absolute path with symlinks resolved. A path that does not exist keeps its expanded form. */
+export declare function canonicalPath(value: string): Promise<string>;
+/** Every source adapter's default home (FR-3), plus every configured extra home (FR-5). */
+export declare function buildSearchList(adapters: readonly SourceAdapter[], config: Pick<ImportConfig, "extraHomes">, scope: SearchScope): Promise<SearchTarget[]>;

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

@@ -0,0 +1,83 @@
+// Which homes are searched, and in what form. A home reached twice is searched once,
+// and two spellings of the same directory are one home.
+import { realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+/** True when the path exists and is a directory. Symlinks are followed. */
+export async function isDirectory(target) {
+    try {
+        return (await stat(target)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Expands a leading `~` and makes the path absolute. */
+export function expandHome(value) {
+    if (value === "~")
+        return homedir();
+    if (value.startsWith("~/") || value.startsWith(`~${path.sep}`)) {
+        return path.resolve(homedir(), value.slice(2));
+    }
+    return path.resolve(value);
+}
+/** Absolute path with symlinks resolved. A path that does not exist keeps its expanded form. */
+export async function canonicalPath(value) {
+    const expanded = expandHome(value);
+    try {
+        return await realpath(expanded);
+    }
+    catch {
+        return expanded;
+    }
+}
+/** Every source adapter's default home (FR-3), plus every configured extra home (FR-5). */
+export async function buildSearchList(adapters, config, scope) {
+    const sources = new Map();
+    const candidates = [];
+    for (const adapter of adapters) {
+        const capabilities = adapter.capabilities();
+        if (!capabilities.roles.includes("source"))
+            continue; // FR-59
+        if (sources.has(capabilities.agent))
+            continue;
+        sources.set(capabilities.agent, adapter);
+        candidates.push({
+            agent: capabilities.agent,
+            home: capabilities.defaultHome,
+            adapter,
+        });
+    }
+    for (const entry of config.extraHomes) {
+        const adapter = sources.get(entry.agent);
+        if (!adapter)
+            continue; // no source adapter for that agent: nothing could read the home
+        candidates.push({ agent: entry.agent, home: entry.home, adapter });
+    }
+    const onlyHome = scope.onlyHome === null ? null : await canonicalPath(scope.onlyHome);
+    const seen = new Set();
+    const targets = [];
+    for (const candidate of candidates) {
+        if (scope.onlyAgent !== null && candidate.agent !== scope.onlyAgent)
+            continue; // FR-15
+        const home = await canonicalPath(candidate.home);
+        if (onlyHome !== null && home !== onlyHome)
+            continue; // FR-2
+        const key = `${candidate.agent}\u0000${home}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        targets.push({ agent: candidate.agent, home, adapter: candidate.adapter });
+    }
+    // FR-2 names a home, not a filter: a home outside the defaults and extraHomes would
+    // otherwise silently empty the list. Every source adapter (narrowed by FR-15) searches
+    // it; an adapter whose layout is absent there simply finds no sessions.
+    if (onlyHome !== null && targets.length === 0) {
+        for (const [agent, adapter] of sources) {
+            if (scope.onlyAgent !== null && agent !== scope.onlyAgent)
+                continue;
+            targets.push({ agent, home: onlyHome, adapter, named: true });
+        }
+    }
+    return targets;
+}

package/node_modules/resume-from/dist/import/discovery/index.d.ts

@@ -0,0 +1,2 @@
+export { SessionSelectionError } from "./errors.js";
+export { createSessionFinder, type DiscoveryDeps, type SourceAdapter } from "./finder.js";

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

@@ -0,0 +1,2 @@
+export { SessionSelectionError } from "./errors.js";
+export { createSessionFinder } from "./finder.js";

package/node_modules/resume-from/dist/import/discovery/ordering.d.ts

@@ -0,0 +1,3 @@
+import type { SessionDescriptor } from "./contract.js";
+/** Newest first across every agent and home (FR-14, FR-15); ties broken by `SessionRef`. */
+export declare function compareDescriptors(a: SessionDescriptor, b: SessionDescriptor): number;

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

@@ -0,0 +1,21 @@
+// The listing order. It is a total order, because FR-10 lets the user see the rows in one
+// invocation and name row 3 in the next one.
+/** An unreadable timestamp sorts last rather than making the comparison unstable. */
+function timeOf(iso) {
+    const parsed = Date.parse(iso);
+    return Number.isNaN(parsed) ? Number.NEGATIVE_INFINITY : parsed;
+}
+function compareText(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareRef(a, b) {
+    return compareText(a.agent, b.agent) || compareText(a.home, b.home) || compareText(a.id, b.id);
+}
+/** Newest first across every agent and home (FR-14, FR-15); ties broken by `SessionRef`. */
+export function compareDescriptors(a, b) {
+    const left = timeOf(a.updatedAt);
+    const right = timeOf(b.updatedAt);
+    if (left !== right)
+        return right > left ? 1 : -1;
+    return compareRef(a.ref, b.ref);
+}

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

@@ -0,0 +1,22 @@
+import type { ValidationDefect } from "./contract.js";
+/**
+ * Which part of the import failed. One shape for every host, whatever stage raised it
+ * (FR-56): a discovery failure, a blocked plan and a landing failure are all this.
+ */
+export type ImportStage = "target" | "discovery" | "plan" | "preview" | "blocked" | "confirmation" | "source-changed" | "landing";
+export interface ImportFailureDetail {
+    defects?: ValidationDefect[];
+    cause?: unknown;
+}
+/**
+ * What every operation of the pipeline rejects with. It is an `Error` so a host that only
+ * prints the throwable still shows what failed and what to do next (FR-56).
+ */
+export declare class ImportFailure extends Error {
+    readonly stage: ImportStage;
+    /** The structural defects, when a target adapter refused the new session (FR-50). */
+    readonly defects: ValidationDefect[];
+    constructor(stage: ImportStage, message: string, detail?: ImportFailureDetail);
+}
+/** The first line of whatever a stage threw. Never the raw throwable (FR-56). */
+export declare function reasonOf(cause: unknown): string;

package/node_modules/resume-from/dist/import/errors.js

@@ -0,0 +1,20 @@
+/**
+ * What every operation of the pipeline rejects with. It is an `Error` so a host that only
+ * prints the throwable still shows what failed and what to do next (FR-56).
+ */
+export class ImportFailure extends Error {
+    stage;
+    /** The structural defects, when a target adapter refused the new session (FR-50). */
+    defects;
+    constructor(stage, message, detail = {}) {
+        super(message, detail.cause === undefined ? undefined : { cause: detail.cause });
+        this.name = "ImportFailure";
+        this.stage = stage;
+        this.defects = detail.defects ?? [];
+    }
+}
+/** The first line of whatever a stage threw. Never the raw throwable (FR-56). */
+export function reasonOf(cause) {
+    const text = cause instanceof Error ? cause.message : String(cause);
+    return text.split("\n")[0] ?? "unknown error";
+}

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

@@ -0,0 +1,3 @@
+export type { AgentAdapter, AgentId, AgentRuntime, HandoverInstruction, HomeFailure, HomePath, ImportPipeline, ImportRequest, LandingResult, Listing, ListRequest, PreviewReport, PreviewWarning, SelectionInput, SessionDescriptor, SessionId, SessionRef, TargetProfile, WarningKind, } from "./contract.js";
+export { ImportFailure, type ImportStage } from "./errors.js";
+export { createImportPipeline, type ImportPipelineDeps } from "./wiring.js";

package/node_modules/resume-from/dist/import/index.js

@@ -0,0 +1,5 @@
+// The import pipeline: list, preview, commit. A host drives these three calls and nothing
+// deeper — the four stages behind them are this module's internal design, and none of them
+// is exported, so no host can land a session it did not preview.
+export { ImportFailure } from "./errors.js";
+export { createImportPipeline } from "./wiring.js";

package/node_modules/resume-from/dist/import/landing/contract.d.ts

@@ -0,0 +1,44 @@
+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 { 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";
+export type { Bytes, CommitError, CommitHandle, CommitRefusal, FileCommitter, PendingFile };
+import type { AgentId, CanonicalSession, CanonicalTurn, HomePath, ProvenanceMarker, RepoSnapshot, SessionId, SessionRef, SourceProvenance, TargetProfile, ToolCallRecord, ToolEffect, TurnKind, TurnRole } from "../../session/contract.js";
+export type { AgentId, CanonicalSession, CanonicalTurn, HomePath, ProvenanceMarker, RepoSnapshot, SessionId, SessionRef, SourceProvenance, TargetProfile, ToolCallRecord, ToolEffect, TurnKind, TurnRole, };
+/** What the user must do next when the adapter cannot switch (FR-45). */
+export interface HandoverInstruction {
+    sessionId: SessionId;
+    /** The native command that opens the new session, for example "claude --resume <id>". */
+    command: string;
+}
+/** What the landing produced (FR-40 to FR-47, FR-52). */
+export interface LandingResult {
+    ref: SessionRef;
+    switched: boolean;
+    /** Set when the adapter could only create (FR-43, FR-45). */
+    handover: HandoverInstruction | null;
+    itemsSent: number;
+    itemsStored: number;
+    marker: ProvenanceMarker;
+}
+/** Which step of the landing failed (FR-56). */
+export type LandingStage = "serialize" | "validate" | "commit" | "read-back" | "switch";
+/** A landing that failed. Nothing remains in the target home (FR-53). */
+export interface LandingError {
+    stage: LandingStage;
+    /** What failed, and what the user can do next (FR-56). */
+    message: string;
+    /** The structural defects, when the stage is "validate" (FR-50). */
+    defects: ValidationDefect[];
+    /** True when a commit was made and then undone. */
+    rolledBack: boolean;
+}
+/** Places a plan in the target home. Adds only, all or nothing (FR-49, FR-53). */
+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>;
+}

package/node_modules/resume-from/dist/import/landing/contract.js

@@ -0,0 +1,4 @@
+// GENERATED from src/import/landing/module.md — the Public Contract section is the normative home.
+// Declarations only: no behaviour, no defaults. If this file and module.md disagree,
+// the document wins and this file is corrected.
+export {};

package/node_modules/resume-from/dist/import/landing/errors.d.ts

@@ -0,0 +1,15 @@
+import type { LandingError, LandingStage, ValidationDefect } from "./contract.js";
+interface FailureDetail {
+    defects?: ValidationDefect[];
+}
+/**
+ * The rejection value of `land`. It is an Error so a host that only logs the
+ * throwable still shows the stage and the next step (FR-56).
+ */
+export declare class LandingFailure extends Error implements LandingError {
+    readonly stage: LandingStage;
+    readonly defects: ValidationDefect[];
+    readonly rolledBack = false;
+    constructor(stage: LandingStage, message: string, detail?: FailureDetail);
+}
+export {};

package/node_modules/resume-from/dist/import/landing/errors.js

@@ -0,0 +1,15 @@
+/**
+ * The rejection value of `land`. It is an Error so a host that only logs the
+ * throwable still shows the stage and the next step (FR-56).
+ */
+export class LandingFailure extends Error {
+    stage;
+    defects;
+    rolledBack = false;
+    constructor(stage, message, detail = {}) {
+        super(message);
+        this.name = "LandingFailure";
+        this.stage = stage;
+        this.defects = detail.defects ?? [];
+    }
+}

package/node_modules/resume-from/dist/import/landing/handover.d.ts

@@ -0,0 +1,5 @@
+import type { AgentId, HandoverInstruction, SessionId } from "./contract.js";
+/** Renders the native command that opens a landed session (FR-45). */
+export type HandoverCommandBuilder = (agent: AgentId, sessionId: SessionId) => string;
+export declare const describeSession: HandoverCommandBuilder;
+export declare function buildHandover(build: HandoverCommandBuilder, agent: AgentId, sessionId: SessionId): HandoverInstruction;

package/node_modules/resume-from/dist/import/landing/handover.js

@@ -0,0 +1,12 @@
+/*
+ * Ceiling: no contract restated by this module carries an agent's own resume
+ * command — neither AgentCapabilities nor the target half of AgentAdapter — and
+ * this module must never name an agent (FR-60). The default therefore names the
+ * session and the agent instead of printing a command that would not run. The
+ * host injects the real one. Upgrade trigger: when the adapter contract carries
+ * a resume-command template, this default and the injection point are deleted.
+ */
+export const describeSession = (agent, sessionId) => `open session ${sessionId} with ${agent}`;
+export function buildHandover(build, agent, sessionId) {
+    return { sessionId, command: build(agent, sessionId) };
+}

package/node_modules/resume-from/dist/import/landing/index.d.ts

@@ -0,0 +1,4 @@
+export { LandingFailure } from "./errors.js";
+export { buildHandover, describeSession, type HandoverCommandBuilder } from "./handover.js";
+export { createSessionLander, type SessionLanderOptions } from "./lander.js";
+export { buildMarker, summariseDrops } from "./marker.js";

package/node_modules/resume-from/dist/import/landing/index.js

@@ -0,0 +1,4 @@
+export { LandingFailure } from "./errors.js";
+export { buildHandover, describeSession } from "./handover.js";
+export { createSessionLander } from "./lander.js";
+export { buildMarker, summariseDrops } from "./marker.js";

package/node_modules/resume-from/dist/import/landing/lander.d.ts

@@ -0,0 +1,7 @@
+import type { SessionLander } from "./contract.js";
+import { type HandoverCommandBuilder } from "./handover.js";
+export interface SessionLanderOptions {
+    /** Overrides the placeholder resume command. See handover.ts for the ceiling. */
+    handoverCommand?: HandoverCommandBuilder;
+}
+export declare function createSessionLander(options?: SessionLanderOptions): SessionLander;