@indigoai-us/hq-cli 5.148.0 → 5.150.0

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/admission.d.ts

@@ -0,0 +1,24 @@
+import type { LaneRecord, LanesConfig } from "./types.js";
+export interface AdmissionHost {
+    hostname: string;
+    outpostId: string | null;
+}
+export type AdmissionCapReason = "provider_cap" | "account_cap" | "profile_cap";
+export declare const ADMISSION_LOCK_STALE_MS = 30000;
+export declare const ADMISSION_LOCK_TIMEOUT_MS = 5000;
+export declare const ADMISSION_RESERVATION_GRACE_MS = 30000;
+export declare function withLaneAdmissionLock<T>(hqRoot: string, provider: LaneRecord["provider"], fn: () => Promise<T>, sleep?: (ms: number) => Promise<void>): Promise<T>;
+export declare function withAllLaneAdmissionLocks<T>(hqRoot: string, fn: () => Promise<T>, sleep?: (ms: number) => Promise<void>): Promise<T>;
+export declare function laneRunsOnHost(lane: LaneRecord, host: AdmissionHost): boolean;
+export declare function compareLaneQueueOrder(a: LaneRecord, b: LaneRecord): number;
+export declare function hasActiveAdmissionReservation(lane: LaneRecord, nowMs: number): boolean;
+export declare function hasActivePendingResume(lane: LaneRecord, nowMs: number): boolean;
+/** Return the first capacity limit that currently prevents this lane from starting. */
+export declare function laneAdmissionCapReason(lanes: LaneRecord[], candidate: LaneRecord, config: LanesConfig, host: AdmissionHost, profileMaxConcurrent?: number, nowMs?: number): AdmissionCapReason | undefined;
+/**
+ * A prior queue entry owns a free slot only when its own provider, account,
+ * and profile caps allow it to use that slot. A blocked profile therefore
+ * cannot hold an unrelated profile's queue position.
+ */
+export declare function hasEarlierEligibleQueuedLane(lanes: LaneRecord[], candidate: LaneRecord, config: LanesConfig, host: AdmissionHost, profileMaxFor: (lane: LaneRecord) => number | undefined, nowMs?: number): boolean;
+//# sourceMappingURL=admission.d.ts.map

package/dist/lib/lanes/admission.js

@@ -0,0 +1,193 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { accountMaxRunning } from "./config.js";
+import { LanesError } from "./errors.js";
+export const ADMISSION_LOCK_STALE_MS = 30_000;
+export const ADMISSION_LOCK_TIMEOUT_MS = 5_000;
+export const ADMISSION_RESERVATION_GRACE_MS = 30_000;
+function defaultAdmissionSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function admissionLockPath(hqRoot, provider) {
+    return path.join(hqRoot, "workspace", "lanes-runs", ".admission-locks", `${provider}-provider.lock`);
+}
+function admissionLockOwnerAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code !== "ESRCH";
+    }
+}
+async function withAdmissionLock(lockPath, fn, sleep) {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const started = Date.now();
+    while (true) {
+        let fd;
+        try {
+            fd = fs.openSync(lockPath, "wx");
+            const ownedStat = fs.fstatSync(fd);
+            try {
+                fs.writeSync(fd, Buffer.from(`${process.pid}\n${Date.now()}\n`, "utf8"));
+            }
+            catch (err) {
+                fs.closeSync(fd);
+                fd = undefined;
+                throw err;
+            }
+            try {
+                await new Promise((resolve) => setImmediate(resolve));
+                return await fn();
+            }
+            finally {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch (err) {
+                    process.stderr.write(`hq lanes: admission lock close failed for ${lockPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+                }
+                try {
+                    const currentStat = fs.statSync(lockPath);
+                    if (currentStat.dev === ownedStat.dev && currentStat.ino === ownedStat.ino) {
+                        fs.unlinkSync(lockPath);
+                    }
+                }
+                catch (err) {
+                    if (err.code !== "ENOENT") {
+                        process.stderr.write(`hq lanes: admission lock unlink failed for ${lockPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            if (Date.now() - started > ADMISSION_LOCK_TIMEOUT_MS) {
+                throw new LanesError("store_lock_timeout", `Timed out waiting for admission lock ${lockPath}`, { path: lockPath });
+            }
+            try {
+                const raw = fs.readFileSync(lockPath, "utf8");
+                const [ownerLine, timestampLine] = raw.split("\n");
+                const ownerPid = ownerLine ? Number(ownerLine) : NaN;
+                const timestamp = timestampLine ? Number(timestampLine) : NaN;
+                if (Number.isSafeInteger(ownerPid) &&
+                    ownerPid > 0 &&
+                    Number.isFinite(timestamp) &&
+                    Date.now() - timestamp > ADMISSION_LOCK_STALE_MS &&
+                    !admissionLockOwnerAlive(ownerPid)) {
+                    if (fs.readFileSync(lockPath, "utf8") !== raw)
+                        continue;
+                    try {
+                        fs.unlinkSync(lockPath);
+                    }
+                    catch (unlinkErr) {
+                        if (unlinkErr.code !== "ENOENT")
+                            throw unlinkErr;
+                    }
+                    continue;
+                }
+            }
+            catch (probeErr) {
+                if (probeErr.code !== "ENOENT") {
+                    process.stderr.write(`hq lanes: stale admission-lock probe failed for ${lockPath}: ${probeErr instanceof Error ? probeErr.message : String(probeErr)}\n`);
+                }
+            }
+            await sleep(10);
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    }
+}
+export function withLaneAdmissionLock(hqRoot, provider, fn, sleep = defaultAdmissionSleep) {
+    return withAdmissionLock(admissionLockPath(hqRoot, provider), fn, sleep);
+}
+export async function withAllLaneAdmissionLocks(hqRoot, fn, sleep = defaultAdmissionSleep) {
+    const providers = ["claude", "codex", "grok"];
+    const acquire = (index) => {
+        const provider = providers[index];
+        if (provider === undefined)
+            return fn();
+        return withLaneAdmissionLock(hqRoot, provider, () => acquire(index + 1), sleep);
+    };
+    return acquire(0);
+}
+export function laneRunsOnHost(lane, host) {
+    if (host.outpostId && lane.host.kind === "outpost") {
+        return lane.host.id === host.outpostId;
+    }
+    return lane.host.kind === "local" && lane.host.id === host.hostname;
+}
+export function compareLaneQueueOrder(a, b) {
+    if (b.priority !== a.priority)
+        return b.priority - a.priority;
+    const byQueueAge = Date.parse(a.queued_at ?? a.created_at) - Date.parse(b.queued_at ?? b.created_at);
+    return byQueueAge || a.lane_id.localeCompare(b.lane_id);
+}
+export function hasActiveAdmissionReservation(lane, nowMs) {
+    if (lane.state !== "queued" || lane.queued_reason !== undefined || !lane.admission_reserved_at) {
+        return false;
+    }
+    const reservedAt = Date.parse(lane.admission_reserved_at);
+    const ageMs = nowMs - reservedAt;
+    return Number.isFinite(reservedAt) && ageMs >= 0 && ageMs < ADMISSION_RESERVATION_GRACE_MS;
+}
+export function hasActivePendingResume(lane, nowMs) {
+    const pending = lane.pending_resume;
+    if (!pending)
+        return false;
+    const reservedAt = Date.parse(pending.at);
+    const ageMs = nowMs - reservedAt;
+    return Number.isFinite(reservedAt) && ageMs >= 0 && ageMs < ADMISSION_RESERVATION_GRACE_MS;
+}
+/** Return the first capacity limit that currently prevents this lane from starting. */
+export function laneAdmissionCapReason(lanes, candidate, config, host, profileMaxConcurrent, nowMs = Date.now()) {
+    const running = lanes.filter((lane) => lane.lane_id !== candidate.lane_id &&
+        (lane.state === "running" ||
+            hasActiveAdmissionReservation(lane, nowMs) ||
+            hasActivePendingResume(lane, nowMs)) &&
+        laneRunsOnHost(lane, host));
+    const providerCfg = config.providers[candidate.provider];
+    const providerRunning = running.filter((lane) => lane.provider === candidate.provider);
+    if (providerRunning.length >= providerCfg.max_running)
+        return "provider_cap";
+    if (candidate.account &&
+        providerRunning.filter((lane) => lane.account === candidate.account).length >=
+            accountMaxRunning(providerCfg, candidate.account)) {
+        return "account_cap";
+    }
+    if (candidate.worker_profile &&
+        profileMaxConcurrent !== undefined &&
+        running.filter((lane) => lane.worker_profile === candidate.worker_profile).length >=
+            profileMaxConcurrent) {
+        return "profile_cap";
+    }
+    return undefined;
+}
+/**
+ * A prior queue entry owns a free slot only when its own provider, account,
+ * and profile caps allow it to use that slot. A blocked profile therefore
+ * cannot hold an unrelated profile's queue position.
+ */
+export function hasEarlierEligibleQueuedLane(lanes, candidate, config, host, profileMaxFor, nowMs = Date.now()) {
+    return lanes
+        .filter((lane) => lane.lane_id !== candidate.lane_id &&
+        lane.state === "queued" &&
+        lane.provider === candidate.provider &&
+        laneRunsOnHost(lane, host) &&
+        compareLaneQueueOrder(lane, candidate) < 0)
+        .some((lane) => {
+        const profileMaxConcurrent = profileMaxFor(lane);
+        const capReason = laneAdmissionCapReason(lanes, lane, config, host, profileMaxConcurrent, nowMs);
+        if (capReason === undefined)
+            return true;
+        if (capReason !== "account_cap" || lane.admission_accounts === undefined)
+            return false;
+        return lane.admission_accounts.some((account) => {
+            if (account === lane.account || config.providers[lane.provider].accounts[account]?.enabled !== true) {
+                return false;
+            }
+            return laneAdmissionCapReason(lanes, { ...lane, account }, config, host, profileMaxConcurrent, nowMs) === undefined;
+        });
+    });
+}
+//# sourceMappingURL=admission.js.map

package/dist/lib/lanes/delivery.js

@@ -280,9 +280,11 @@ export function resumeCommandRefusal(lane) {
             error: "lane_not_resumable",
             message: `Lane is ${lane.state}. hq lanes resume continues a lane in ${RESUME_COMMAND_STATES.join(", ")}; ${lane.state === "awaiting_input"
                 ? "use hq lanes questions answer <question-id>."
-                : lane.state === "queued" || lane.state === "running"
-                    ? "use hq lanes message for a live lane."
-                    : "a lane in this state is not resumed."}`,
+                : lane.state === "queued"
+                    ? "use hq lanes admit <lane-id>."
+                    : lane.state === "running"
+                        ? "use hq lanes message for a live lane."
+                        : "a lane in this state is not resumed."}`,
         };
     }
     if (!providerSupportsSessionResume(lane.provider)) {

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

@@ -3,8 +3,11 @@
  */
 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 { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
+export type { AdmissionCapReason, AdmissionHost } from "./admission.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,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 { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.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, {