@indigoai-us/hq-cli 5.154.0 → 5.156.0

package/dist/lib/lanes/watcher.js

@@ -40,12 +40,13 @@ import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { readLane, retryUpdateLane } from "./store.js";
 import { readWorkerRunResult } from "./delivery.js";
 import { applyDefaultQuotaHold, quotaSignalFromFields, readQuotaSignal, recordAccountQuota, } from "./quota.js";
-import { PROVIDER_REJECTED_REASON, QUOTA_STATUS, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
+import { PROVIDER_REJECTED_REASON, QUOTA_STATUS, isProviderLoginFailure, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 import { readToolActivity, toolActivityPath } from "./dropbox.js";
 import { loadLanesConfig, providerProgressEventMinIntervalMs, providerQuotaDefaultHoldMs } from "./config.js";
-import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, progressEventDue, } from "./mesh-events.js";
+import { resolveAdmissionHost as resolveProcessAdmissionHost } from "./admission-host.js";
+import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, emitLaneTerminalStateEvent, progressEventDue, } from "./mesh-events.js";
 import { envelopeQuestionId } from "./questions.js";
-import { laneRunDir, missingPidProbe, probePidRecord, readPidRecord, readProcStarttime, readSpawnManifest, envelopeRepairMode, spawnEnvelopeRepair, } from "./spawn.js";
+import { laneRunDir, missingPidProbe, probePidRecord, readPidRecord, readProcStarttime, readSpawnManifest, envelopeRepairMode, spawnEnvelopeRepair, retryLaneOnAlternateAccount, } from "./spawn.js";
 /** Spec §5.7: no signal for 20 minutes while the process is still alive. */
 export const SILENCE_MS = 20 * 60 * 1000;
 export const WATCHER_POLL_MS = 5_000;
