@indigoai-us/hq-cli 5.155.0 → 5.156.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [5.156.0] — 2026-09-24
+
+### Fixed
+
+- Project-thread lookup treats an omitted server `kind` as the project thread,
+  preventing duplicate project threads when a newer lane thread is present.
+- Lane admission reservations are refreshed after Work Mesh lane-thread
+  registration so slow registration cannot age the reservation before spawn.
+
+### Added
+
+- `hq mesh project register --channel` and `project set --channel` can bind an
+  existing channel to project events. `hq mesh check --project` shows lane
+  identity and status, including terminal lane threads.
+- Lane mesh threads keep a stable lane id across resume and account moves.
+  Events include the worker profile, model, account, parent lane, and senior
+  owner. Stop and dead-host recovery events close terminal threads.
+
+### Tests
+
+- Cover server-shaped project-thread results and reservation timing after
+  lane-thread registration.
+
 ## [5.155.0] — 2026-09-24
 
 ### Fixed

package/dist/command-catalog.generated.d.ts

@@ -5708,6 +5708,9 @@ export declare const COMMAND_CATALOG: readonly [{
             }, {
                 readonly flags: "--repo <path[@branch]>";
                 readonly description: "Repository binding (repeatable)";
+            }, {
+                readonly flags: "--channel <channelId>";
+                readonly description: "Bind the project to an existing company or project channel";
             }, {
                 readonly flags: "--create";
                 readonly description: "Create the Board view when the GET is a 404";
@@ -5754,7 +5757,7 @@ export declare const COMMAND_CATALOG: readonly [{
                 readonly description: "Company slug or cloud uid";
             }, {
                 readonly flags: "--channel <channelId>";
-                readonly description: "Reserved: the current server chooses the project channel";
+                readonly description: "Bind the project to an existing company or project channel";
             }, {
                 readonly flags: "--json";
                 readonly description: "Print machine-readable JSON";

package/dist/command-catalog.generated.js

@@ -7367,6 +7367,10 @@ export const COMMAND_CATALOG = [
                                 "flags": "--repo <path[@branch]>",
                                 "description": "Repository binding (repeatable)"
                             },
+                            {
+                                "flags": "--channel <channelId>",
+                                "description": "Bind the project to an existing company or project channel"
+                            },
                             {
                                 "flags": "--create",
                                 "description": "Create the Board view when the GET is a 404"
@@ -7427,7 +7431,7 @@ export const COMMAND_CATALOG = [
                             },
                             {
                                 "flags": "--channel <channelId>",
-                                "description": "Reserved: the current server chooses the project channel"
+                                "description": "Bind the project to an existing company or project channel"
                             },
                             {
                                 "flags": "--json",

package/dist/commands/lanes.js

@@ -18,7 +18,7 @@ import { buildOutpostLaneCommand, buildOutpostPickupCommand, createOutpostsClien
 import { parseUserYaml } from "../utils/user-yaml-error.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
-import { createLaneMesh, emitLaneDecisionEvents, } from "../lib/lanes/mesh-events.js";
+import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
@@ -1150,18 +1150,45 @@ function askDeliveryFailedPath(hqRoot, laneId) {
     return path.join(runDir(hqRoot, laneId), "ask_delivery_failed.json");
 }
 async function emitLaneMeshEvent(ctx, company, threadId, event, payload) {
-    if (!threadId || !company)
+    if (!company)
+        return;
+    let targetThreadId = threadId;
+    let eventPayload = payload;
+    const laneId = typeof payload.lane_id === "string" ? payload.lane_id.trim() : "";
+    if (laneId && ctx.mesh.ensureLaneThread) {
+        const lane = readLane(ctx.hqRoot(), laneId);
+        const ready = await ensureLaneThreadRecord(ctx, lane, lane.project_id, lane.story_id, "running");
+        targetThreadId = ready.thread_id;
+        eventPayload = { ...laneMeshEventIdentity(ready), ...payload };
+    }
+    if (!targetThreadId)
         return;
-    await ctx.mesh.appendThreadEvent(company, threadId, event, payload);
+    await ctx.mesh.appendThreadEvent(company, targetThreadId, event, eventPayload);
+}
+async function emitLaneTerminalStateSoft(ctx, lane) {
+    if (lane.state !== "failed" && lane.state !== "interrupted" &&
+        lane.state !== "cancelled" && lane.state !== "killed")
+        return;
+    try {
+        await emitLaneTerminalStateEvent(ctx.mesh, lane, lane.state, lane.terminal_reason, AbortSignal.timeout(10_000));
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: terminal mesh update failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
 }
 async function emitLaneStartedForStories(ctx, company, lane, threadId) {
-    if (!threadId)
+    const ready = ctx.mesh.ensureLaneThread
+        ? await ensureLaneThreadRecord(ctx, lane, lane.project_id, lane.story_id, "running")
+        : lane;
+    const stableThreadId = ready.thread_id ?? threadId;
+    if (!stableThreadId)
         return;
     const failures = [];
-    for (const story of laneStories(lane)) {
+    for (const story of laneStories(ready)) {
         try {
-            await emitLaneMeshEvent(ctx, company, threadId, "lane_started", {
-                lane_id: lane.lane_id,
+            await emitLaneMeshEvent(ctx, company, stableThreadId, "lane_started", {
+                ...laneMeshEventIdentity(ready),
+                lane_id: ready.lane_id,
                 project_id: story.project_id,
                 story_id: story.story_id,
             });
@@ -1630,9 +1657,8 @@ async function runCreate(ctx, opts) {
                     (profileAccounts === undefined || profileAccounts.includes(id)))
                     .map(([id]) => id))]
         : undefined;
-    const threadId = meshCompany
-        ? await ctx.mesh.ensureProjectThread(meshCompany, project)
-        : undefined;
+    // The lane id is created in `persist`; its Work Mesh thread is ensured
+    // immediately afterward from that stable identity.
     const persist = async () => {
         let admission;
         let validation;
@@ -1712,7 +1738,6 @@ async function runCreate(ctx, opts) {
                 added_at: createdAt,
                 updated_at: createdAt,
             })),
-            thread_id: threadId,
             depth: laneDepth,
             senior,
             senior_history: [],
@@ -1765,7 +1790,35 @@ async function runCreate(ctx, opts) {
     else {
         persisted = await withLaneAdmissionLock(hqRoot, provider, persist, ctx.sleep);
     }
-    const { lane, admission, validation } = persisted;
+    let lane = persisted.lane;
+    const { admission, validation } = persisted;
+    if (meshCompany) {
+        try {
+            lane = await ensureLaneThreadRecord(ctx, lane);
+        }
+        catch {
+            try {
+                lane = casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
+                    ...current,
+                    state: "failed",
+                    queued_reason: undefined,
+                    terminal_reason: "mesh_thread_registration_failed",
+                }));
+            }
+            catch {
+                throw new LanesError("mesh_thread_registration_failed", `Work Mesh lane registration failed for ${lane.lane_id}, and its local record could not be marked terminal.`, { lane_id: lane.lane_id });
+            }
+            throw new LanesError("mesh_thread_registration_failed", `Work Mesh lane registration failed; lane ${lane.lane_id} was marked failed.`, { lane_id: lane.lane_id, state: lane.state });
+        }
+    }
+    // Thread registration runs after persistence; anchor the reservation after
+    // its network work so a slow response cannot age the slot before spawn.
+    if (meshCompany && admission.action === "start" && lane.admission_reserved_at) {
+        lane = casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
+            ...current,
+            admission_reserved_at: ctx.now().toISOString(),
+        }));
+    }
     const dest = runDir(hqRoot, lane.lane_id);
     ensureDir(path.join(dest, "logs"));
     ensureDir(path.join(dest, "envelopes"));
@@ -1802,7 +1855,7 @@ async function runCreate(ctx, opts) {
             locateTranscript: ctx.locateTranscript,
         });
         if (meshCompany)
-            await emitLaneStartedForStories(ctx, meshCompany, started, threadId);
+            await emitLaneStartedForStories(ctx, meshCompany, started, started.thread_id);
     }
     else if (outpostId) {
         started = await dispatchCreatedOutpostLane(ctx, {
@@ -1864,13 +1917,15 @@ async function dispatchCreatedOutpostLane(ctx, input) {
         const dispatched = await ctx.dispatchOutpostExec({ outpostId, command });
         const remote = parseRemotePickupJson(dispatched.stdout);
         if (remote?.error === "outpost_self_target") {
-            return casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+            const cancelled = casUpdateLane(hqRoot, lane.lane_id, (current) => ({
                 ...current,
                 state: "cancelled",
                 queued_reason: undefined,
                 terminal_reason: "outpost_self_target",
                 outpost_command_id: dispatched.commandId,
             }));
+            await emitLaneTerminalStateSoft(ctx, cancelled);
+            return cancelled;
         }
         const stdoutTrimmed = dispatched.stdout.trim();
         if (remote === null && stdoutTrimmed !== "" && dispatched.status !== "Success") {
@@ -1882,6 +1937,7 @@ async function dispatchCreatedOutpostLane(ctx, input) {
                 stderr: dispatched.stderr.slice(0, 2000),
                 parse_error: "unparseable_pickup_stdout",
             });
+            await emitLaneTerminalStateSoft(ctx, failed);
             throw new LanesError(DISPATCH_TERMINAL_REASON, "Outpost pickup command failed", {
                 outpost_id: outpostId,
                 lane_id: failed.lane_id,
@@ -1899,6 +1955,7 @@ async function dispatchCreatedOutpostLane(ctx, input) {
                 status: dispatched.status,
                 stderr: dispatched.stderr.slice(0, 2000),
             });
+            await emitLaneTerminalStateSoft(ctx, failed);
             throw new LanesError(DISPATCH_TERMINAL_REASON, "Outpost pickup command failed", {
                 outpost_id: outpostId,
                 lane_id: failed.lane_id,
@@ -1923,6 +1980,7 @@ async function dispatchCreatedOutpostLane(ctx, input) {
             outpost_id: outpostId,
             message,
         });
+        await emitLaneTerminalStateSoft(ctx, failed);
         throw new LanesError(DISPATCH_TERMINAL_REASON, `Failed to dispatch lane to Outpost ${outpostId}: ${message}`, {
             outpost_id: outpostId,
             lane_id: failed.lane_id,
@@ -2126,6 +2184,7 @@ async function runPickup(ctx, opts) {
         env: ctx.env,
     });
     if (isTerminalLaneState(afterAccount.state)) {
+        await emitLaneTerminalStateSoft(ctx, afterAccount);
         printJson({
             ok: true,
             action: "pickup",
@@ -3150,17 +3209,32 @@ function callerMayVerifyStory(ctx, lane) {
         return false;
     return sessionIdFromEnv(ctx.env) === lane.senior.id;
 }
-async function ensureStoryThread(ctx, lane, projectId) {
+async function ensureStoryThread(ctx, lane, projectId, storyId = lane.story_id) {
+    const company = lane.mesh_company ?? lane.company;
+    if (!company)
+        return lane;
+    return ensureLaneThreadRecord(ctx, lane, projectId, storyId);
+}
+async function ensureLaneThreadRecord(ctx, lane, projectId = lane.project_id, storyId = lane.story_id, laneStatus = lane.state) {
     const company = lane.mesh_company ?? lane.company;
     if (!company)
         return lane;
-    const threadId = await ctx.mesh.ensureProjectThread(company, projectId);
-    if (threadId === lane.thread_id)
+    const descriptorLane = { ...lane, project_id: projectId, story_id: storyId };
+    const threadId = ctx.mesh.ensureLaneThread
+        ? await ctx.mesh.ensureLaneThread(company, descriptorLane, laneStatus)
+        : await ctx.mesh.ensureProjectThread(company, projectId);
+    if (threadId === lane.thread_id && !lane.thread_id.startsWith("proj-"))
         return lane;
-    return casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
+    const updated = casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
         ...current,
         thread_id: threadId,
     }));
+    // The CAS changes the lane version. Refresh once so the server descriptor
+    // and the durable local record converge before the worker starts.
+    if (ctx.mesh.ensureLaneThread) {
+        await ctx.mesh.ensureLaneThread(company, { ...updated, project_id: projectId, story_id: storyId }, laneStatus);
+    }
+    return updated;
 }
 async function emitStoryTransition(ctx, lane, projectId, storyId, event, status, payload = {}) {
     const company = lane.mesh_company ?? lane.company;
@@ -3174,6 +3248,7 @@ async function emitStoryTransition(ctx, lane, projectId, storyId, event, status,
         project_id: projectId,
         story_id: storyId,
         ...payload,
+        lane_status: lane.state,
     });
     await ctx.mesh.patchStoryStatus(company, projectId, storyId, status === "blocked" ? "in_progress" : status);
 }
@@ -3514,6 +3589,7 @@ async function runStop(ctx, laneId) {
             sleepMs: ctx.stopSleepMs,
         });
     }
+    await emitLaneTerminalStateSoft(ctx, updated);
     const cancelled = cancelPendingQuestionsForLane(hqRoot, laneId, at);
     printJson({
         ok: true,

package/dist/commands/mesh.js

@@ -59,14 +59,22 @@ export function formatCheckLines(threads, company, projectId) {
     const scope = projectId
         ? `${company.companySlug || company.companyUid}/${projectId}`
         : company.companySlug || company.companyUid;
-    const lines = [`Work mesh: ${threads.length} active thread(s) for ${scope}`];
+    const lines = [`Work mesh: ${threads.length} thread(s) for ${scope}`];
     for (const thread of threads.slice(0, 8)) {
         const owner = thread.ownerUid ? ` owner=${thread.ownerUid}` : "";
         const summary = thread.progressSummary ||
             thread.sourceSignalSummary ||
             thread.blockedReason ||
             "";
-        lines.push(`- ${thread.threadStatus ?? "unknown"} ${thread.threadId ?? "?"}${owner}${summary ? `: ${summary}` : ""}`);
+        const lane = thread.kind === "lane" ? thread.lane : undefined;
+        const laneDetails = lane
+            ? ` lane=${lane.laneId} laneStatus=${thread.laneStatus ?? "unknown"}` +
+                ` story=${lane.storyId ?? "unknown"} profile=${lane.workerProfile ?? "unknown"}` +
+                ` model=${lane.model ?? "unknown"} account=${lane.account ?? "unknown"}` +
+                `${lane.parentLaneId ? ` parent=${lane.parentLaneId}` : ""}`
+            : "";
+        const machine = thread.senderMachineUid ? ` machine=${thread.senderMachineUid}` : "";
+        lines.push(`- ${thread.threadStatus ?? "unknown"} ${thread.threadId ?? "?"}${owner}${machine}${laneDetails}${summary ? `: ${summary}` : ""}`);
     }
     return lines;
 }
@@ -320,6 +328,9 @@ function mergeProjectRepos(current, planned) {
     return [...planned, ...current.filter((repo) => !plannedPaths.has(repo.path))];
 }
 async function runProjectSet(projectId, opts) {
+    if (opts.channel !== undefined && !opts.channel.trim()) {
+        fail("PROJECT_CHANNEL_INVALID: --channel must be a non-empty channel id.");
+    }
     if (opts.storiesFile && opts.storiesJson) {
         fail("Pass only one of --stories-file or --stories-json.");
     }
@@ -358,6 +369,7 @@ async function runProjectSet(projectId, opts) {
     const principalUid = await resolveMeshPrincipalUid(token, loadCachedTokens());
     const PROJECT_CHANGED = "The Board changed while you were editing. Re-run to pick up the latest.";
     let view;
+    let registration;
     if (!current) {
         const ensured = await ensureProjectBoard({
             token,
@@ -367,10 +379,12 @@ async function runProjectSet(projectId, opts) {
             description: opts.description !== undefined ? opts.description : source?.description ?? "",
             stories: source?.stories ?? [],
             repos: explicitRepos ?? source?.repos ?? [],
+            channelId: opts.channel,
         });
         view = ensured.view;
+        registration = ensured.registration;
     }
-    else {
+    else if (opts.name !== undefined || opts.description !== undefined || source !== undefined || explicitRepos !== undefined) {
         try {
             view = await putProjectView(token, company.companyUid, projectId, {
                 name: opts.name?.trim() || source?.name || current.name,
@@ -395,18 +409,30 @@ async function runProjectSet(projectId, opts) {
             throw err;
         }
     }
+    else {
+        view = current;
+    }
+    if (current && opts.channel !== undefined) {
+        registration = await registerMeshProject(token, company.companyUid, projectId, opts.channel);
+    }
     if (!current && opts.create) {
         noteCallingSessionBound(view.projectId, company);
     }
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, action: "project.set", principalUid, ...view }, null, 2));
+        console.log(JSON.stringify({
+            ok: true,
+            action: "project.set",
+            principalUid,
+            ...view,
+            ...(registration ? { registration } : {}),
+        }, null, 2));
         return;
     }
     console.log(`Work mesh: project ${view.projectId} set (${view.name}; ${view.stories.length} stories)`);
 }
 async function runProjectRegister(projectId, opts) {
-    if (opts.channel?.trim()) {
-        fail("--channel is not supported by the current Work Mesh registration API; omit it to let the server create or bind the project channel.");
+    if (opts.channel !== undefined && !opts.channel.trim()) {
+        fail("PROJECT_CHANNEL_INVALID: --channel must be a non-empty channel id.");
     }
     const { token, company } = await withCompany(opts);
     const principalUid = await resolveMeshPrincipalUid(token, loadCachedTokens());
@@ -425,7 +451,7 @@ async function runProjectRegister(projectId, opts) {
     }
     let registration;
     try {
-        registration = await registerMeshProject(token, company.companyUid, projectId);
+        registration = await registerMeshProject(token, company.companyUid, projectId, opts.channel);
     }
     catch (err) {
         const failure = err;
@@ -1787,6 +1813,7 @@ export function registerMeshCommand(program) {
         .option("--stories-json <json>", "Story array or JSON object with userStories")
         .option("--repos-json <json>", "Repository array, such as [{path,branch}]")
         .option("--repo <path[@branch]>", "Repository binding (repeatable)", collectRepeatable)
+        .option("--channel <channelId>", "Bind the project to an existing company or project channel")
         .option("--create", "Create the Board view when the GET is a 404")
         .option("--json", "Print machine-readable JSON")
         .action((projectId, opts) => wrap(() => runProjectSet(projectId, opts))());
@@ -1801,7 +1828,7 @@ export function registerMeshCommand(program) {
         .command("register <projectId>")
         .description("Register an existing Board and bind its project channel; use project ensure to create or repair a Board")
         .requiredOption("--company <slug|uid>", "Company slug or cloud uid")
-        .option("--channel <channelId>", "Reserved: the current server chooses the project channel")
+        .option("--channel <channelId>", "Bind the project to an existing company or project channel")
         .option("--json", "Print machine-readable JSON")
         .action((projectId, opts) => wrap(() => runProjectRegister(projectId, opts))());
     mesh

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

@@ -42,11 +42,11 @@
  * of opening a browser nobody is watching, and the watcher records
  * `mesh_event_failed` and moves on. No credential file is read here.
  */
-import type { LaneCompanyRef, LaneEnvelope, LaneRecord } from "./types.js";
-export declare const LANE_MESH_EVENTS: readonly ["lane_started", "lane_progress", "lane_question", "lane_question_at_user", "lane_ask", "lane_blocked", "lane_done"];
+import type { LaneCompanyRef, LaneEnvelope, LaneRecord, TerminalLaneState } from "./types.js";
+export declare const LANE_MESH_EVENTS: readonly ["lane_started", "lane_progress", "lane_question", "lane_question_at_user", "lane_ask", "lane_blocked", "lane_done", "lane_failed", "lane_interrupted", "lane_cancelled", "lane_killed"];
 export type LaneMeshEvent = (typeof LANE_MESH_EVENTS)[number];
 /** Roster kinds this module emits. Subset of the server's `validKinds`. */
-export declare const WIRE_EVENT_KINDS: readonly ["run_started", "run_progress", "run_complete", "question", "note"];
+export declare const WIRE_EVENT_KINDS: readonly ["run_started", "run_progress", "run_complete", "blocked", "question", "note"];
 export type WireEventKind = (typeof WIRE_EVENT_KINDS)[number];
 /** Server caps: activity title/summary 2000, question text 500, note text 500. */
 export declare const WIRE_ACTIVITY_TEXT_MAX = 2000;
@@ -70,6 +70,7 @@ export declare function toWireThreadEvent(event: LaneMeshEvent, payload: Record<
  */
 export interface LaneMesh {
     ensureProjectThread: (company: LaneCompanyRef, projectId: string) => Promise<string>;
+    ensureLaneThread?: (company: LaneCompanyRef, lane: LaneRecord, laneStatus?: string, signal?: AbortSignal) => Promise<string>;
     appendThreadEvent: (company: LaneCompanyRef, threadId: string, event: LaneMeshEvent, payload: Record<string, unknown>, signal?: AbortSignal) => Promise<void>;
     patchStoryStatus: (company: LaneCompanyRef, projectId: string, storyId: string, status: string) => Promise<void>;
 }
@@ -92,6 +93,7 @@ export declare function createLaneMesh(opts?: CreateLaneMeshOptions): LaneMesh;
 export declare function laneMeshCompany(lane: Pick<LaneRecord, "company" | "mesh_company">): LaneCompanyRef | undefined;
 /** Company attribution + thread present. Unscoped personal lanes emit nothing. */
 export declare function laneCanEmit(lane: Pick<LaneRecord, "company" | "mesh_company" | "thread_id">): boolean;
+export declare function laneMeshEventIdentity(lane: LaneRecord): Record<string, unknown>;
 /**
  * Spec §8 terminal-envelope events. `done` → lane_done and story → review;
  * `blocked` → lane_blocked; `ask` → lane_ask with the queue ids. The story is
@@ -101,6 +103,8 @@ export declare function emitLaneDecisionEvents(mesh: LaneMesh, lane: LaneRecord,
     questionIds?: string[];
     signal?: AbortSignal;
 }): Promise<void>;
+/** Emit an abnormal terminal state even when the worker produced no envelope. */
+export declare function emitLaneTerminalStateEvent(mesh: LaneMesh, lane: LaneRecord, state: Exclude<TerminalLaneState, "done">, summary?: string, signal?: AbortSignal): Promise<void>;
 export declare function emitLaneProgressEvent(mesh: LaneMesh, lane: LaneRecord, detail: string, signal?: AbortSignal): Promise<void>;
 /**
  * Throttle for lane_progress (spec §8 progress row). True when no progress

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.156.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {