@indigoai-us/hq-cli 5.155.0 → 5.157.0

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, getProjectView, patchStoryStatus, putProjectView, requireToken, registerMeshProject, resolveMeshCompany, } from "../mesh/api.js";
+import { appendThreadEvent, clamp, ensureLaneMeshThread, ensureProjectThread, getProjectView, patchStoryStatus, putProjectView, requireToken, registerMeshProject, resolveMeshCompany, } from "../mesh/api.js";
 import { LanesError } from "./errors.js";
 export const LANE_MESH_EVENTS = [
     "lane_started",
@@ -52,12 +52,17 @@ export const LANE_MESH_EVENTS = [
     "lane_ask",
     "lane_blocked",
     "lane_done",
+    "lane_failed",
+    "lane_interrupted",
+    "lane_cancelled",
+    "lane_killed",
 ];
 /** Roster kinds this module emits. Subset of the server's `validKinds`. */
 export const WIRE_EVENT_KINDS = [
     "run_started",
     "run_progress",
     "run_complete",
+    "blocked",
     "question",
     "note",
 ];
@@ -94,6 +99,30 @@ function nonEmpty(text, fallback) {
 export function toWireThreadEvent(event, payload) {
     const kind = parseLaneMeshEvent(event);
     const id = identity(payload);
+    const laneId = str(payload.lane_id ?? payload.laneId).trim();
+    const senior = payload.senior && typeof payload.senior === "object" && !Array.isArray(payload.senior)
+        ? payload.senior
+        : undefined;
+    const lane = laneId
+        ? {
+            laneId,
+            ...(str(payload.story_id ?? payload.storyId) ? { storyId: str(payload.story_id ?? payload.storyId) } : {}),
+            ...(str(payload.worker_profile ?? payload.workerProfile) ? { workerProfile: str(payload.worker_profile ?? payload.workerProfile) } : {}),
+            ...(str(payload.model) ? { model: str(payload.model) } : {}),
+            ...(str(payload.account) ? { account: str(payload.account) } : {}),
+            ...(str(payload.parent_lane_id ?? payload.parentLaneId) ? { parentLaneId: str(payload.parent_lane_id ?? payload.parentLaneId) } : {}),
+            ...(senior && ["user", "session", "lane"].includes(String(senior.kind))
+                ? { senior: { kind: senior.kind, ...(typeof senior.id === "string" ? { id: senior.id } : {}) } }
+                : {}),
+            laneVersion: Number.isSafeInteger(Number(payload.lane_version ?? payload.laneVersion)) && Number(payload.lane_version ?? payload.laneVersion) > 0
+                ? Number(payload.lane_version ?? payload.laneVersion)
+                : 1,
+        }
+        : undefined;
+    const laneFields = (laneStatus) => ({
+        ...(lane ? { lane } : {}),
+        ...(laneStatus ? { laneStatus } : {}),
+    });
     switch (kind) {
         case "lane_started":
             return {
@@ -101,6 +130,7 @@ export function toWireThreadEvent(event, payload) {
                 payload: {
                     title: clamp(`lane_started ${str(payload.lane_id) || "unknown-lane"}`, WIRE_ACTIVITY_TEXT_MAX),
                     summary: clamp(`Lane ${id} started`, WIRE_ACTIVITY_TEXT_MAX),
+                    ...laneFields("running"),
                 },
             };
         case "lane_progress": {
@@ -109,29 +139,47 @@ export function toWireThreadEvent(event, payload) {
                 eventKind: "run_progress",
                 payload: {
                     summary: clamp(nonEmpty(`lane_progress ${id}${detail ? `: ${detail}` : ""}`, "lane_progress"), WIRE_ACTIVITY_TEXT_MAX),
+                    ...laneFields("running"),
                 },
             };
         }
         case "lane_done": {
             const summary = str(payload.summary);
+            const suppliedStatus = str(payload.lane_status ?? payload.laneStatus);
+            const laneStatus = isMeshLaneStatus(suppliedStatus) ? suppliedStatus : "done";
             return {
                 eventKind: "run_complete",
                 payload: {
                     title: clamp(`lane_done ${str(payload.lane_id) || "unknown-lane"}`, WIRE_ACTIVITY_TEXT_MAX),
                     summary: clamp(nonEmpty(`${id}: ${summary}`.replace(/:\s*$/, ""), `lane_done ${id}`), WIRE_ACTIVITY_TEXT_MAX),
+                    ...laneFields(laneStatus),
                 },
             };
         }
         case "lane_blocked": {
-            const reason = str(payload.blocked_reason);
-            // The roster's `blocked` event kind would flip the shared project
-            // thread, which spec §8 keeps lane events away from. Use the accepted
-            // audit note kind to preserve a filterable blocked marker.
+            const reason = str(payload.blocked_reason ?? payload.reason);
+            const suppliedStatus = str(payload.lane_status ?? payload.laneStatus);
+            const laneStatus = isMeshLaneStatus(suppliedStatus) ? suppliedStatus : "blocked";
             return {
-                eventKind: "note",
+                eventKind: "blocked",
                 payload: {
-                    text: clamp(`lane_blocked ${id}${reason ? `: ${reason}` : ""}`, WIRE_NOTE_TEXT_MAX),
-                    noteKind: "audit",
+                    reason: clamp(`lane_blocked ${id}${reason ? `: ${reason}` : ""}`, WIRE_NOTE_TEXT_MAX),
+                    ...laneFields(laneStatus),
+                },
+            };
+        }
+        case "lane_failed":
+        case "lane_interrupted":
+        case "lane_cancelled":
+        case "lane_killed": {
+            const laneStatus = kind.slice("lane_".length);
+            const summary = str(payload.summary ?? payload.reason ?? payload.blocked_reason);
+            return {
+                eventKind: "run_complete",
+                payload: {
+                    title: clamp(`${kind} ${str(payload.lane_id) || "unknown-lane"}`, WIRE_ACTIVITY_TEXT_MAX),
+                    summary: clamp(nonEmpty(`${id}: ${summary}`.replace(/:\s*$/, ""), `${kind} ${id}`), WIRE_ACTIVITY_TEXT_MAX),
+                    ...laneFields(laneStatus),
                 },
             };
         }
@@ -144,6 +192,7 @@ export function toWireThreadEvent(event, payload) {
             };
             if (questionId)
                 out.questionId = questionId;
+            Object.assign(out, laneFields());
             return { eventKind: "question", payload: out };
         }
         case "lane_ask": {
@@ -155,6 +204,7 @@ export function toWireThreadEvent(event, payload) {
             };
             if (ids[0])
                 out.questionId = ids[0];
+            Object.assign(out, laneFields("awaiting_input"));
             return { eventKind: "question", payload: out };
         }
         default: {
@@ -224,12 +274,28 @@ export function createLaneMesh(opts = {}) {
     return {
         async ensureProjectThread(company, projectId) {
             const tok = await token();
-            const resolved = await resolveMeshCompany(tok, company.slug);
+            const resolved = await resolveMeshCompany(tok, company.uid);
             const ensured = await ensureProjectThread(tok, resolved, projectId, {
                 summary: `HQ lane ${projectId}`,
             });
             return ensured.threadId;
         },
+        async ensureLaneThread(company, lane, laneStatus = lane.state, signal) {
+            const tok = await token();
+            const resolved = await resolveMeshCompany(tok, company.uid);
+            const descriptor = {
+                laneId: lane.lane_id,
+                ...(lane.story_id ? { storyId: lane.story_id } : {}),
+                ...(lane.worker_profile ? { workerProfile: lane.worker_profile } : {}),
+                ...(lane.model ? { model: lane.model } : {}),
+                ...(lane.account ? { account: lane.account } : {}),
+                ...(lane.senior.kind === "lane" ? { parentLaneId: lane.senior.id } : {}),
+                senior: { kind: lane.senior.kind, id: lane.senior.id },
+                laneVersion: lane.version,
+            };
+            const ensured = await ensureLaneMeshThread(tok, resolved, lane.project_id, descriptor, isMeshLaneStatus(laneStatus) ? laneStatus : "running", signal);
+            return ensured.threadId;
+        },
         async appendThreadEvent(company, threadId, event, payload, signal) {
             const wire = toWireThreadEvent(event, payload);
             const tok = await token();
@@ -263,34 +329,51 @@ export function laneMeshCompany(lane) {
 export function laneCanEmit(lane) {
     return laneMeshCompany(lane) !== undefined && !!lane.thread_id;
 }
-function baseIdentity(lane) {
+export function laneMeshEventIdentity(lane) {
     const lastMove = lane.account_history?.[lane.account_history.length - 1];
     return {
         lane_id: lane.lane_id,
         project_id: lane.project_id,
         story_id: lane.story_id,
+        worker_profile: lane.worker_profile,
+        model: lane.model,
+        lane_version: lane.version,
+        senior: { kind: lane.senior.kind, id: lane.senior.id },
+        ...(lane.senior.kind === "lane" ? { parent_lane_id: lane.senior.id } : {}),
         ...(lane.account !== undefined ? { account: lane.account } : {}),
         // A moved lane names the move on every event its run emits (US-023 §8).
         ...(lastMove !== undefined ? { account_move: { from: lastMove.from, to: lastMove.to, at: lastMove.at } } : {}),
     };
 }
+function isMeshLaneStatus(value) {
+    return ["queued", "running", "awaiting_input", "blocked", "done", "failed", "interrupted", "cancelled", "killed"].includes(value);
+}
+// hq-pro derives lane thread ids from company + lane identity; opaque ids may
+// be legacy shared project threads and must be migrated before a lane closes.
+const STABLE_LANE_THREAD_ID = /^lane-[0-9a-f]{32}$/;
+async function ensureLaneEventThread(mesh, company, lane, laneStatus, signal) {
+    if (mesh.ensureLaneThread && !STABLE_LANE_THREAD_ID.test(lane.thread_id ?? "")) {
+        return mesh.ensureLaneThread(company, lane, laneStatus, signal);
+    }
+    return lane.thread_id;
+}
 /**
  * Spec §8 terminal-envelope events. `done` → lane_done and story → review;
  * `blocked` → lane_blocked; `ask` → lane_ask with the queue ids. The story is
  * never set to `done` here: promotion belongs to the senior.
  */
 export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
-    if (!laneCanEmit(lane))
-        return;
     const company = laneMeshCompany(lane);
-    const threadId = lane.thread_id;
+    if (!company)
+        return;
+    const threadId = await ensureLaneEventThread(mesh, company, lane, lane.state, opts.signal);
     if (!company || !threadId)
         return;
     switch (envelope.decision) {
         case "done": {
             const outcomes = await Promise.allSettled([
                 mesh.appendThreadEvent(company, threadId, "lane_done", {
-                    ...baseIdentity(lane),
+                    ...laneMeshEventIdentity(lane),
                     summary: envelope.summary,
                 }, opts.signal),
                 mesh.patchStoryStatus(company, lane.project_id, lane.story_id, "review"),
@@ -304,7 +387,7 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
             {
                 const outcomes = await Promise.allSettled([
                     mesh.appendThreadEvent(company, threadId, "lane_blocked", {
-                        ...baseIdentity(lane),
+                        ...laneMeshEventIdentity(lane),
                         blocked_reason: envelope.blocked_reason ?? "",
                     }),
                     mesh.patchStoryStatus(company, lane.project_id, lane.story_id, "in_progress"),
@@ -322,7 +405,7 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
                 for (const questionId of opts.questionIds ?? []) {
                     try {
                         await mesh.appendThreadEvent(company, threadId, "lane_ask", {
-                            ...baseIdentity(lane),
+                            ...laneMeshEventIdentity(lane),
                             question_ids: [questionId],
                         }, opts.signal);
                     }
@@ -340,15 +423,28 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
         }
     }
 }
-export async function emitLaneProgressEvent(mesh, lane, detail, signal) {
-    if (!laneCanEmit(lane))
+/** Emit an abnormal terminal state even when the worker produced no envelope. */
+export async function emitLaneTerminalStateEvent(mesh, lane, state, summary, signal) {
+    const company = laneMeshCompany(lane);
+    if (!company)
         return;
+    const threadId = await ensureLaneEventThread(mesh, company, lane, state, signal);
+    if (!company || !threadId)
+        return;
+    await mesh.appendThreadEvent(company, threadId, `lane_${state}`, {
+        ...laneMeshEventIdentity(lane),
+        ...(summary ? { summary } : {}),
+    }, signal);
+}
+export async function emitLaneProgressEvent(mesh, lane, detail, signal) {
     const company = laneMeshCompany(lane);
-    const threadId = lane.thread_id;
+    if (!company)
+        return;
+    const threadId = await ensureLaneEventThread(mesh, company, lane, lane.state, signal);
     if (!company || !threadId)
         return;
     await mesh.appendThreadEvent(company, threadId, "lane_progress", {
-        ...baseIdentity(lane),
+        ...laneMeshEventIdentity(lane),
         detail,
     }, signal);
 }

package/dist/lib/lanes/reconcile.js

@@ -21,7 +21,7 @@ import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrot
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
 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 { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, 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";
@@ -1032,6 +1032,34 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                             }
                         }
                     }
+                    else if (!deps.dryRun &&
+                        (result.record.state === "failed" || result.record.state === "interrupted" ||
+                            result.record.state === "cancelled" || result.record.state === "killed")) {
+                        const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
+                        if (mesh) {
+                            const meshEmitTimeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+                            let timer;
+                            try {
+                                await Promise.race([
+                                    emitLaneTerminalStateEvent(mesh, result.record, result.record.state, result.record.terminal_reason),
+                                    new Promise((_resolve, reject) => {
+                                        timer = setTimeout(() => reject(new Error(`terminal mesh emit timed out after ${meshEmitTimeoutMs}ms`)), meshEmitTimeoutMs);
+                                    }),
+                                ]);
+                            }
+                            catch (err) {
+                                markDirty(summary, {
+                                    kind: "lane",
+                                    id: lane.lane_id,
+                                    why: `terminal mesh emit failed: ${err instanceof Error ? err.message : String(err)}`,
+                                });
+                            }
+                            finally {
+                                if (timer)
+                                    clearTimeout(timer);
+                            }
+                        }
+                    }
                 }
             }
             catch (err) {
@@ -1060,6 +1088,32 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     to: "interrupted",
                     reason: "host_lost",
                 });
+                const mesh = !deps.dryRun
+                    ? deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh
+                    : null;
+                if (mesh) {
+                    const meshEmitTimeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+                    let timer;
+                    try {
+                        await Promise.race([
+                            emitLaneTerminalStateEvent(mesh, result.record, "interrupted", "host_lost"),
+                            new Promise((_resolve, reject) => {
+                                timer = setTimeout(() => reject(new Error(`terminal mesh emit timed out after ${meshEmitTimeoutMs}ms`)), meshEmitTimeoutMs);
+                            }),
+                        ]);
+                    }
+                    catch (err) {
+                        markDirty(summary, {
+                            kind: "lane",
+                            id: lane.lane_id,
+                            why: `terminal mesh emit failed: ${err instanceof Error ? err.message : String(err)}`,
+                        });
+                    }
+                    finally {
+                        if (timer)
+                            clearTimeout(timer);
+                    }
+                }
             }
         }
         catch (err) {

package/dist/lib/lanes/watcher.js

@@ -44,7 +44,7 @@ import { PROVIDER_REJECTED_REASON, QUOTA_STATUS, isProviderLoginFailure, provide
 import { readToolActivity, toolActivityPath } from "./dropbox.js";
 import { loadLanesConfig, providerProgressEventMinIntervalMs, providerQuotaDefaultHoldMs } from "./config.js";
 import { resolveAdmissionHost as resolveProcessAdmissionHost } from "./admission-host.js";
-import { createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, progressEventDue, } from "./mesh-events.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, retryLaneOnAlternateAccount, } from "./spawn.js";
 /** Spec §5.7: no signal for 20 minutes while the process is still alive. */
@@ -586,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);
@@ -607,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);
             }
@@ -889,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.155.0",
+  "version": "5.157.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {