@herbertgao/pi-extensions 2026.8.8 → 2026.8.10

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

@@ -0,0 +1,48 @@
+import type { ImportConfig } from "../../platform/config/contract.js";
+export type { ImportConfig };
+import type { TokenEstimator } from "../../platform/tokens/contract.js";
+export type { TokenEstimator };
+import type { AgentId, CanonicalSession, CanonicalTurn, HomePath, RepoSnapshot, SessionId, SessionRef, SourceProvenance, TargetProfile, ToolCallRecord, ToolEffect, TurnKind, TurnRole } from "../../session/contract.js";
+export type { AgentId, CanonicalSession, CanonicalTurn, HomePath, RepoSnapshot, SessionId, SessionRef, SourceProvenance, TargetProfile, ToolCallRecord, ToolEffect, TurnKind, TurnRole, };
+/** Why a turn did not cross over (FR-31, FR-54). */
+export type DropReason = "budget" | "broken-tail";
+/** Why a turn is kept whatever the budget says (FR-32). */
+export type PinReason = "first-request" | "recent-turn" | "summary" | "changed-files";
+/** One turn the rules removed. */
+export interface TurnDrop {
+    /** The turn's index in the source session. */
+    index: number;
+    reason: DropReason;
+}
+/** One turn the rules protected. */
+export interface TurnPin {
+    /** The turn's index in the source session. */
+    index: number;
+    reason: PinReason;
+}
+/** The result of applying requirement sections D and E to one source session. */
+export interface TransferPlan {
+    target: TargetProfile;
+    /** The source metadata, unchanged. */
+    provenance: SourceProvenance;
+    /** Only the turns that cross over, in source order. */
+    turns: CanonicalTurn[];
+    pins: TurnPin[];
+    drops: TurnDrop[];
+    keptTurnCount: number;
+    droppedTurnCount: number;
+    /** Tool result bodies the rules removed (FR-24, FR-25). */
+    bodiesDropped: number;
+    /** Estimated cost of the kept turns, in tokens. */
+    estimatedTokens: number;
+    /** budgetShare multiplied by the target window, rounded down (FR-29, FR-30). */
+    budgetTokens: number;
+    /** True when an incomplete trailing tool call was removed (FR-54, FR-55). */
+    brokenTailDropped: boolean;
+    /** Set when the pinned content alone exceeds the budget. The import cannot run (FR-33). */
+    blockedReason: string | null;
+}
+/** Applies requirement sections D and E. Pure: the same input always gives the same plan. */
+export interface TransferRules {
+    apply(session: CanonicalSession, target: TargetProfile, config: ImportConfig, estimator: TokenEstimator): TransferPlan;
+}

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

@@ -0,0 +1,4 @@
+// GENERATED from src/import/transfer/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/transfer/index.d.ts

@@ -0,0 +1,2 @@
+export type { DropReason, PinReason, TransferPlan, TransferRules, TurnDrop, TurnPin, } from "./contract.js";
+export { createTransferRules } from "./rules.js";

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

@@ -0,0 +1 @@
+export { createTransferRules } from "./rules.js";

package/node_modules/resume-from/dist/import/transfer/rules.d.ts

@@ -0,0 +1,3 @@
+import type { TransferRules } from "./contract.js";
+/** The rules hold no state, so every instance behaves identically (T-TRA-19). */
+export declare function createTransferRules(): TransferRules;

package/node_modules/resume-from/dist/import/transfer/rules.js

@@ -0,0 +1,228 @@
+// Requirement sections D and E, as executable rules. Pure: no clock, no filesystem,
+// no network, no randomness — the preview and the commit of one request must agree.
+/** FR-25. The record ends with this, so the target model reads that the body is gone. */
+const DROPPED_BODY_MARKER = "(content dropped: imported session, may be stale)";
+/** FR-23. One line, in words, when the source recorded no outcome at all. */
+const NO_OUTCOME_RECORDED = "(outcome not recorded by the source)";
+/** FR-33. The one advice sentence every budget-driven block ends with. */
+const BUDGET_ADVICE = "Raise budgetShare, lower pinnedRecentTurns, or choose a target with a larger window.";
+/** Role/kind delimiters and message framing that target serializers add around every turn. */
+const TURN_FRAMING_TOKENS = 4;
+/** The order pins are reported in when one turn is pinned for more than one reason. */
+const PIN_ORDER = [
+    "first-request",
+    "recent-turn",
+    "summary",
+    "changed-files",
+];
+/** FR-23: one line about the outcome. Line breaks and blank lines collapse to single spaces. */
+function toSingleLine(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line !== "")
+        .join(" ");
+}
+function normalizeRecord(record) {
+    const outcome = toSingleLine(record.outcomeLine);
+    const stated = outcome === "" ? NO_OUTCOME_RECORDED : outcome;
+    return {
+        toolName: record.toolName,
+        argumentsText: record.argumentsText,
+        // Append only when the adapter did not already embed it (Pi, Claude Code embed it;
+        // Codex does not). toSingleLine runs first so trailing whitespace cannot defeat endsWith.
+        outcomeLine: record.bodyDropped && !stated.endsWith(DROPPED_BODY_MARKER)
+            ? `${stated} ${DROPPED_BODY_MARKER}`
+            : stated,
+        effect: record.effect,
+        bodyDropped: record.bodyDropped,
+        ...(record.resultRecorded !== undefined ? { resultRecorded: record.resultRecorded } : {}),
+    };
+}
+/**
+ * Rebuilt field by field, never copied by reference or spread: a field the canonical
+ * vocabulary has no room for — hidden reasoning, a system prompt, an environment block,
+ * telemetry, vendor state, a smuggled result body — must not survive into the plan (FR-28).
+ */
+function normalizeTurn(turn) {
+    return {
+        index: turn.index,
+        role: turn.role,
+        kind: turn.kind,
+        text: turn.text,
+        toolCall: turn.toolCall ? normalizeRecord(turn.toolCall) : null,
+        timestamp: turn.timestamp,
+    };
+}
+/** FR-54: a tool call the source never recorded a result for. */
+function isUnansweredCall(turn) {
+    if (turn?.kind !== "tool-call")
+        return false;
+    // Check resultRecorded directly; outcomeLine is always non-empty (adapters fill it with a
+    // fallback text), so an outcomeLine=="" check would be dead and never catch real broken tails.
+    //
+    // Use === false, not !resultRecorded: an absent flag (undefined) means "unknown, treat as
+    // recorded" — construction sites outside this module may omit the field (e.g. test fixtures),
+    // and we must not silently break tails that were never broken. Only an explicit false fires. (FR-54)
+    return !turn.toolCall || turn.toolCall.resultRecorded === false;
+}
+/** Adapters understand their native tool schema; this layer only normalizes their path list. */
+function dedupeChangedPaths(recorded) {
+    const paths = [];
+    const seen = new Set();
+    for (const path of recorded) {
+        if (path !== "" && !seen.has(path)) {
+            seen.add(path);
+            paths.push(path);
+        }
+    }
+    return paths;
+}
+/** FR-32. A turn can be pinned for more than one reason; every reason is reported. */
+function computePins(turns, pinnedRecentTurns) {
+    const reasons = new Map();
+    const pin = (index, reason) => {
+        const existing = reasons.get(index);
+        if (existing)
+            existing.add(reason);
+        else
+            reasons.set(index, new Set([reason]));
+    };
+    const firstRequest = turns.find((turn) => turn.role === "user" && turn.kind === "message");
+    if (firstRequest)
+        pin(firstRequest.index, "first-request");
+    const recent = Math.min(Math.max(0, Math.trunc(pinnedRecentTurns)), turns.length);
+    for (const turn of turns.slice(turns.length - recent))
+        pin(turn.index, "recent-turn");
+    for (const turn of turns) {
+        if (turn.kind === "summary")
+            pin(turn.index, "summary");
+        if (turn.toolCall?.effect === "mutating")
+            pin(turn.index, "changed-files");
+    }
+    const pins = [];
+    for (const turn of turns) {
+        const set = reasons.get(turn.index);
+        if (!set)
+            continue;
+        reasons.delete(turn.index);
+        for (const reason of PIN_ORDER) {
+            if (set.has(reason))
+                pins.push({ index: turn.index, reason });
+        }
+    }
+    return pins;
+}
+/** The cost of what actually ships for this turn: its text, or its record's three fields. */
+function turnCost(turn, estimator) {
+    const record = turn.toolCall;
+    const text = record
+        ? `${turn.text}\n${record.toolName}\n${record.argumentsText}\n${record.outcomeLine}`
+        : turn.text;
+    return estimator.estimate(text) + TURN_FRAMING_TOKENS;
+}
+function copyProvenance(provenance, changedPaths) {
+    return {
+        ref: {
+            agent: provenance.ref.agent,
+            home: provenance.ref.home,
+            id: provenance.ref.id,
+        },
+        title: provenance.title,
+        startedAt: provenance.startedAt,
+        updatedAt: provenance.updatedAt,
+        repo: {
+            commit: provenance.repo.commit,
+            branch: provenance.repo.branch,
+            changedPaths,
+        },
+    };
+}
+function apply(session, target, config, estimator) {
+    const source = session.turns;
+    const drops = [];
+    // 1. Drop the broken tail (FR-54, FR-55): every consecutive trailing call the source never
+    // answered — an interrupted parallel tool batch leaves several unanswered calls, not one.
+    let cut = source.length;
+    while (cut > 0 && isUnansweredCall(source[cut - 1])) {
+        const turn = source[cut - 1];
+        if (turn)
+            drops.push({ index: turn.index, reason: "broken-tail" });
+        cut -= 1;
+    }
+    const brokenTailDropped = cut < source.length;
+    // 2. Select content (FR-22 to FR-28). The record shape is what enforces FR-24.
+    const selected = source.slice(0, cut).map(normalizeTurn);
+    // 3. Compute the budget (FR-29, FR-30).
+    const budgetTokens = Math.floor(config.budgetShare * target.windowTokens);
+    // 4. Pin (FR-32).
+    const pins = computePins(selected, config.pinnedRecentTurns);
+    const pinned = new Set(pins.map((entry) => entry.index));
+    const costs = selected.map((turn) => turnCost(turn, estimator));
+    let estimatedTokens = 0;
+    let pinnedTokens = 0;
+    for (const [position, turn] of selected.entries()) {
+        const cost = costs[position] ?? 0;
+        estimatedTokens += cost;
+        if (pinned.has(turn.index))
+            pinnedTokens += cost;
+    }
+    // 5. Stop if the pinned content alone exceeds the budget (FR-33).
+    let blockedReason = null;
+    const kept = selected.map(() => true);
+    if (pinnedTokens > budgetTokens) {
+        blockedReason =
+            `Pinned content needs ${pinnedTokens} tokens but the budget is ${budgetTokens} tokens ` +
+                `(budgetShare ${config.budgetShare} of a ${target.windowTokens}-token window). ` +
+                BUDGET_ADVICE;
+    }
+    else {
+        // 6. Drop the oldest unpinned turn until the estimate fits (FR-31, FR-34).
+        for (const [position, turn] of selected.entries()) {
+            if (estimatedTokens <= budgetTokens)
+                break;
+            if (pinned.has(turn.index))
+                continue;
+            kept[position] = false;
+            estimatedTokens -= costs[position] ?? 0;
+            drops.push({ index: turn.index, reason: "budget" });
+        }
+    }
+    // 7. Report (FR-17, FR-18, FR-35).
+    const turns = selected.filter((_, position) => kept[position]);
+    // 7a. Block a plan that would import nothing: a zero-turn result is an import that cannot
+    // succeed regardless of budget, and "Nothing to import" is the honest diagnosis (FR-17, FR-33).
+    // The cause determines the advice: budget-driven drops suggest raising the budget;
+    // an empty-content session (no budget drops) means the session itself has nothing to offer.
+    if (blockedReason === null && turns.length === 0) {
+        const budgetDriven = drops.some((d) => d.reason === "budget");
+        blockedReason = budgetDriven
+            ? `nothing to import — the budget removed all turns. ${BUDGET_ADVICE}`
+            : "nothing to import — the session has no importable content. Choose a different session.";
+    }
+    drops.sort((left, right) => left.index - right.index);
+    return {
+        target: {
+            agent: target.agent,
+            home: target.home,
+            windowTokens: target.windowTokens,
+        },
+        provenance: copyProvenance(session.provenance, dedupeChangedPaths(session.provenance.repo.changedPaths)),
+        turns,
+        pins,
+        drops,
+        keptTurnCount: turns.length,
+        droppedTurnCount: drops.length,
+        // Counted over the whole selection, not the survivors: step 2 removed every body
+        // before the budget ran, so a turn the budget later dropped still lost one.
+        bodiesDropped: selected.filter((turn) => turn.toolCall?.bodyDropped === true).length,
+        estimatedTokens,
+        budgetTokens,
+        brokenTailDropped,
+        blockedReason,
+    };
+}
+/** The rules hold no state, so every instance behaves identically (T-TRA-19). */
+export function createTransferRules() {
+    return { apply };
+}

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

@@ -0,0 +1,24 @@
+import type { RepoReader } from "../platform/repo/contract.js";
+import type { AgentAdapter, FileCommitter, ImportConfig, ImportPipeline, TokenEstimator } from "./contract.js";
+import { type HandoverCommandBuilder } from "./landing/index.js";
+import { type PipelineStages } from "./pipeline.js";
+export interface ImportPipelineDeps {
+    /** Every constructed adapter, in the order the composition root listed them (FR-57). */
+    adapters: readonly AgentAdapter[];
+    config: ImportConfig;
+    estimator: TokenEstimator;
+    committer: FileCommitter;
+    /** Read by the preview to say how far the tree moved (FR-37, FR-38). */
+    repo: RepoReader;
+    /**
+     * The import time written into the marker (FR-47). Injected because no stage may read a
+     * clock: a preview and the commit that follows it must compute the same plan.
+     */
+    now?: () => string;
+    /** Renders an agent's own resume command for the handover (FR-45). */
+    handoverCommand?: HandoverCommandBuilder;
+}
+/** The four stages, wired. Internal: a host builds a pipeline, never a stage. */
+export declare function buildStages(deps: ImportPipelineDeps): PipelineStages;
+/** One import, from listing to landing. The only thing a host constructs here. */
+export declare function createImportPipeline(deps: ImportPipelineDeps): ImportPipeline;

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

@@ -0,0 +1,27 @@
+// The Internal Design, as code: this module builds its four stages and nothing else builds
+// them. Everything the stages need arrives from src/host/ — this module constructs no adapter,
+// no committer, no estimator and no configuration.
+import { createSessionFinder } from "./discovery/index.js";
+import { createSessionLander } from "./landing/index.js";
+import { createPipelineFromStages } from "./pipeline.js";
+import { createPreviewBuilder } from "./preview/index.js";
+import { createTransferRules } from "./transfer/index.js";
+/** The four stages, wired. Internal: a host builds a pipeline, never a stage. */
+export function buildStages(deps) {
+    return {
+        finder: createSessionFinder({ adapters: deps.adapters, config: deps.config }),
+        rules: createTransferRules(),
+        // Per request: the preview reads the repository the request names (FR-13, FR-37).
+        previewFor: (repoRoot) => createPreviewBuilder(deps.repo, repoRoot),
+        lander: createSessionLander(deps.handoverCommand === undefined ? {} : { handoverCommand: deps.handoverCommand }),
+        adapters: deps.adapters,
+        config: deps.config,
+        estimator: deps.estimator,
+        committer: deps.committer,
+        now: deps.now ?? (() => new Date().toISOString()),
+    };
+}
+/** One import, from listing to landing. The only thing a host constructs here. */
+export function createImportPipeline(deps) {
+    return createPipelineFromStages(buildStages(deps));
+}

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

