@indigoai-us/hq-cli 5.148.0 → 5.149.1

package/dist/lib/lanes/session-relink.js

@@ -0,0 +1,216 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { copySessionFiles, encodeClaudeProjectDir, planSessionCopy, } from "./move-account.js";
+import { LanesError } from "./errors.js";
+function statDirectory(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return false;
+        throw err;
+    }
+}
+function claudeTranscriptPath(home, cwd, sessionId) {
+    return path.join(home, "projects", encodeClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+}
+function findCodexRollouts(home, sessionId) {
+    const root = path.join(home, "sessions");
+    if (!statDirectory(root))
+        return [];
+    const suffix = `-${sessionId}.jsonl`;
+    const stack = [{ dir: root, depth: 0 }];
+    const matches = [];
+    while (stack.length > 0) {
+        const { dir, depth } = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                continue;
+            throw new LanesError("provider_home_search_failed", `Could not search provider home ${home}: ${err instanceof Error ? err.message : String(err)}`, { provider: "codex", home });
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (depth < 3)
+                    stack.push({ dir: full, depth: depth + 1 });
+            }
+            else if (entry.isFile() &&
+                entry.name.startsWith("rollout-") &&
+                entry.name.endsWith(suffix)) {
+                matches.push(full);
+            }
+        }
+    }
+    return matches;
+}
+function sessionTranscripts(provider, home, cwd, sessionId) {
+    if (provider === "codex")
+        return findCodexRollouts(home, sessionId);
+    const transcript = claudeTranscriptPath(home, cwd, sessionId);
+    try {
+        return fs.statSync(transcript).isFile() ? [transcript] : [];
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return [];
+        throw new LanesError("provider_home_search_failed", `Could not check provider home ${home}: ${err instanceof Error ? err.message : String(err)}`, { provider, home });
+    }
+}
+/**
+ * Older Claude account homes can share a registered `account-N/.claude`
+ * parent even after one account is re-registered elsewhere. Discover only
+ * those sibling homes, then inspect the exact session path; credential files
+ * are never opened.
+ */
+export function discoverSiblingAccountHomes(provider, registeredHomes) {
+    const roots = new Set();
+    for (const home of registeredHomes) {
+        if (provider === "claude") {
+            const accountDir = path.dirname(home);
+            if (path.basename(home) === ".claude" &&
+                path.basename(accountDir).startsWith("account-")) {
+                roots.add(path.dirname(accountDir));
+            }
+        }
+        else if (path.basename(home).startsWith("account-")) {
+            roots.add(path.dirname(home));
+        }
+    }
+    const homes = [];
+    for (const root of [...roots].sort()) {
+        let entries;
+        try {
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                continue;
+            throw new LanesError("provider_home_search_failed", `Could not search provider account directory ${root}: ${err instanceof Error ? err.message : String(err)}`, { provider, home: root });
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !entry.name.startsWith("account-"))
+                continue;
+            const home = provider === "claude"
+                ? path.join(root, entry.name, ".claude")
+                : path.join(root, entry.name);
+            if (statDirectory(home))
+                homes.push(home);
+        }
+    }
+    return homes;
+}
+function uniqueHomes(homes) {
+    const unique = new Set();
+    for (const home of homes) {
+        if (typeof home !== "string" || home.trim() === "")
+            continue;
+        unique.add(path.resolve(home));
+    }
+    return [...unique];
+}
+function missingTranscript(input, homes) {
+    return new LanesError("provider_transcript_missing", `Provider transcript for session ${input.sessionId} was not found. Homes searched: ${homes.join(", ")}`, { provider: input.provider, session_id: input.sessionId, homes_searched: homes });
+}
+function copyVerifiedTranscript(input, sourceHome, targetHome, searched) {
+    let copied;
+    try {
+        copied = copySessionFiles(planSessionCopy(input.provider, {
+            sourceHome,
+            targetHome,
+            cwd: input.cwd,
+            sessionId: input.sessionId,
+        }));
+    }
+    catch (err) {
+        if (err instanceof LanesError && err.error === "provider_session_missing") {
+            throw missingTranscript(input, searched);
+        }
+        throw err;
+    }
+    const target = sessionTranscripts(input.provider, targetHome, input.cwd, input.sessionId);
+    if (target.length !== 1) {
+        throw new LanesError("provider_transcript_relink_failed", `Could not verify session ${input.sessionId} in target home ${targetHome}`, { provider: input.provider, session_id: input.sessionId, target_home: targetHome });
+    }
+    return {
+        ...copied,
+        source_home: sourceHome,
+        transcript_path: target[0],
+        homes_searched: searched,
+    };
+}
+/** Find, copy, and verify a provider transcript in the home the next run uses. */
+export function ensureSessionHome(input) {
+    const targetHome = path.resolve(input.targetHome);
+    const homes = uniqueHomes([
+        targetHome,
+        ...input.registeredHomes,
+        ...(input.providerHomeAtSpawn ? [input.providerHomeAtSpawn] : []),
+        ...discoverSiblingAccountHomes(input.provider, input.registeredHomes),
+    ]);
+    const searched = [targetHome];
+    const current = sessionTranscripts(input.provider, targetHome, input.cwd, input.sessionId);
+    if (current.length > 1) {
+        throw new LanesError("provider_transcript_ambiguous", `Multiple ${input.provider} transcripts for session ${input.sessionId} exist in ${targetHome}`, { provider: input.provider, session_id: input.sessionId, homes_searched: searched, matches: current });
+    }
+    const lastRunHome = input.providerHomeAtSpawn
+        ? path.resolve(input.providerHomeAtSpawn)
+        : undefined;
+    if (lastRunHome !== undefined && lastRunHome !== targetHome) {
+        searched.push(lastRunHome);
+        const lastRun = sessionTranscripts(input.provider, lastRunHome, input.cwd, input.sessionId);
+        if (lastRun.length > 1) {
+            throw new LanesError("provider_transcript_ambiguous", `Multiple ${input.provider} transcripts for session ${input.sessionId} exist in the last run home ${lastRunHome}`, { provider: input.provider, session_id: input.sessionId, homes_searched: searched, matches: lastRun });
+        }
+        if (lastRun.length === 1) {
+            return copyVerifiedTranscript(input, lastRunHome, targetHome, searched);
+        }
+    }
+    if (current.length === 1) {
+        const plan = planSessionCopy(input.provider, {
+            sourceHome: targetHome,
+            targetHome,
+            cwd: input.cwd,
+            sessionId: input.sessionId,
+        });
+        return {
+            ...plan,
+            copied: [],
+            source_home: targetHome,
+            transcript_path: current[0],
+            homes_searched: searched,
+        };
+    }
+    const matches = [];
+    for (const home of homes.slice(1)) {
+        if (home === lastRunHome && searched.includes(home))
+            continue;
+        searched.push(home);
+        const found = sessionTranscripts(input.provider, home, input.cwd, input.sessionId);
+        if (found.length > 1) {
+            throw new LanesError("provider_transcript_ambiguous", `Multiple ${input.provider} transcripts for session ${input.sessionId} exist in ${home}`, { provider: input.provider, session_id: input.sessionId, homes_searched: searched, matches: found });
+        }
+        if (found.length === 1)
+            matches.push({ home, transcript: found[0] });
+    }
+    if (matches.length === 0)
+        throw missingTranscript(input, searched);
+    if (matches.length > 1) {
+        throw new LanesError("provider_transcript_ambiguous", `Provider transcript for session ${input.sessionId} exists in multiple homes: ${matches.map((match) => match.home).join(", ")}`, {
+            provider: input.provider,
+            session_id: input.sessionId,
+            homes_searched: searched,
+            matching_homes: matches.map((match) => match.home),
+        });
+    }
+    return copyVerifiedTranscript(input, matches[0].home, targetHome, searched);
+}
+//# sourceMappingURL=session-relink.js.map

package/dist/lib/lanes/spawn.d.ts

@@ -235,6 +235,7 @@ export interface SpawnManifestFile {
     resume?: {
         session_id: string;
     } | null;
+    provider_home_at_spawn?: string;
     /** Byte length of logs/worker.out before this run started; its result is after this. */
     worker_out_offset?: number;
     fast_mode?: boolean;

package/dist/lib/lanes/spawn.js

@@ -22,6 +22,7 @@ import { AccountResolutionError, LanesError } from "./errors.js";
 import { ignoredWorkerProfileFields, loadWorkerProfile, materializeWorkerProfile, workerProfilePrompt, } from "./profile.js";
 import { resolveMachineIdentity, } from "./machine-identity.js";
 import { readLane, retryUpdateLane } from "./store.js";
+import { ensureSessionHome } from "./session-relink.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, parseLaneProvider, } from "./types.js";
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
@@ -1027,6 +1028,9 @@ export function readSpawnManifest(runDir) {
     const out = {};
     if (typeof rec.envelope_path === "string")
         out.envelope_path = rec.envelope_path;
+    if (typeof rec.provider_home_at_spawn === "string") {
+        out.provider_home_at_spawn = rec.provider_home_at_spawn;
+    }
     if (typeof rec.worker_out_offset === "number" &&
         Number.isInteger(rec.worker_out_offset) &&
         rec.worker_out_offset >= 0) {
@@ -1053,6 +1057,10 @@ export function readSpawnManifest(runDir) {
     }
     return out;
 }
+function laneLaunchResult(lane) {
+    const { provider_home_at_spawn: _providerHomeAtSpawn, ...safe } = lane;
+    return safe;
+}
 function inferTrigger(lane) {
     if (lane.state === "awaiting_input")
         return { kind: "answered_questions" };
@@ -1075,12 +1083,32 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const spawnProcess = deps.spawnProcess ?? defaultSpawnProcess;
     const proveDetached = deps.proveDetached ?? defaultProveDetached;
     const killProcess = deps.killProcess ?? defaultKillProcess;
-    const existing = readLane(hqRoot, lane.lane_id);
+    const runDir = laneRunDir(hqRoot, lane.lane_id);
+    const previousSpawn = readSpawnManifest(runDir);
+    const stored = readLane(hqRoot, lane.lane_id);
+    const recoveredSessionId = (typeof stored.provider_session_id === "string" && stored.provider_session_id.trim()
+        ? stored.provider_session_id
+        : undefined) ??
+        (typeof stored.last_resume?.session_id === "string" && stored.last_resume.session_id.trim()
+            ? stored.last_resume.session_id
+            : undefined) ??
+        (typeof previousSpawn.resume?.session_id === "string" && previousSpawn.resume.session_id.trim()
+            ? previousSpawn.resume.session_id
+            : undefined);
+    const existing = {
+        ...stored,
+        ...(stored.provider_session_id === undefined && recoveredSessionId !== undefined
+            ? { provider_session_id: recoveredSessionId }
+            : {}),
+        ...(stored.provider_home_at_spawn === undefined && previousSpawn.provider_home_at_spawn !== undefined
+            ? { provider_home_at_spawn: previousSpawn.provider_home_at_spawn }
+            : {}),
+    };
     if (existing.state === "running") {
         if (launch.trigger?.kind === "resume") {
             throw new LanesError("lane_not_resumable", `Lane ${lane.lane_id} is already running`, { lane_id: lane.lane_id, state: existing.state });
         }
-        return existing;
+        return laneLaunchResult(existing);
     }
     // A queued lane that a move parked at the target's cap carries the turn
     // it was resumed with: the admit spawn continues that session instead of
@@ -1098,7 +1126,6 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     if (existing.host.kind === "outpost") {
         refuseOutpostSelfTarget(hqRoot, existing, deps);
     }
-    const runDir = laneRunDir(hqRoot, lane.lane_id);
     const logsDir = path.join(runDir, "logs");
     ensureDir(logsDir);
     ensureDir(path.join(runDir, "envelopes"));
@@ -1159,6 +1186,17 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     if (profileDefaultsApply && profileModel !== undefined && pinnedModel === undefined) {
         validateProfileLaneModel(existing.provider, profileModel, resolved.home, profile.id, modelDeps);
     }
+    if (plan.mode === "resume" && existing.provider !== "grok") {
+        ensureSessionHome({
+            provider: existing.provider,
+            sessionId: plan.session_id,
+            cwd: hqRoot,
+            targetHome: resolved.home,
+            registeredHomes: Object.values(config.providers[existing.provider].accounts)
+                .map((account) => account.home),
+            providerHomeAtSpawn: existing.provider_home_at_spawn,
+        });
+    }
     if (lane.account !== resolved.id) {
         retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
             if (current.account === resolved.id)
@@ -1325,6 +1363,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             // An account move's reservation ends with the claim.
             pending_resume: undefined,
             account: resolved.id,
+            provider_home_at_spawn: resolved.home,
             ...(model !== undefined ? { model } : {}),
             ...(model !== undefined
                 ? {
@@ -1348,6 +1387,10 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 }
                 : {}),
         };
+        if (resume !== undefined) {
+            next.provider_session_id = resume.session_id;
+            next.provider_session_id_absent = undefined;
+        }
         if (effort.effort !== undefined)
             next.effort = effort.effort;
         else
@@ -1406,7 +1449,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 last_compaction: record,
             }));
         }
-        return claimedRecord;
+        return laneLaunchResult(claimedRecord);
     }
     const workerOutPath = path.join(logsDir, "worker.out");
     const workerOutOffset = fileSizeOrZero(workerOutPath);
@@ -1476,7 +1519,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         }
         throw err;
     }
-    return readLane(hqRoot, lane.lane_id);
+    return laneLaunchResult(readLane(hqRoot, lane.lane_id));
 }
 /**
  * `resume`: claude and codex continue the recorded session with the repair

package/dist/lib/lanes/store.js

@@ -13,7 +13,8 @@ import * as path from "node:path";
 import { generateUlid } from "../mesh/live/ulid.js";
 import { resolveLanesHqRoot } from "./hq-root.js";
 import { LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesError, isLaneVersionConflict, } from "./errors.js";
-import { HISTORY_CAP, HOST_KINDS, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isLaneState, isQuestionStatus, isSeniorKind, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
+import { HISTORY_CAP, HOST_KINDS, LANE_STORY_STATUSES, LANE_SCHEMA_VERSION, QUESTION_SCHEMA_VERSION, SENIOR_KINDS, isHostKind, isLaneProvider, isLaneState, isQuestionStatus, isSeniorKind, parseMajorSchema, REQUIRED_LANE_RECORD_FIELDS, LANE_FIELD_WRITERS, LANE_WRITERS, } from "./types.js";
+import { laneStories } from "./stories.js";
 export const LANES_STORE_REL = path.join("workspace", "lanes");
 export const LANE_RECORDS_DIR = "lanes";
 export const QUESTION_RECORDS_DIR = "questions";
@@ -277,6 +278,80 @@ function parseOptionalMeshCompanyField(raw, filePath) {
     requireString(raw.mesh_company.slug, "mesh_company.slug");
     requireString(raw.mesh_company.uid, "mesh_company.uid");
 }
+function legacyLaneStory(raw) {
+    const status = raw.state === "blocked"
+        ? "blocked"
+        : raw.story_status === "review"
+            ? "review"
+            : raw.story_status === "done" || raw.story_complete === true
+                ? "review"
+                : "in_progress";
+    const story = {
+        project_id: requireString(raw.project_id, "project_id"),
+        story_id: requireString(raw.story_id, "story_id"),
+        status,
+        added_at: requireString(raw.created_at, "created_at"),
+        updated_at: requireString(raw.updated_at, "updated_at"),
+    };
+    if (typeof raw.blocked_reason === "string" && raw.blocked_reason.length > 0) {
+        story.blocked_reason = raw.blocked_reason;
+    }
+    return story;
+}
+function parseLaneStories(raw, filePath) {
+    if (raw.stories === undefined) {
+        // v1 records carried one story in the top-level fields. Keep the old
+        // fields authoritative for the migration and give worker-completed work
+        // the review state until a senior explicitly verifies it.
+        raw.stories = [legacyLaneStory(raw)];
+        return;
+    }
+    if (!Array.isArray(raw.stories) || raw.stories.length === 0) {
+        throw new LaneSchemaError("stories must be a non-empty array when present", {
+            path: filePath,
+            field: "stories",
+        });
+    }
+    for (const [index, value] of raw.stories.entries()) {
+        const field = `stories[${index}]`;
+        if (!isPlainObject(value)) {
+            throw new LaneSchemaError(`${field} must be an object`, { path: filePath, field });
+        }
+        requireString(value.project_id, `${field}.project_id`);
+        requireString(value.story_id, `${field}.story_id`);
+        requireString(value.added_at, `${field}.added_at`);
+        requireString(value.updated_at, `${field}.updated_at`);
+        if (typeof value.status !== "string" ||
+            !LANE_STORY_STATUSES.includes(value.status)) {
+            throw new LaneSchemaError(`Unknown story status ${JSON.stringify(value.status)}`, {
+                path: filePath,
+                field: `${field}.status`,
+                value: value.status,
+                accepted: [...LANE_STORY_STATUSES],
+            });
+        }
+        if (value.blocked_reason !== undefined) {
+            requireString(value.blocked_reason, `${field}.blocked_reason`);
+        }
+        if (value.verified_at !== undefined) {
+            requireString(value.verified_at, `${field}.verified_at`);
+        }
+        if (value.verified_by !== undefined) {
+            if (!isPlainObject(value.verified_by)) {
+                throw new LaneSchemaError(`${field}.verified_by must be an object`, {
+                    path: filePath,
+                    field: `${field}.verified_by`,
+                });
+            }
+            if (!isSeniorKind(value.verified_by.kind)) {
+                throw new LaneSchemaError(`Unknown senior kind ${JSON.stringify(value.verified_by.kind)}`, { path: filePath, field: `${field}.verified_by.kind` });
+            }
+            if (value.verified_by.kind !== "user") {
+                requireString(value.verified_by.id, `${field}.verified_by.id`);
+            }
+        }
+    }
+}
 export function parseLaneRecord(raw, filePath) {
     if (!isPlainObject(raw)) {
         throw new LaneSchemaError("Lane record must be a JSON object", {
@@ -302,6 +377,7 @@ export function parseLaneRecord(raw, filePath) {
     if (!isLaneProvider(raw.provider)) {
         throw new LaneSchemaError(`Unknown provider ${JSON.stringify(raw.provider)}`, { path: filePath, value: raw.provider });
     }
+    parseLaneStories(raw, filePath);
     parseOptionalCompanyField(raw, filePath);
     parseOptionalMeshCompanyField(raw, filePath);
     if (!isPlainObject(raw.senior)) {
@@ -472,6 +548,37 @@ function higherVersionRecord(live, others) {
     }
     return best;
 }
+function laneStoryIdentity(story) {
+    return `${story.project_id}\u0000${story.story_id}`;
+}
+function mergeLaneStories(records, base) {
+    const baseStories = laneStories(base);
+    const merged = new Map();
+    const baseOrder = [];
+    for (const story of baseStories) {
+        const key = laneStoryIdentity(story);
+        if (!merged.has(key))
+            baseOrder.push(key);
+        merged.set(key, story);
+    }
+    for (const record of records) {
+        if (record === base)
+            continue;
+        for (const story of laneStories(record)) {
+            const key = laneStoryIdentity(story);
+            const current = merged.get(key);
+            if (!current || story.updated_at > current.updated_at) {
+                merged.set(key, story);
+            }
+        }
+    }
+    const sideOnly = [...merged.keys()]
+        .filter((key) => !baseOrder.includes(key))
+        .sort();
+    return [...baseOrder, ...sideOnly]
+        .map((key) => merged.get(key))
+        .filter((story) => story !== undefined);
+}
 export function mergeLaneRecords(live, sidecars) {
     if (sidecars.length === 0)
         return live;
@@ -486,6 +593,7 @@ export function mergeLaneRecords(live, sidecars) {
                 account_history: unionHistory(all.map((record) => record.account_history ?? []), entryIdentity, base.account_history ?? []),
             }
             : {}),
+        stories: mergeLaneStories(all, base),
     };
 }
 export function mergeQuestionRecords(live, sidecars) {

package/dist/lib/lanes/stories.d.ts

@@ -0,0 +1,17 @@
+import type { LaneRecord, LaneStory } from "./types.js";
+/** Board-facing states for the stories a lane currently carries. */
+export declare const ACTIVE_LANE_STORY_STATUSES: readonly ["in_progress", "blocked", "review"];
+export declare function storyKey(projectId: string, storyId: string): string;
+/**
+ * Read the v1 multi-story field while keeping old one-story records usable.
+ * The returned legacy row is deliberately in-memory until the next normal
+ * lane write, so reading an old record never changes it on disk by itself.
+ */
+export declare function laneStories(lane: LaneRecord): LaneStory[];
+export declare function activeLaneStories(lane: LaneRecord): LaneStory[];
+export declare function laneStory(lane: LaneRecord, projectId: string, storyId: string): LaneStory | undefined;
+export declare function storyWarning(lane: LaneRecord): string | undefined;
+export declare function withCurrentStory(lane: LaneRecord, projectId: string, storyId: string): LaneRecord;
+export declare function withLaneStories(lane: LaneRecord, stories: LaneStory[]): LaneRecord;
+export declare function storyStatusForEnvelope(status: string): "in_progress" | "review";
+//# sourceMappingURL=stories.d.ts.map

package/dist/lib/lanes/stories.js

@@ -0,0 +1,73 @@
+/** Board-facing states for the stories a lane currently carries. */
+export const ACTIVE_LANE_STORY_STATUSES = [
+    "in_progress",
+    "blocked",
+    "review",
+];
+export function storyKey(projectId, storyId) {
+    return `${projectId}\u0000${storyId}`;
+}
+function legacyStatus(lane) {
+    if (lane.state === "blocked")
+        return "blocked";
+    if (lane.story_status === "review")
+        return "review";
+    // A worker envelope was historically allowed to say done. The worker's
+    // terminal result only earns review; senior verification is the sole path
+    // to the durable done state.
+    if (lane.story_status === "done" || lane.story_complete === true) {
+        return "review";
+    }
+    return "in_progress";
+}
+/**
+ * Read the v1 multi-story field while keeping old one-story records usable.
+ * The returned legacy row is deliberately in-memory until the next normal
+ * lane write, so reading an old record never changes it on disk by itself.
+ */
+export function laneStories(lane) {
+    if (Array.isArray(lane.stories) && lane.stories.length > 0) {
+        return lane.stories;
+    }
+    const at = lane.updated_at || lane.created_at;
+    return [
+        {
+            project_id: lane.project_id,
+            story_id: lane.story_id,
+            status: legacyStatus(lane),
+            added_at: lane.created_at,
+            updated_at: at,
+        },
+    ];
+}
+export function activeLaneStories(lane) {
+    return laneStories(lane).filter((story) => ACTIVE_LANE_STORY_STATUSES.includes(story.status));
+}
+export function laneStory(lane, projectId, storyId) {
+    const key = storyKey(projectId, storyId);
+    return laneStories(lane).find((story) => storyKey(story.project_id, story.story_id) === key);
+}
+export function storyWarning(lane) {
+    const count = activeLaneStories(lane).length;
+    if (count <= 1)
+        return undefined;
+    return `Lane ${lane.lane_id} carries ${count} active stories; parallel story work is allowed but discouraged.`;
+}
+export function withCurrentStory(lane, projectId, storyId) {
+    return {
+        ...lane,
+        project_id: projectId,
+        story_id: storyId,
+    };
+}
+export function withLaneStories(lane, stories) {
+    return { ...lane, stories };
+}
+export function storyStatusForEnvelope(status) {
+    // A worker's `done` envelope is reviewable work. Durable `done` is reserved
+    // for the senior verification command.
+    if (status === "review")
+        return "review";
+    return "in_progress";
+}
+//# sourceMappingURL=stories.js.map

