@indigoai-us/hq-cli 5.148.0 → 5.150.0

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. */
@@ -843,6 +844,8 @@ export function markSpawnFailure(hqRoot, laneId, reasonRaw, details) {
             ...current,
             state: "failed",
             queued_reason: undefined,
+            queued_at: undefined,
+            admission_reserved_at: undefined,
             terminal_reason: reason,
             terminal_details: details,
         };
@@ -1027,6 +1030,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 +1059,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 +1085,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 +1128,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 +1188,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)
@@ -1322,9 +1362,12 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             ...current,
             state: "running",
             queued_reason: undefined,
+            queued_at: undefined,
+            admission_reserved_at: undefined,
             // 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 +1391,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 +1453,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 +1523,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, isQueuedReason, 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";
@@ -244,6 +245,25 @@ function requireString(value, field) {
     }
     return value;
 }
+function requireTimestamp(value, field, filePath) {
+    const parsedAt = typeof value === "string" ? Date.parse(value) : NaN;
+    const datePart = typeof value === "string" ? value.slice(0, 10) : "";
+    const datePartAt = /^\d{4}-\d{2}-\d{2}$/.test(datePart)
+        ? Date.parse(`${datePart}T00:00:00.000Z`)
+        : NaN;
+    if (typeof value !== "string" ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) ||
+        !Number.isFinite(parsedAt) ||
+        !Number.isFinite(datePartAt) ||
+        new Date(datePartAt).toISOString().slice(0, 10) !== datePart) {
+        throw new LaneSchemaError(`Expected ISO timestamp for ${field}`, {
+            path: filePath,
+            field,
+            value,
+        });
+    }
+    return value;
+}
 function requireInt(value, field) {
     if (typeof value !== "number" || !Number.isInteger(value)) {
         throw new LaneSchemaError(`Expected integer for ${field}`, { field });
@@ -277,6 +297,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", {
@@ -296,12 +390,38 @@ export function parseLaneRecord(raw, filePath) {
     requireInt(raw.priority, "priority");
     requireString(raw.project_id, "project_id");
     requireString(raw.story_id, "story_id");
+    requireTimestamp(raw.created_at, "created_at", filePath);
+    requireTimestamp(raw.updated_at, "updated_at", filePath);
+    if (raw.queued_reason !== undefined && !isQueuedReason(raw.queued_reason)) {
+        throw new LaneSchemaError(`Unknown queued reason ${JSON.stringify(raw.queued_reason)}`, {
+            path: filePath,
+            field: "queued_reason",
+            value: raw.queued_reason,
+        });
+    }
+    if (raw.queued_at !== undefined)
+        requireTimestamp(raw.queued_at, "queued_at", filePath);
+    if (raw.admission_reserved_at !== undefined) {
+        requireTimestamp(raw.admission_reserved_at, "admission_reserved_at", filePath);
+    }
+    if (raw.admission_accounts !== undefined) {
+        if (!Array.isArray(raw.admission_accounts) ||
+            raw.admission_accounts.length === 0 ||
+            raw.admission_accounts.some((account) => typeof account !== "string" || account.trim() === "") ||
+            new Set(raw.admission_accounts).size !== raw.admission_accounts.length) {
+            throw new LaneSchemaError("admission_accounts must be a non-empty array of unique account ids", { path: filePath, field: "admission_accounts" });
+        }
+        if (typeof raw.account !== "string" || !raw.admission_accounts.includes(raw.account)) {
+            throw new LaneSchemaError("account must be present in admission_accounts", { path: filePath, field: "admission_accounts", account: raw.account });
+        }
+    }
     if (!isLaneState(raw.state)) {
         throw new LaneSchemaError(`Unknown lane state ${JSON.stringify(raw.state)}`, { path: filePath, value: raw.state });
     }
     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 +592,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 +637,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) {
@@ -596,6 +748,9 @@ export function createLane(hqRoot, init, deps = defaultStoreDeps()) {
         version: 1,
         created_at: init.created_at ?? now,
         updated_at: init.updated_at ?? now,
+        ...(init.state === "queued"
+            ? { queued_at: init.queued_at ?? init.created_at ?? now }
+            : {}),
         senior_history: init.senior_history ?? [],
         attribution_history: init.attribution_history ?? [],
     };

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

@@ -166,8 +166,9 @@ export declare const TERMINAL_LANE_STATES: readonly ["done", "failed", "interrup
 export type TerminalLaneState = (typeof TERMINAL_LANE_STATES)[number];
 export declare const LANE_PROVIDERS: readonly ["claude", "codex", "grok"];
 export type LaneProvider = (typeof LANE_PROVIDERS)[number];
-export declare const QUEUED_REASONS: readonly ["cap", "queue_position", "throttle", "provider_binary_missing"];
+export declare const QUEUED_REASONS: readonly ["cap", "provider_cap", "account_cap", "profile_cap", "queue_position", "throttle", "provider_binary_missing"];
 export type QueuedReason = (typeof QUEUED_REASONS)[number];
+export declare function isQueuedReason(value: unknown): value is QueuedReason;
 export declare const HOST_KINDS: readonly ["local", "outpost"];
 export type HostKind = (typeof HOST_KINDS)[number];
 export declare const SENIOR_KINDS: readonly ["session", "lane", "user"];
@@ -176,6 +177,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 +241,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,12 +260,21 @@ 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;
     senior_history: SeniorHistoryEntry[];
     state: LaneState;
     queued_reason?: QueuedReason;
+    /** Time the current queue turn began; old records fall back to created_at. */
+    queued_at?: string;
+    /** Short-lived slot reservation between create persistence and worker spawn. */
+    admission_reserved_at?: string;
     /**
      * Set by `hq lanes pickup` when it stores an outpost lane and cleared by
      * the account bind once the model probe has finished. While set, the
@@ -275,6 +298,8 @@ export interface LaneRecord {
     worker_profile_ignored?: string[];
     provider: LaneProvider;
     account?: string;
+    /** Eligible accounts for a queue entry created without an explicit account. */
+    admission_accounts?: string[];
     /**
      * Every operator move of the lane's session to another account of the
      * same provider (`hq lanes resume|message --account`), newest last, capped
@@ -367,6 +392,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

@@ -95,7 +95,18 @@ export const TERMINAL_LANE_STATES = [
     "killed",
 ];
 export const LANE_PROVIDERS = ["claude", "codex", "grok"];
-export const QUEUED_REASONS = ["cap", "queue_position", "throttle", "provider_binary_missing"];
+export const QUEUED_REASONS = [
+    "cap",
+    "provider_cap",
+    "account_cap",
+    "profile_cap",
+    "queue_position",
+    "throttle",
+    "provider_binary_missing",
+];
+export function isQueuedReason(value) {
+    return typeof value === "string" && QUEUED_REASONS.includes(value);
+}
 export const HOST_KINDS = ["local", "outpost"];
 export const SENIOR_KINDS = ["session", "lane", "user"];
 export const ENVELOPE_DECISIONS = ["done", "ask", "blocked"];
@@ -105,6 +116,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,20 +213,20 @@ 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"],
+    state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "reconcile"], queued_at: ["creator", "command", "spawn"], admission_reserved_at: ["creator", "command", "reconcile", "spawn"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator"], worker_path: ["creator"], worker_pack: ["creator"], worker_profile: ["creator"], worker_profile_hash: ["creator", "spawn"], worker_profile_ignored: ["creator", "spawn"],
-    provider: ["creator"], account: ["creator", "spawn", "command"], account_history: ["command"], pending_resume: ["command", "spawn"], host: ["creator"], origin_host: ["creator"], origin_host_source: ["creator"],
+    provider: ["creator"], account: ["creator", "spawn", "command", "reconcile"], admission_accounts: ["creator", "command"], account_history: ["command"], pending_resume: ["command", "spawn"], host: ["creator"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], attribution_history: ["command"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn"], effort_source: ["creator", "spawn"], fast_mode: ["spawn"],
     last_message_at: ["command"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     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"],
+    admitted_reason: ["command", "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);