@@ -0,0 +1,36 @@
+/**
+ * The package entry point.
+ *
+ * There is one wiring in this system and it lives in `src/host/`, which Decision 3 makes the
+ * composition root: the agent list is there because putting it in `src/adapters/` would cycle.
+ * This file's whole job is to name the one path into that wiring, so the three ways in — a
+ * program that imports the package, the command binary, and the Pi extension — are three doors
+ * onto one composition rather than three compositions.
+ *
+ * That is why nothing here reaches `src/session/`, `src/adapters/`, `src/import/` or
+ * `src/platform/`. A second import of any of them from here would be a second wiring path, and
+ * the entry point would start deciding things the host already decides.
+ */
+import { type Host, type HostDeps } from "./host/index.js";
+export type { AgentId, AgentRuntime, HandoverInstruction, HomePath, HostWiring, ImportPipeline, ImportRequest, LandingResult, ResumeFrom, SelectionInput, SessionId, SessionRef, TargetProfile, } from "./contract.js";
+/**
+ * The two entry points C-1 forces (Decision 4): a binary for the agents that cannot host a
+ * picker, and an in-process activation for the one that can. Both are re-exported rather than
+ * rebuilt — each already loads the host through `createHost` below.
+ *
+ * `activatePiExtension` is published here because the package's `./pi-extension` subpath resolves
+ * to `src/host/pi-extension/`, which holds the command and the picker but not the activation that
+ * builds a host for them. A Pi host that reached only for the subpath would have to wire the
+ * system itself.
+ */
+export { activatePiExtension, type PiActivation, runCommandBinary } from "./host/index.js";
+export type { Host, HostDeps };
+/**
+ * Loads configuration, builds the agent list, and returns the host wiring.
+ *
+ * `createHost()` with no argument is the contract's call and the one every entry point makes:
+ * every dependency defaults to the shipped implementation. The optional argument is the seam the
+ * host already publishes — it is what lets a test replace one generic service of `src/platform/`
+ * and see the rest of the system run unchanged (T-ROO-22).
+ */
+export declare function createHost(deps?: HostDeps): Promise<Host>;

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

@@ -0,0 +1,36 @@
+/**
+ * The package entry point.
+ *
+ * There is one wiring in this system and it lives in `src/host/`, which Decision 3 makes the
+ * composition root: the agent list is there because putting it in `src/adapters/` would cycle.
+ * This file's whole job is to name the one path into that wiring, so the three ways in — a
+ * program that imports the package, the command binary, and the Pi extension — are three doors
+ * onto one composition rather than three compositions.
+ *
+ * That is why nothing here reaches `src/session/`, `src/adapters/`, `src/import/` or
+ * `src/platform/`. A second import of any of them from here would be a second wiring path, and
+ * the entry point would start deciding things the host already decides.
+ */
+import { createHost as buildHost } from "./host/index.js";
+/**
+ * The two entry points C-1 forces (Decision 4): a binary for the agents that cannot host a
+ * picker, and an in-process activation for the one that can. Both are re-exported rather than
+ * rebuilt — each already loads the host through `createHost` below.
+ *
+ * `activatePiExtension` is published here because the package's `./pi-extension` subpath resolves
+ * to `src/host/pi-extension/`, which holds the command and the picker but not the activation that
+ * builds a host for them. A Pi host that reached only for the subpath would have to wire the
+ * system itself.
+ */
+export { activatePiExtension, runCommandBinary } from "./host/index.js";
+/**
+ * Loads configuration, builds the agent list, and returns the host wiring.
+ *
+ * `createHost()` with no argument is the contract's call and the one every entry point makes:
+ * every dependency defaults to the shipped implementation. The optional argument is the seam the
+ * host already publishes — it is what lets a test replace one generic service of `src/platform/`
+ * and see the rest of the system run unchanged (T-ROO-22).
+ */
+export function createHost(deps = {}) {
+    return buildHost(deps);
+}

package/node_modules/resume-from/dist/platform/config/contract.d.ts

@@ -0,0 +1,35 @@
+import type { AgentId, HomePath } from "../../session/contract.js";
+export type { AgentId, HomePath };
+/** One extra home the user added to the search list (FR-5). */
+export interface HomeEntry {
+    agent: AgentId;
+    home: HomePath;
+}
+/** A context window the user set for one agent, overriding the adapter default (FR-18). */
+export interface WindowOverride {
+    agent: AgentId;
+    windowTokens: number;
+}
+/** User configuration. Every field has a default (FR-5, FR-30, FR-32). */
+export interface ImportConfig {
+    /** Homes searched in addition to every adapter's default home. Default empty (FR-5). */
+    extraHomes: HomeEntry[];
+    /** Share of the target window one import may use. Default 0.30 (FR-30, Q-1). */
+    budgetShare: number;
+    /** Recent turns kept word for word. Default 5 (FR-32, Q-2). */
+    pinnedRecentTurns: number;
+    /** Context windows the user set explicitly. Default empty. */
+    windowOverrides: WindowOverride[];
+}
+/** Why a configuration was rejected (FR-56). */
+export interface ConfigError {
+    /** The setting at fault, for example "budgetShare". */
+    field: string;
+    /** What is wrong, and what the user can do next. */
+    message: string;
+}
+/** Loads configuration and fills every missing field with its default. */
+export interface ConfigLoader {
+    /** Rejects for invalid values or unreadable paths. A genuinely missing file is not an error. */
+    load(): Promise<ImportConfig>;
+}

package/node_modules/resume-from/dist/platform/config/contract.js

@@ -0,0 +1,4 @@
+// GENERATED from src/platform/config/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/platform/config/defaults.d.ts

@@ -0,0 +1,16 @@
+import type { ImportConfig } from "./contract.js";
+/**
+ * Share of the target window one import may use (FR-30, Q-1).
+ * This is the single home of the number: answering Q-1 is editing this line (T-CFG-8, T-CFG-14).
+ */
+export declare const DEFAULT_BUDGET_SHARE = 0.3;
+/**
+ * Recent turns kept word for word (FR-32, Q-2).
+ * Single home of the number, for the same reason as the budget share.
+ */
+export declare const DEFAULT_PINNED_RECENT_TURNS = 5;
+/**
+ * A complete configuration with nothing set by the user.
+ * Fresh arrays every call: a caller that mutates its copy must not affect the next load.
+ */
+export declare function defaultConfig(): ImportConfig;

package/node_modules/resume-from/dist/platform/config/defaults.js

@@ -0,0 +1,22 @@
+/**
+ * Share of the target window one import may use (FR-30, Q-1).
+ * This is the single home of the number: answering Q-1 is editing this line (T-CFG-8, T-CFG-14).
+ */
+export const DEFAULT_BUDGET_SHARE = 0.3;
+/**
+ * Recent turns kept word for word (FR-32, Q-2).
+ * Single home of the number, for the same reason as the budget share.
+ */
+export const DEFAULT_PINNED_RECENT_TURNS = 5;
+/**
+ * A complete configuration with nothing set by the user.
+ * Fresh arrays every call: a caller that mutates its copy must not affect the next load.
+ */
+export function defaultConfig() {
+    return {
+        extraHomes: [],
+        budgetShare: DEFAULT_BUDGET_SHARE,
+        pinnedRecentTurns: DEFAULT_PINNED_RECENT_TURNS,
+        windowOverrides: [],
+    };
+}

package/node_modules/resume-from/dist/platform/config/errors.d.ts

@@ -0,0 +1,9 @@
+import type { ConfigError } from "./contract.js";
+/**
+ * What `ConfigLoader.load` rejects with (FR-56). An `Error` as well as a `ConfigError`,
+ * so a rejection that reaches a host still carries a stack.
+ */
+export declare class ConfigLoadError extends Error implements ConfigError {
+    readonly field: string;
+    constructor(field: string, message: string);
+}

package/node_modules/resume-from/dist/platform/config/errors.js

@@ -0,0 +1,12 @@
+/**
+ * What `ConfigLoader.load` rejects with (FR-56). An `Error` as well as a `ConfigError`,
+ * so a rejection that reaches a host still carries a stack.
+ */
+export class ConfigLoadError extends Error {
+    field;
+    constructor(field, message) {
+        super(message);
+        this.name = "ConfigLoadError";
+        this.field = field;
+    }
+}

package/node_modules/resume-from/dist/platform/config/index.d.ts

@@ -0,0 +1,5 @@
+export type { ConfigError, ConfigLoader, HomeEntry, ImportConfig, WindowOverride, } from "./contract.js";
+export { DEFAULT_BUDGET_SHARE, DEFAULT_PINNED_RECENT_TURNS, defaultConfig } from "./defaults.js";
+export { ConfigLoadError } from "./errors.js";
+export { type ConfigLoaderOptions, createConfigLoader } from "./loader.js";
+export { defaultConfigPath } from "./paths.js";

package/node_modules/resume-from/dist/platform/config/index.js

@@ -0,0 +1,6 @@
+// src/platform/config/ — loads the user's settings and fills every missing one with its
+// default. Types are declared in ./contract.js; this file is the module's behaviour.
+export { DEFAULT_BUDGET_SHARE, DEFAULT_PINNED_RECENT_TURNS, defaultConfig } from "./defaults.js";
+export { ConfigLoadError } from "./errors.js";
+export { createConfigLoader } from "./loader.js";
+export { defaultConfigPath } from "./paths.js";