@@ -89,7 +90,12 @@ export function classifyLaneExit(input) {
         throw new LanesError("unknown_envelope_decision", `Unknown envelope decision ${JSON.stringify(input.envelope.decision)}. Accepted: done, ask, blocked`, { accepted: ["done", "ask", "blocked"], value: input.envelope.decision });
     }
     if (input.providerRejection) {
-        return { state: "failed", reason: PROVIDER_REJECTED_REASON };
+        return {
+            state: "failed",
+            reason: isProviderLoginFailure(input.providerRejection)
+                ? "account_not_logged_in"
+                : PROVIDER_REJECTED_REASON,
+        };
     }
     if (input.invalidEnvelope) {
         return { state: "failed", reason: ENVELOPE_INVALID_REASON };
@@ -580,20 +586,27 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
     const meshRequestTimeoutMs = deps.meshRequestTimeoutMs ?? 10_000;
     const initialLane = readLaneSoft(hqRoot, laneId);
     if (mesh && initialLane) {
-        // Explicit mesh attribution is the repair signal. Ordinary company lanes
-        // already receive their thread during create; legacy records without one
-        // stay quiet until an operator or the owning flow repairs them.
-        const company = initialLane.mesh_company;
-        if (company && !initialLane.thread_id) {
+        // Every armed watcher refreshes the server descriptor. This migrates old
+        // shared project threads and picks up account/model changes after resume.
+        const company = initialLane.mesh_company ?? initialLane.company ?? undefined;
+        if (company &&
+            (mesh.ensureLaneThread || !initialLane.thread_id || initialLane.thread_id.startsWith("proj-"))) {
             let timer;
             try {
                 const threadId = await Promise.race([
-                    mesh.ensureProjectThread(company, initialLane.project_id),
+                    mesh.ensureLaneThread
+                        ? mesh.ensureLaneThread(company, initialLane)
+                        : mesh.ensureProjectThread(company, initialLane.project_id),
                     new Promise((_resolve, reject) => {
                         timer = setTimeout(() => reject(new Error(`mesh thread ensure timed out after ${meshRequestTimeoutMs}ms`)), meshRequestTimeoutMs);
                     }),
                 ]);
-                retryUpdateLane(hqRoot, laneId, "spawn", (current) => current.thread_id ? current : { ...current, thread_id: threadId });
+                const updated = initialLane.thread_id === threadId
+                    ? initialLane
+                    : retryUpdateLane(hqRoot, laneId, "spawn", (current) => current.thread_id === threadId ? current : { ...current, thread_id: threadId });
+                if (mesh.ensureLaneThread && updated.version !== initialLane.version) {
+                    await mesh.ensureLaneThread(company, updated);
+                }
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -601,7 +614,7 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                 writeWatcherDecision(outPath, {
                     event: "mesh_event_failed",
                     at: new Date(now()).toISOString(),
-                    mesh_event: "ensure_project_thread",
+                    mesh_event: "ensure_lane_thread",
                     error: message,
                 }, outMax);
             }
@@ -613,6 +626,10 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
     }
     const progressIntervalMs = deps.progressEventMinIntervalMs ?? readProgressIntervalMs(hqRoot, readLaneSoft(hqRoot, laneId));
     const spawnRepair = deps.spawnRepair ?? spawnEnvelopeRepair;
+    const retryAccount = deps.retryAccount ?? ((root, lane, reason) => retryLaneOnAlternateAccount(root, lane, reason, "watcher", {
+        ...deps.retrySpawnDeps,
+        admissionHost: (deps.resolveAdmissionHost ?? resolveProcessAdmissionHost)(),
+    }));
     let lastSignalMs = now();
     let lastSeenMtime = 0;
     let lastAlive = null;
@@ -836,6 +853,32 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                         process.stderr.write(`hq lanes watcher: quota record failed for ${laneId}: ${err instanceof Error ? err.message : String(err)}\n`);
                     }
                 }
+                const accountRetryReason = quota
+                    ? "usage_limit"
+                    : isProviderLoginFailure(providerRejection)
+                        ? "account_unavailable"
+                        : null;
+                if (accountRetryReason && quotaLane?.account) {
+                    try {
+                        const retry = await retryAccount(hqRoot, quotaLane, accountRetryReason);
+                        logDecision({
+                            event: "account_failover",
+                            at: tick.emit.at,
+                            from: quotaLane.account,
+                            to: retry.account ?? null,
+                            reason: accountRetryReason,
+                            state: retry.state,
+                        });
+                        return;
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        process.stderr.write(`hq lanes watcher: account failover failed for ${laneId}: ${message}\n`);
+                        logDecision({ event: "account_failover_failed", at: tick.emit.at, reason: accountRetryReason, error: message });
+                        if (readLane(hqRoot, laneId).state !== "running")
+                            return;
+                    }
+                }
                 const terminalWrite = applyTerminalToLaneWithResult(hqRoot, laneId, classification, {
                     envelope,
                     envelopeRef: latest?.ref,
@@ -853,11 +896,17 @@ export async function runWatcherLoop(hqRoot, laneId, deps = {}) {
                 // Spec §8 terminal rows: done → lane_done + story review; blocked →
                 // lane_blocked; ask → lane_ask with the queue ids. After the state
                 // write, so a mesh failure can never leave the lane unclassified.
-                if (mesh && envelope && latest && terminalWrite.changed) {
-                    const questionIds = envelope.decision === "ask"
-                        ? envelopeQuestionIds(laneId, latest.ref, envelope)
-                        : undefined;
-                    await emitMeshSoft(`lane_${envelope.decision}`, logDecision, tick.emit.at, (signal) => emitLaneDecisionEvents(mesh, updated, envelope, { questionIds, signal }), meshRequestTimeoutMs);
+                if (mesh && terminalWrite.changed) {
+                    if (envelope && latest) {
+                        const questionIds = envelope.decision === "ask"
+                            ? envelopeQuestionIds(laneId, latest.ref, envelope)
+                            : undefined;
+                        await emitMeshSoft(`lane_${envelope.decision}`, logDecision, tick.emit.at, (signal) => emitLaneDecisionEvents(mesh, updated, envelope, { questionIds, signal }), meshRequestTimeoutMs);
+                    }
+                    else if (updated.state === "failed" || updated.state === "interrupted" ||
+                        updated.state === "cancelled" || updated.state === "killed") {
+                        await emitMeshSoft(`lane_${updated.state}`, logDecision, tick.emit.at, (signal) => emitLaneTerminalStateEvent(mesh, updated, updated.state, classification.reason, signal), meshRequestTimeoutMs);
+                    }
                 }
             }
         }

package/dist/lib/mesh/api.d.ts

@@ -16,13 +16,35 @@ export interface MeshThread {
     projectId?: string;
     companyUid?: string;
     threadStatus?: string;
+    kind?: "project" | "work-session" | "lane" | string;
+    lane?: MeshLaneDescriptor;
+    laneStatus?: MeshLaneStatus;
+    projectChannelId?: string;
     ownerUid?: string;
+    ownerType?: "human" | "agent";
+    senderMachineUid?: string;
+    senderPrincipalType?: "agent" | "outpost";
+    senderAuthenticatedSub?: string;
     progressSummary?: string;
     sourceSignalSummary?: string;
     blockedReason?: string;
     lastActivityAt?: string;
     createdAt?: string;
 }
+export type MeshLaneStatus = "queued" | "running" | "awaiting_input" | "blocked" | "done" | "failed" | "interrupted" | "cancelled" | "killed";
+export interface MeshLaneDescriptor {
+    laneId: string;
+    storyId?: string;
+    workerProfile?: string;
+    model?: string;
+    account?: string;
+    parentLaneId?: string;
+    senior?: {
+        kind: "user" | "session" | "lane";
+        id?: string;
+    };
+    laneVersion: number;
+}
 export interface MeshProjectStoryInput {
     id: string;
     title: string;
@@ -101,6 +123,10 @@ export declare function ensureProjectThread(token: string, company: MeshCompany,
     threadId: string;
     created: boolean;
 }>;
+/** Ensure the server-owned, stable Work Mesh thread for one lane. */
+export declare function ensureLaneMeshThread(token: string, company: MeshCompany, projectId: string, lane: MeshLaneDescriptor, laneStatus: MeshLaneStatus, signal?: AbortSignal): Promise<{
+    threadId: string;
+}>;
 export declare function appendThreadEvent(token: string, companyUid: string, threadId: string, eventKind: string, payload: Record<string, unknown>, signal?: AbortSignal): Promise<{
     eventId?: string;
     createdAt?: string;
@@ -138,7 +164,7 @@ export declare function putProjectView(token: string, companyUid: string, projec
     expectedVersion?: number;
 }): Promise<MeshProjectView>;
 /** Register the project genesis thread and deterministic project channel. */
-export declare function registerMeshProject(token: string, companyUid: string, projectId: string): Promise<MeshProjectRegistration>;
+export declare function registerMeshProject(token: string, companyUid: string, projectId: string, channelId?: string): Promise<MeshProjectRegistration>;
 export declare function pairDmUidsFromInbox(inbox: unknown): string[];
 export interface WarmCacheResult {
     directory: boolean;

package/dist/lib/mesh/api.js

@@ -229,21 +229,23 @@ async function listThreadsByStatus(token, companyUid) {
     return collected;
 }
 /**
- * Project threads are often missing from the status index. Prefer
- * `projectId` + `status=open`; if that combined query is rejected, fall
- * back to `projectId` alone.
+ * Project facets contain all project-owned threads, including terminal lane
+ * threads that have been removed from the active-status index.
  */
 async function listProjectThreads(token, companyUid, projectId) {
     try {
         return await listThreadsByQuery(token, {
             companyUid,
             projectId,
-            status: "open",
         });
     }
     catch {
         try {
-            return await listThreadsByQuery(token, { companyUid, projectId });
+            return await listThreadsByQuery(token, {
+                companyUid,
+                projectId,
+                status: "open",
+            });
         }
         catch {
             return [];
@@ -253,7 +255,10 @@ async function listProjectThreads(token, companyUid, projectId) {
 function mergeProjectAndStatusThreads(projectThreads, statusThreads, projectId) {
     const seen = new Set();
     const merged = [];
-    for (const thread of sortThreadsByActivity(projectThreads.filter((t) => (!t.projectId || t.projectId === projectId) && isActiveThread(t)))) {
+    for (const thread of sortThreadsByActivity(projectThreads.filter((t) => (!t.projectId || t.projectId === projectId) &&
+        (isActiveThread(t) ||
+            (t.kind === "lane" &&
+                ["done", "failed", "interrupted", "cancelled", "killed"].includes(String(t.laneStatus))))))) {
         const key = threadKey(thread);
         if (key) {
             if (seen.has(key))
@@ -312,7 +317,7 @@ export function eventPayload(kind, opts, claimedBy) {
 export async function ensureProjectThread(token, company, projectId, opts) {
     if (opts.threadId)
         return { threadId: opts.threadId, created: false };
-    const existing = (await listActiveThreads(token, company.companyUid, projectId))[0];
+    const existing = (await listActiveThreads(token, company.companyUid, projectId)).find((thread) => (thread.kind ?? "project") === "project" && !!thread.threadId);
     if (existing?.threadId)
         return { threadId: existing.threadId, created: false };
     const created = asRecord(await meshJson(token, "/v1/work-mesh/threads", {
@@ -332,6 +337,27 @@ export async function ensureProjectThread(token, company, projectId, opts) {
         throw new Error("Work mesh did not return a threadId");
     return { threadId, created: true };
 }
+/** Ensure the server-owned, stable Work Mesh thread for one lane. */
+export async function ensureLaneMeshThread(token, company, projectId, lane, laneStatus, signal) {
+    const result = asRecord(await meshJson(token, "/v1/work-mesh/threads", {
+        method: "POST",
+        body: {
+            companyUid: company.companyUid,
+            projectId,
+            routing: {
+                priority: "normal",
+                tags: ["hq-lane", `project:${projectId}`, `lane:${lane.laneId}`],
+            },
+            lane,
+            laneStatus,
+        },
+        signal,
+    }));
+    const threadId = typeof result?.threadId === "string" ? result.threadId.trim() : "";
+    if (!threadId)
+        throw new Error("Work mesh lane registration did not return a threadId");
+    return { threadId };
+}
 export async function appendThreadEvent(token, companyUid, threadId, eventKind, payload, signal) {
     const data = asRecord(await meshJson(token, `/v1/work-mesh/threads/${encodeURIComponent(threadId)}/events`, {
         method: "POST",
@@ -443,18 +469,21 @@ export async function putProjectView(token, companyUid, projectId, input) {
     return result;
 }
 /** Register the project genesis thread and deterministic project channel. */
-export async function registerMeshProject(token, companyUid, projectId) {
-    const result = asRecord(await meshJson(token, `/v1/work-mesh/projects/${encodeURIComponent(projectId)}/register`, { method: "POST", body: { companyUid } }));
+export async function registerMeshProject(token, companyUid, projectId, channelId) {
+    if (channelId !== undefined && !channelId.trim()) {
+        throw new Error("PROJECT_CHANNEL_INVALID: channelId must be non-empty");
+    }
+    const result = asRecord(await meshJson(token, `/v1/work-mesh/projects/${encodeURIComponent(projectId)}/register`, { method: "POST", body: { companyUid, ...(channelId ? { channelId: channelId.trim() } : {}) } }));
     const threadId = String(result?.threadId || "").trim();
-    const channelId = String(result?.channelId || "").trim();
-    if (!threadId || !channelId) {
+    const registeredChannelId = String(result?.channelId || "").trim();
+    if (!threadId || !registeredChannelId) {
         throw new Error("Work mesh registration did not return a threadId and channelId");
     }
     return {
         companyUid: String(result?.companyUid || companyUid).trim(),
         projectId: String(result?.projectId || projectId).trim(),
         threadId,
-        channelId,
+        channelId: registeredChannelId,
         channelCreated: result?.channelCreated === true,
     };
 }

package/dist/lib/mesh/project-board.d.ts

@@ -41,6 +41,7 @@ export declare function ensureProjectBoard(input: {
     description?: string;
     stories: MeshProjectStoryInput[];
     repos?: MeshProjectRepo[];
+    channelId?: string;
 }): Promise<{
     view: MeshProjectView;
     registration: MeshProjectRegistration;

package/dist/lib/mesh/project-board.js

@@ -125,7 +125,7 @@ export async function ensureProjectBoard(input) {
         stories: input.stories,
         repos: input.repos ?? [],
     });
-    const registration = await registerMeshProject(input.token, input.company.companyUid, input.projectId);
+    const registration = await registerMeshProject(input.token, input.company.companyUid, input.projectId, input.channelId);
     await closeSupersededProjectThread({
         token: input.token,
         companyUid: input.company.companyUid,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.154.0",
+  "version": "5.156.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {