@indigoai-us/hq-cli 5.148.0 → 5.149.1

package/dist/commands/mesh.js

@@ -9,11 +9,12 @@ import { resolve as resolvePath } from "node:path";
 import * as os from "node:os";
 import { readFileSync } from "node:fs";
 import { findHqRoot } from "../utils/manifest.js";
+import { CLI_VERSION } from "../cli-version.js";
 import chalk from "chalk";
 import { loadCachedTokens, isMachineIdentity } from "../utils/cognito-session.js";
 import * as readline from "node:readline/promises";
 import { STORY_STATUSES, appendThreadEvent, ensureProjectThread, eventPayload, getProjectView, listActiveMembershipCompanies, listActiveThreads, patchStory, putProjectView, registerMeshProject, resolveActiveMembershipCompany, resolveMeshPrincipalUid, warmMeshConversationCache, } from "../lib/mesh/api.js";
-import { closeSupersededProjectThread, ensureProjectBoard } from "../lib/mesh/project-board.js";
+import { closeSupersededProjectThread, ensureMissingBoardStories, ensureProjectBoard } from "../lib/mesh/project-board.js";
 import { buildPreflightFixtures } from "../lib/work-context/preflight-contract.js";
 import { createCandidatesFetcher, createMigratePoster, createOrganizePoster, createWorkSessionDeliverer, fetchCompanyLive, formatCompanyLiveTable, openMeshTransport, probeMigrationCapabilityForMemberships, requireToken, } from "../lib/mesh/client.js";
 import { clearDefaultCompany, isDefaultCompanyDisabled, readDeviceConfig, recordMigrationCapabilitySnapshot, setRepairHeldWithDefault, setDefaultCompany, } from "../lib/work-context/config.js";
@@ -34,7 +35,7 @@ import { generateUlid } from "../lib/mesh/live/ulid.js";
 import { readLegacyBacklog } from "../lib/mesh/live/emit-replay.js";
 import { resolveMeshEmitMode, writeMeshConfigMode, } from "../lib/mesh/live/daemon/mode.js";
 import { workMeshRoot } from "../lib/mesh/live/paths.js";
-import { buildInstallPaths, collectDaemonDoctor, daemonServiceStatus, findAncestorHqRoot, resolveInstallHqRoot, detectPlatform, formatDaemonDoctor, installDaemonService, readDaemonState, runMeshDaemon, uninstallDaemonService, daemonDir, } from "../lib/mesh/live/daemon/index.js";
+import { buildInstallPaths, collectDaemonDoctor, daemonServiceStatus, findAncestorHqRoot, resolveInstallHqRoot, detectPlatform, formatCliIdentityLines, formatDaemonDoctor, installDaemonIfStale, installDaemonService, readDaemonState, resolveAbsoluteNodeBinary, resolveRunningCliEntry, runMeshDaemon, uninstallDaemonService, daemonDir, } from "../lib/mesh/live/daemon/index.js";
 import { workContextRoot } from "../lib/work-context/paths.js";
 import { formatMigrateConfirmation, submitSessionMigration, } from "../lib/work-context/migrate.js";
 import { formatOrganizeList, prepareOrganizeDecision, settleOrganizeAskWithoutBind, submitOrganizeDecision, } from "../lib/work-context/organize.js";
@@ -575,6 +576,29 @@ async function runPrdSync(opts) {
         ...(bound?.projectId ? { project: bound.projectId } : {}),
         touchedPaths: [resolvePath(file)],
     };
+    if (bound?.companyUid && bound.projectId) {
+        try {
+            const source = parseProjectPlan(readFileSync(file, "utf8"), file);
+            await ensureMissingBoardStories({
+                token,
+                company: {
+                    companyUid: bound.companyUid,
+                    companySlug: bound.companySlug || bound.companyUid,
+                },
+                projectId: bound.projectId,
+                name: source.name || bound.projectId,
+                description: source.description ?? "",
+                stories: source.stories,
+                repos: source.repos ?? [],
+                requiredIds: plan.events.map((event) => event.taskId),
+            });
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            console.error(`work-mesh: prd-sync ensure failed; emitting anyway (${reason.slice(0, 160)})`);
+        }
+    }
+    const meshRoot = workMeshHomeRoot();
     const seqFirst = reserveSessionSeq(sessionId, plan.events.length);
     const events = plan.events.map((event, index) => buildMeshEmitEvent({
         eventId: generateUlid(Date.now() + index),
@@ -592,7 +616,7 @@ async function runPrdSync(opts) {
     }));
     const poster = createEmitPoster({ token, baseUrl: resolveVaultApiBase(process.env) });
     const emitted = await emitEvents({
-        workMeshRoot: workMeshHomeRoot(),
+        workMeshRoot: meshRoot,
         poster,
         newEvents: events,
     });
@@ -601,8 +625,15 @@ async function runPrdSync(opts) {
         for (const line of formatEmitRejectionLines(emitted.rejections))
             console.error(line);
     }
-    plan.commit();
-    if (plan.taskId) {
+    const blocked = new Set(emitted.rejections.map((row) => row.eventId));
+    for (const pending of readEmitRetry(meshRoot)) {
+        const id = typeof pending.eventId === "string" ? pending.eventId : "";
+        if (id)
+            blocked.add(id);
+    }
+    const advanced = events.flatMap((event) => (event.eventId && event.taskId && !blocked.has(event.eventId) ? [event.taskId] : []));
+    plan.commit(advanced);
+    if (plan.taskId && advanced.includes(plan.taskId)) {
         updateSessionState(sessionId, root, (current) => {
             if (!current)
                 return null;
@@ -639,6 +670,12 @@ async function runDoctor(opts) {
         fail("`hq mesh doctor --apply` (paced Board PUTs from local prd.json) is not in the CLI yet.\n" +
             "Omit --apply to warm the conversation cache (directory, inbox, pair DMs).");
     }
+    const identity = collectDaemonDoctor();
+    const identityLines = formatCliIdentityLines(identity);
+    if (!opts.json) {
+        for (const line of identityLines)
+            console.log(line);
+    }
     const token = await requireToken();
     const principalUid = await resolveMeshPrincipalUid(token, loadCachedTokens());
     if (!principalUid) {
@@ -647,7 +684,15 @@ async function runDoctor(opts) {
     const warmed = await warmMeshConversationCache(token, principalUid);
     const needsProject = listNeedsProjectSessions(workContextHomeRoot());
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, action: "doctor", ...warmed, needsProject }, null, 2));
+        console.log(JSON.stringify({
+            ok: true,
+            action: "doctor",
+            ...warmed,
+            needsProject,
+            cliMismatchLine: identity.cliMismatchLine ?? null,
+            hqOnPath: identity.hqOnPath,
+            multipleHqOnPath: identity.multipleHqOnPath,
+        }, null, 2));
         return;
     }
     console.log(`Work mesh cache warmed at ${warmed.cacheRoot}` +
@@ -1938,6 +1983,7 @@ export function registerMeshCommand(program) {
         .description("Install LaunchAgent (macOS), systemd user unit (Linux), or Scheduled Task (Windows)")
         .option("--system-user <user>", "Write a root-owned unit template for agent boxes (e.g. ec2-user)")
         .option("--hq-root <path>", "HQ root to record for the service (else HQ_ROOT, else the nearest HQ root above cwd)")
+        .option("--if-stale", "Reinstall and restart only when this CLI is newer than the daemon's recorded version")
         .option("--json", "Print machine-readable JSON")
         .action((opts) => wrap(() => runDaemonInstall(opts))());
     daemon
@@ -1971,13 +2017,38 @@ async function runDaemonInstall(opts) {
     // Verified root only: a repo's own .claude/ must never become the daemon's
     // HQ root (that path is persisted as trusted and used for attribution).
     const hqRoot = resolveInstallHqRoot({ explicit: opts.hqRoot });
+    const paths = buildInstallPaths({
+        systemUser: opts.systemUser,
+        hqRoot: hqRoot.root,
+        hqRootSource: hqRoot.source,
+        hqBinary: resolveRunningCliEntry(),
+        nodeBinary: resolveAbsoluteNodeBinary(),
+    });
+    if (opts.ifStale) {
+        const stale = installDaemonIfStale({
+            currentVersion: CLI_VERSION,
+            platform: detectPlatform(),
+            paths,
+            systemUser: opts.systemUser,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                action: stale.reinstalled ? "install" : "unchanged",
+                reinstalled: stale.reinstalled,
+                message: stale.message,
+                hqBinary: paths.hqBinary,
+                nodeBinary: paths.nodeBinary,
+                hqRoot: hqRoot.root,
+            }, null, 2));
+            return;
+        }
+        console.log(stale.message);
+        return;
+    }
     const result = installDaemonService({
         platform: detectPlatform(),
-        paths: buildInstallPaths({
-            systemUser: opts.systemUser,
-            hqRoot: hqRoot.root,
-            hqRootSource: hqRoot.source,
-        }),
+        paths,
         systemUser: opts.systemUser,
     });
     if (opts.json) {

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

@@ -3,8 +3,9 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
-export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LaneRecord, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
+export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
+export type { AccountConfig, AttributionHistoryEntry, EnvelopeDecision, EnvelopeQuestion, HostKind, LaneCompanyRef, LaneEnvelope, LaneHost, LaneProvider, LaneRecord, LaneStory, LaneStoryStatus, PendingResume, AccountHistoryEntry, LaneState, LanesConfig, LastEnvelopeRef, LivenessState, LivenessWindows, ProviderConfig, QuestionAnswer, QuestionBodyRef, QuestionRecord, QuestionStatus, QueuedReason, RaisedVia, RoutingHistoryEntry, RoutingReason, SeniorHistoryEntry, SeniorKind, SeniorRef, StoryStatus, TerminalLaneState, ThrottleConfig, } from "./types.js";
+export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";
 export { resolveLanesHqRoot } from "./hq-root.js";

package/dist/lib/lanes/index.js

@@ -3,7 +3,8 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
+export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
+export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export { resolveLanesHqRoot } from "./hq-root.js";
 export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";

package/dist/lib/lanes/mesh-events.d.ts

@@ -78,6 +78,14 @@ export interface CreateLaneMeshOptions {
     interactive?: boolean;
     /** Test seam. Defaults to the shared `requireToken`. */
     token?: () => Promise<string>;
+    /** Repair a missing project view before retrying a story status patch. */
+    repairProjectView?: (input: {
+        token: string;
+        company: LaneCompanyRef;
+        projectId: string;
+        storyId: string;
+        status: string;
+    }) => Promise<void>;
 }
 export declare function createLaneMesh(opts?: CreateLaneMeshOptions): LaneMesh;
 /** Resolve the explicit mesh attribution before falling back to the lane tenant. */

package/dist/lib/lanes/mesh-events.js

@@ -42,7 +42,7 @@
  * of opening a browser nobody is watching, and the watcher records
  * `mesh_event_failed` and moves on. No credential file is read here.
  */
-import { appendThreadEvent, clamp, ensureProjectThread, patchStoryStatus, requireToken, resolveMeshCompany, } from "../mesh/api.js";
+import { appendThreadEvent, clamp, ensureProjectThread, getProjectView, patchStoryStatus, putProjectView, requireToken, registerMeshProject, resolveMeshCompany, } from "../mesh/api.js";
 import { LanesError } from "./errors.js";
 export const LANE_MESH_EVENTS = [
     "lane_started",
@@ -163,9 +163,64 @@ export function toWireThreadEvent(event, payload) {
         }
     }
 }
+function isProjectViewNotFound(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    return (candidate.code === "PROJECT_VIEW_NOT_FOUND" ||
+        (typeof candidate.message === "string" && candidate.message.includes("PROJECT_VIEW_NOT_FOUND")));
+}
+function isAlreadyRegistered(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    return (candidate.code === "PROJECT_ALREADY_REGISTERED" ||
+        (typeof candidate.message === "string" && candidate.message.includes("PROJECT_ALREADY_REGISTERED")));
+}
+async function repairProjectView(input) {
+    const company = { companyUid: input.company.uid, companySlug: input.company.slug };
+    await ensureProjectThread(input.token, company, input.projectId, {
+        summary: `HQ lane ${input.projectId}`,
+    });
+    let current;
+    try {
+        current = await getProjectView(input.token, input.company.uid, input.projectId);
+    }
+    catch (error) {
+        if (!isProjectViewNotFound(error))
+            throw error;
+    }
+    const stories = [...(current?.stories ?? [])];
+    const index = stories.findIndex((story) => story.id === input.storyId);
+    const nextStory = {
+        ...(index >= 0 ? stories[index] : {}),
+        id: input.storyId,
+        title: index >= 0 ? stories[index]?.title || input.storyId : input.storyId,
+        status: input.status,
+    };
+    if (index >= 0)
+        stories[index] = nextStory;
+    else
+        stories.push(nextStory);
+    await putProjectView(input.token, input.company.uid, input.projectId, {
+        name: current?.name || input.projectId,
+        description: current?.description || "HQ lane project",
+        stories,
+        repos: current?.repos ?? [],
+        ...(current?.version !== undefined ? { expectedVersion: current.version } : {}),
+    });
+    try {
+        await registerMeshProject(input.token, input.company.uid, input.projectId);
+    }
+    catch (error) {
+        if (!isAlreadyRegistered(error))
+            throw error;
+    }
+}
 export function createLaneMesh(opts = {}) {
     const interactive = opts.interactive ?? true;
     const token = opts.token ?? (() => requireToken({ interactive }));
+    const repair = opts.repairProjectView ?? repairProjectView;
     return {
         async ensureProjectThread(company, projectId) {
             const tok = await token();
@@ -182,7 +237,21 @@ export function createLaneMesh(opts = {}) {
         },
         async patchStoryStatus(company, projectId, storyId, status) {
             const tok = await token();
-            await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+            try {
+                await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+            }
+            catch (error) {
+                if (!isProjectViewNotFound(error))
+                    throw error;
+                await repair({
+                    token: tok,
+                    company,
+                    projectId,
+                    storyId,
+                    status,
+                });
+                await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+            }
         },
     };
 }
@@ -232,10 +301,18 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
             return;
         }
         case "blocked":
-            await mesh.appendThreadEvent(company, threadId, "lane_blocked", {
-                ...baseIdentity(lane),
-                blocked_reason: envelope.blocked_reason ?? "",
-            });
+            {
+                const outcomes = await Promise.allSettled([
+                    mesh.appendThreadEvent(company, threadId, "lane_blocked", {
+                        ...baseIdentity(lane),
+                        blocked_reason: envelope.blocked_reason ?? "",
+                    }),
+                    mesh.patchStoryStatus(company, lane.project_id, lane.story_id, "in_progress"),
+                ]);
+                const failure = outcomes.find((outcome) => outcome.status === "rejected");
+                if (failure?.status === "rejected")
+                    throw failure.reason;
+            }
             return;
         case "ask":
             // A mesh question event has one `questionId`; sending one event per id

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -26,6 +26,16 @@ export interface OutpostDispatchResult {
     stdout: string;
     stderr: string;
 }
+export interface OutpostLaneCommand {
+    action: "message" | "resume";
+    laneId: string;
+    text?: string;
+    project?: string;
+    story?: string;
+    account?: string;
+    model?: string;
+    compact?: boolean;
+}
 export interface OutpostExecPort {
     stageExecInput: (outpostId?: string) => Promise<{
         putUrl: string;
@@ -47,6 +57,8 @@ export interface OutpostExecPort {
 export declare function parseOutpostPickupPayload(raw: unknown): OutpostPickupPayload;
 /** Same wrapping `hq outposts exec` applies: run from the box's HQ folder. */
 export declare function buildOutpostPickupCommand(payloadUrl: string): string;
+/** Build the same `hq outposts exec` remote command used by lane pickup. */
+export declare function buildOutpostLaneCommand(input: OutpostLaneCommand): string;
 export declare function stageOutpostPayload(port: Pick<OutpostExecPort, "stageExecInput">, outpostId: string, bytes: Uint8Array, put?: typeof fetch): Promise<{
     getUrl: string;
 }>;

package/dist/lib/lanes/outpost-dispatch.js

@@ -42,6 +42,23 @@ export function parseOutpostPickupPayload(raw) {
 export function buildOutpostPickupCommand(payloadUrl) {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "pickup", "--payload-url", payloadUrl]));
 }
+/** Build the same `hq outposts exec` remote command used by lane pickup. */
+export function buildOutpostLaneCommand(input) {
+    const args = ["hq", "lanes", input.action, input.laneId];
+    for (const [flag, value] of [
+        ["--text", input.text],
+        ["--project", input.project],
+        ["--story", input.story],
+        ["--account", input.account],
+        ["--model", input.model],
+    ]) {
+        if (value !== undefined)
+            args.push(flag, value);
+    }
+    if (input.compact === false)
+        args.push("--no-compact");
+    return withRemoteHqDir(joinCommandParts(args));
+}
 export async function stageOutpostPayload(port, outpostId, bytes, put = fetch) {
     const staged = await port.stageExecInput(outpostId);
     const upload = await put(staged.putUrl, {

package/dist/lib/lanes/reconcile.js

@@ -20,6 +20,7 @@ import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./qu
 import { answeredQuestionEntries, raiseEnvelopeQuestions } from "./questions.js";
 import { SILENCE_MS, classifyLaneExit, isPidAlive, readLatestEnvelope, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, laneMeshCompany } from "./mesh-events.js";
+import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
@@ -882,18 +883,44 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     (latest.envelope.questions?.length ?? 0) > 0) {
                     raiseEnvelopeQuestions(hqRoot, readLane(hqRoot, lane.lane_id), latest.envelope, latest.ref, nowIso);
                 }
-                const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "running", (current) => ({
-                    ...current,
-                    state: repairedClassification.state,
-                    queued_reason: undefined,
-                    terminal_reason: repairedClassification.reason ?? "host_lost",
-                    ...(providerRejection
-                        ? { terminal_details: providerRejectionDetails(providerRejection, current) }
-                        : {}),
-                    ...(quota?.quota_reset_at ? { quota_reset_at: quota.quota_reset_at } : {}),
-                    ...(quota?.marker ? { model_quota_marker: quota.marker } : {}),
-                    last_host_report_at: nowIso,
-                }), deps.dryRun);
+                const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "running", (current) => {
+                    const next = {
+                        ...current,
+                        state: repairedClassification.state,
+                        queued_reason: undefined,
+                        terminal_reason: repairedClassification.reason ?? "host_lost",
+                        ...(providerRejection
+                            ? { terminal_details: providerRejectionDetails(providerRejection, current) }
+                            : {}),
+                        ...(quota?.quota_reset_at ? { quota_reset_at: quota.quota_reset_at } : {}),
+                        ...(quota?.marker ? { model_quota_marker: quota.marker } : {}),
+                        last_host_report_at: nowIso,
+                    };
+                    if (latest?.envelope) {
+                        const envelope = latest.envelope;
+                        next.story_status = envelope.story_status;
+                        if (envelope.story_complete !== undefined) {
+                            next.story_complete = envelope.story_complete;
+                            next.story_complete_reason = envelope.story_complete_reason;
+                        }
+                        const storyStatus = envelope.decision === "blocked"
+                            ? "blocked"
+                            : envelope.decision === "done"
+                                ? "review"
+                                : storyStatusForEnvelope(envelope.story_status);
+                        next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
+                            ? {
+                                ...story,
+                                status: storyStatus,
+                                updated_at: nowIso,
+                                ...(envelope.decision === "blocked"
+                                    ? { blocked_reason: envelope.blocked_reason ?? "" }
+                                    : { blocked_reason: undefined }),
+                            }
+                            : story);
+                    }
+                    return next;
+                }, deps.dryRun);
                 if (result.changed) {
                     summary.dead_host.push({
                         id: lane.lane_id,

package/dist/lib/lanes/session-relink.d.ts

@@ -0,0 +1,25 @@
+import { type SessionCopyResult } from "./move-account.js";
+import type { LaneProvider } from "./types.js";
+export interface EnsureSessionHomeInput {
+    provider: Exclude<LaneProvider, "grok">;
+    sessionId: string;
+    cwd: string;
+    targetHome: string;
+    registeredHomes: string[];
+    providerHomeAtSpawn?: string;
+}
+export interface EnsureSessionHomeResult extends SessionCopyResult {
+    source_home: string;
+    transcript_path: string;
+    homes_searched: string[];
+}
+/**
+ * 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 declare function discoverSiblingAccountHomes(provider: EnsureSessionHomeInput["provider"], registeredHomes: string[]): string[];
+/** Find, copy, and verify a provider transcript in the home the next run uses. */
+export declare function ensureSessionHome(input: EnsureSessionHomeInput): EnsureSessionHomeResult;
+//# sourceMappingURL=session-relink.d.ts.map