package/node_modules/resume-from/dist/platform/config/loader.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigLoader } from "./contract.js";
+export interface ConfigLoaderOptions {
+    /** Configuration file to read. Defaults to `~/.config/resume-from/config.json`. */
+    configPath?: string | undefined;
+}
+/**
+ * A loader that reads one JSON file and fills every missing setting with its default.
+ * It never writes: a missing file is a missing file, not something to create (T-CFG-13).
+ */
+export declare function createConfigLoader(options?: ConfigLoaderOptions): ConfigLoader;

package/node_modules/resume-from/dist/platform/config/loader.js

@@ -0,0 +1,47 @@
+import { readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { defaultConfig } from "./defaults.js";
+import { ConfigLoadError } from "./errors.js";
+import { defaultConfigPath } from "./paths.js";
+import { buildConfig } from "./validate.js";
+/**
+ * A loader that reads one JSON file and fills every missing setting with its default.
+ * It never writes: a missing file is a missing file, not something to create (T-CFG-13).
+ */
+export function createConfigLoader(options = {}) {
+    const configPath = options.configPath ?? defaultConfigPath();
+    return {
+        async load() {
+            const text = await readConfigFile(configPath);
+            // No file, or a file the user emptied: both mean "nothing set", not "nothing works".
+            if (text === undefined || text.trim() === "")
+                return defaultConfig();
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch (cause) {
+                // Not a fallback to defaults: a file the user wrote and the tool ignored is worse
+                // than an error.
+                throw new ConfigLoadError(configPath, `${configPath} is not valid JSON: ${reason(cause)}. Fix the syntax, or delete the ` +
+                    "file to use the defaults.");
+            }
+            return buildConfig(parsed, dirname(configPath), configPath);
+        },
+    };
+}
+/** The file's text, or undefined when there is no file to read. */
+async function readConfigFile(configPath) {
+    try {
+        return await readFile(configPath, "utf8");
+    }
+    catch (cause) {
+        const code = cause.code;
+        if (code === "ENOENT")
+            return undefined;
+        throw new ConfigLoadError(configPath, `${configPath} cannot be read: ${reason(cause)}. Check the path and its permissions.`);
+    }
+}
+function reason(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}

package/node_modules/resume-from/dist/platform/config/paths.d.ts

@@ -0,0 +1,13 @@
+import type { HomePath } from "./contract.js";
+/** Where the configuration lives when the caller names no other file. */
+export declare function defaultConfigPath(): string;
+/**
+ * Turns a home as written into an absolute, symlink-free path: a leading `~` becomes the
+ * user's home, a relative path is resolved against the configuration file's own directory
+ * (an invocation's working directory would make the same file mean different things), and
+ * symlinks are followed so `src/import/discovery/` deduplicates locations, not spellings.
+ *
+ * A home that does not exist keeps its resolved spelling. Existence is not checked here —
+ * a home may be created between the load and the search.
+ */
+export declare function resolveHomePath(raw: string, baseDir: string): Promise<HomePath>;

package/node_modules/resume-from/dist/platform/config/paths.js

@@ -0,0 +1,37 @@
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+const CONFIG_DIR = ".config";
+const APP_DIR = "resume-from";
+const CONFIG_FILE = "config.json";
+/** Where the configuration lives when the caller names no other file. */
+export function defaultConfigPath() {
+    return resolve(homedir(), CONFIG_DIR, APP_DIR, CONFIG_FILE);
+}
+/**
+ * Turns a home as written into an absolute, symlink-free path: a leading `~` becomes the
+ * user's home, a relative path is resolved against the configuration file's own directory
+ * (an invocation's working directory would make the same file mean different things), and
+ * symlinks are followed so `src/import/discovery/` deduplicates locations, not spellings.
+ *
+ * A home that does not exist keeps its resolved spelling. Existence is not checked here —
+ * a home may be created between the load and the search.
+ */
+export async function resolveHomePath(raw, baseDir) {
+    const expanded = expandTilde(raw);
+    const absolute = isAbsolute(expanded) ? resolve(expanded) : resolve(baseDir, expanded);
+    try {
+        return await realpath(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}
+function expandTilde(raw) {
+    if (raw === "~")
+        return homedir();
+    // Only "~/": "~other" is another user's home to a shell, and a plain segment here.
+    if (raw.startsWith("~/"))
+        return resolve(homedir(), raw.slice(2));
+    return raw;
+}