package/dist/lib/lanes/types.d.ts

@@ -176,6 +176,9 @@ export declare const ENVELOPE_DECISIONS: readonly ["done", "ask", "blocked"];
 export type EnvelopeDecision = (typeof ENVELOPE_DECISIONS)[number];
 export declare const STORY_STATUSES: readonly ["queued", "in_progress", "review", "done"];
 export type StoryStatus = (typeof STORY_STATUSES)[number];
+/** Durable Board status for a story carried by a lane. */
+export declare const LANE_STORY_STATUSES: readonly ["in_progress", "blocked", "review", "done"];
+export type LaneStoryStatus = (typeof LANE_STORY_STATUSES)[number];
 /**
  * `expired` is accepted on read for records that already carry it. Spec §9
  * ageing advances hop with `unanswered_timeout` and never expires a question,
@@ -237,6 +240,16 @@ export interface LastEnvelopeRef {
     decision: EnvelopeDecision;
     at: string;
 }
+export interface LaneStory {
+    project_id: string;
+    story_id: string;
+    status: LaneStoryStatus;
+    added_at: string;
+    updated_at: string;
+    blocked_reason?: string;
+    verified_at?: string;
+    verified_by?: SeniorRef;
+}
 export interface LaneRecord {
     schema_version: typeof LANE_SCHEMA_VERSION | string;
     lane_id: string;
@@ -246,6 +259,11 @@ export interface LaneRecord {
     mesh_company?: LaneCompanyRef;
     project_id: string;
     story_id: string;
+    /**
+     * Stories currently carried by this lane. Old records omit this field and
+     * are migrated in memory from project_id/story_id on read.
+     */
+    stories?: LaneStory[];
     thread_id?: string;
     depth: number;
     senior: SeniorRef;
@@ -367,6 +385,8 @@ export interface LaneRecord {
      */
     provider_session_id?: string;
     provider_session_id_absent?: string;
+    /** Provider home used by the most recently spawned run, for transcript recovery. */
+    provider_home_at_spawn?: string;
     /** Set at spawn when this run continued a recorded session instead of starting fresh. */
     last_resume?: LaneResumeRecord;
     /** Cache counters from the last exited run's result. Nothing else from the payload. */

package/dist/lib/lanes/types.js

@@ -105,6 +105,13 @@ export const STORY_STATUSES = [
     "review",
     "done",
 ];
+/** Durable Board status for a story carried by a lane. */
+export const LANE_STORY_STATUSES = [
+    "in_progress",
+    "blocked",
+    "review",
+    "done",
+];
 /**
  * `expired` is accepted on read for records that already carry it. Spec §9
  * ageing advances hop with `unanswered_timeout` and never expires a question,
@@ -195,7 +202,7 @@ export const LANE_WRITERS = ["creator", "command", "watcher", "reconcile", "spaw
 /** Field ownership at the durable-record mutation boundary (spec §10.1). */
 export const LANE_FIELD_WRITERS = {
     schema_version: ["creator"], lane_id: ["creator"], company: ["creator"],
-    project_id: ["command"], story_id: ["command"], thread_id: ["creator", "command"], mesh_company: ["creator"],
+    project_id: ["command"], story_id: ["command"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
@@ -208,7 +215,7 @@ export const LANE_FIELD_WRITERS = {
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
-    provider_session_id: ["watcher"], provider_session_id_absent: ["watcher"], last_resume: ["spawn"], last_run_usage: ["watcher"], envelope_repair: ["watcher", "reconcile"], last_progress_event_at: ["watcher"],
+    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], last_resume: ["spawn"], last_run_usage: ["watcher"], envelope_repair: ["watcher", "reconcile"], last_progress_event_at: ["watcher"],
 };
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);