@indigoai-us/hq-cli 5.168.0 → 5.170.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [5.170.0] — 2026-09-24
+
+### Fixed
+
+- Switching the HQ session company (including `hq-session.sh set company_slug`) clears the Work Mesh project and task, posts `session_end` to the previous company, and holds a personal target as `needs_company`.
+
+## [5.169.0] — 2026-09-24
+
+### Fixed
+
+- `hq lanes create` and `hq lanes story <add|start|block|done>` keep story work
+  local when an existing Work Mesh Board rejects a missing story. The
+  `story_warning` identifies the project and story and suggests:
+  `hq mesh project ensure <projectId> --company <slug> --stories-file prd.json`.
+
 ## [5.168.0] — 2026-09-24
 
 ### Fixed

package/dist/commands/lanes.js

@@ -1340,13 +1340,23 @@ async function emitLaneTerminalStateSoft(ctx, lane) {
     }
 }
 async function emitLaneStartedForStories(ctx, company, lane, threadId) {
-    const ready = ctx.mesh.ensureLaneThread
-        ? await ensureLaneThreadRecord(ctx, lane, lane.project_id, lane.story_id, "running")
-        : lane;
+    let ready = lane;
+    if (ctx.mesh.ensureLaneThread) {
+        try {
+            ready = await ensureLaneThreadRecord(ctx, lane, lane.project_id, lane.story_id, "running");
+        }
+        catch (err) {
+            const warning = storyNotOnBoardWarning(err);
+            if (warning !== undefined)
+                return [warning];
+            throw err;
+        }
+    }
     const stableThreadId = ready.thread_id ?? threadId;
     if (!stableThreadId)
-        return;
+        return [];
     const failures = [];
+    const warnings = [];
     for (const story of laneStories(ready)) {
         try {
             await emitLaneMeshEvent(ctx, company, stableThreadId, "lane_started", {
@@ -1355,14 +1365,59 @@ async function emitLaneStartedForStories(ctx, company, lane, threadId) {
                 project_id: story.project_id,
                 story_id: story.story_id,
             });
-            await ctx.mesh.patchStoryStatus(company, story.project_id, story.story_id, "in_progress");
         }
         catch (err) {
+            const warning = storyNotOnBoardWarning(err);
+            if (warning !== undefined) {
+                warnings.push(warning);
+                continue;
+            }
             failures.push(err);
+            continue;
+        }
+        try {
+            await ctx.mesh.patchStoryStatus(company, story.project_id, story.story_id, "in_progress");
+        }
+        catch (err) {
+            const warning = storyNotOnBoardWarning(err);
+            if (warning !== undefined)
+                warnings.push(warning);
+            else
+                failures.push(err);
         }
     }
     if (failures.length > 0)
         throw failures[0];
+    return warnings;
+}
+async function assertStoriesOnBoard(ctx, company, projectId, storyIds) {
+    const check = ctx.mesh.assertProjectStoriesOnBoard;
+    if (!check) {
+        throw new LanesError("story_board_check_unavailable", "Cannot confirm stories are on the Work Mesh Board; refusing to write lane state", { project_id: projectId, story_id: storyIds[0] ?? null });
+    }
+    await check.call(ctx.mesh, company, projectId, storyIds);
+}
+function storyNotOnBoardWarning(err) {
+    return isLanesError(err) && err.error === "story_not_on_board"
+        ? err.message
+        : undefined;
+}
+function combinedStoryWarning(lane, additional = []) {
+    const warnings = [storyWarning(lane), ...additional]
+        .filter((warning) => warning !== undefined && warning.trim().length > 0);
+    return [...new Set(warnings)].join(" ") || null;
+}
+async function storyBoardWarning(ctx, company, projectId, storyIds) {
+    try {
+        await assertStoriesOnBoard(ctx, company, projectId, storyIds);
+        return undefined;
+    }
+    catch (err) {
+        const warning = storyNotOnBoardWarning(err);
+        if (warning !== undefined)
+            return warning;
+        throw err;
+    }
 }
 export const PICKUP_TERMINAL_REASONS = [
     "account_not_logged_in",
@@ -1631,6 +1686,12 @@ async function runCreate(ctx, opts) {
     }
     const seniorCompany = companyOfSenior(hqRoot, senior, ctx);
     assertSameTenant(company, senior, seniorCompany);
+    const createStoryWarnings = [];
+    if (meshCompany) {
+        const warning = await storyBoardWarning(ctx, meshCompany, project, storyIds);
+        if (warning !== undefined)
+            createStoryWarnings.push(warning);
+    }
     let resolvedWorker;
     if (opts.worker) {
         resolvedWorker = resolveLaneWorker(hqRoot, opts.worker, company?.slug);
@@ -2079,19 +2140,25 @@ async function runCreate(ctx, opts) {
         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 (err) {
+            const warning = storyNotOnBoardWarning(err);
+            if (warning !== undefined) {
+                createStoryWarnings.push(warning);
             }
-            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 });
+            else {
+                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 });
             }
-            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
@@ -2137,8 +2204,9 @@ async function runCreate(ctx, opts) {
             runCompaction: ctx.runCompaction,
             locateTranscript: ctx.locateTranscript,
         });
-        if (meshCompany)
-            await emitLaneStartedForStories(ctx, meshCompany, started, started.thread_id);
+        if (meshCompany) {
+            createStoryWarnings.push(...await emitLaneStartedForStories(ctx, meshCompany, started, started.thread_id));
+        }
     }
     else if (outpostId) {
         started = await dispatchCreatedOutpostLane(ctx, {
@@ -2174,7 +2242,7 @@ async function runCreate(ctx, opts) {
         project_id: started.project_id,
         story_id: started.story_id,
         stories: laneStories(started),
-        story_warning: storyWarning(started) ?? null,
+        story_warning: combinedStoryWarning(started, createStoryWarnings),
         thread_id: started.thread_id ?? null,
         senior: started.senior,
         depth: started.depth,
@@ -4138,6 +4206,17 @@ async function ensureStoryThread(ctx, lane, projectId, storyId = lane.story_id)
         return lane;
     return ensureLaneThreadRecord(ctx, lane, projectId, storyId);
 }
+async function ensureStoryThreadForTransition(ctx, lane, projectId, storyId) {
+    try {
+        return { lane: await ensureStoryThread(ctx, lane, projectId, storyId) };
+    }
+    catch (err) {
+        const warning = storyNotOnBoardWarning(err);
+        if (warning === undefined)
+            throw err;
+        return { lane, warning };
+    }
+}
 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)
@@ -4185,8 +4264,12 @@ function sameCommittedStory(current, expected, projectId, storyId) {
 async function commitStoryTransition(ctx, before, next, projectId, storyId, event, status, payload = {}) {
     try {
         await emitStoryTransition(ctx, next, projectId, storyId, event, status, payload);
+        return undefined;
     }
     catch (err) {
+        const warning = storyNotOnBoardWarning(err);
+        if (warning !== undefined)
+            return warning;
         try {
             const current = readLane(ctx.hqRoot(), next.lane_id);
             if (!sameCommittedStory(current, next, projectId, storyId)) {
@@ -4231,14 +4314,26 @@ async function runStoryAdd(ctx, laneId, storyId, opts) {
     const normalizedStoryId = storyId.trim();
     if (!normalizedStoryId)
         throw new LanesError("missing_story", "<story-id> is required", {});
+    const company = lane.mesh_company ?? lane.company;
+    const warnings = [];
+    if (company) {
+        const warning = await storyBoardWarning(ctx, company, projectId, [normalizedStoryId]);
+        if (warning !== undefined)
+            warnings.push(warning);
+    }
     const at = ctx.now().toISOString();
-    lane = await ensureStoryThread(ctx, lane, projectId);
+    const thread = await ensureStoryThreadForTransition(ctx, lane, projectId, normalizedStoryId);
+    lane = thread.lane;
+    if (thread.warning !== undefined)
+        warnings.push(thread.warning);
     const before = lane;
     const next = casUpdateLane(hqRoot, laneId, (current) => {
         assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
         return addCarriedStory(current, projectId, normalizedStoryId, at);
     });
-    await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress");
+    const transitionWarning = await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress");
+    if (transitionWarning !== undefined)
+        warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);
     printJson({
         ok: true,
@@ -4247,7 +4342,7 @@ async function runStoryAdd(ctx, laneId, storyId, opts) {
         project_id: projectId,
         story_id: normalizedStoryId,
         status: "in_progress",
-        story_warning: storyWarning(finalLane) ?? null,
+        story_warning: combinedStoryWarning(finalLane, warnings),
         lane: finalLane,
     });
 }
@@ -4264,15 +4359,21 @@ async function runStoryStart(ctx, laneId, storyId, opts) {
         });
     }
     const at = ctx.now().toISOString();
-    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const warnings = [];
+    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
+    lane = thread.lane;
+    if (thread.warning !== undefined)
+        warnings.push(thread.warning);
     const before = lane;
     const next = casUpdateLane(hqRoot, laneId, (current) => {
         assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
         return updateCarriedStory(current, target.projectId, target.storyId, "in_progress", at);
     });
-    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_started", "in_progress");
+    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_started", "in_progress");
+    if (transitionWarning !== undefined)
+        warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+    printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
 }
 async function runStoryBlock(ctx, laneId, storyId, opts) {
     const hqRoot = ctx.hqRoot();
@@ -4290,15 +4391,21 @@ async function runStoryBlock(ctx, laneId, storyId, opts) {
     if (!reason)
         throw new LanesError("missing_block_reason", "--reason is required", {});
     const at = ctx.now().toISOString();
-    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const warnings = [];
+    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
+    lane = thread.lane;
+    if (thread.warning !== undefined)
+        warnings.push(thread.warning);
     const before = lane;
     const next = casUpdateLane(hqRoot, laneId, (current) => {
         assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
         return updateCarriedStory(current, target.projectId, target.storyId, "blocked", at, { blocked_reason: reason });
     });
-    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_blocked", "blocked", { blocked_reason: reason });
+    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_blocked", "blocked", { blocked_reason: reason });
+    if (transitionWarning !== undefined)
+        warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.block", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "blocked", blocked_reason: reason, story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+    printJson({ ok: true, action: "story.block", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "blocked", blocked_reason: reason, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
 }
 async function runStoryDone(ctx, laneId, storyId, opts) {
     const hqRoot = ctx.hqRoot();
@@ -4323,7 +4430,11 @@ async function runStoryDone(ctx, laneId, storyId, opts) {
         });
     }
     const at = ctx.now().toISOString();
-    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const warnings = [];
+    const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
+    lane = thread.lane;
+    if (thread.warning !== undefined)
+        warnings.push(thread.warning);
     const before = lane;
     const next = casUpdateLane(hqRoot, laneId, (current) => {
         assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
@@ -4332,9 +4443,11 @@ async function runStoryDone(ctx, laneId, storyId, opts) {
             verified_by: current.senior,
         });
     });
-    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_done", "done", { summary: "Senior verification complete" });
+    const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_done", "done", { summary: "Senior verification complete" });
+    if (transitionWarning !== undefined)
+        warnings.push(transitionWarning);
     const finalLane = readLane(hqRoot, laneId);
-    printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+    printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
 }
 /**
  * Registration state of the drain hook in the lane's account home, read the

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

@@ -42,6 +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 { LanesError } from "./errors.js";
 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];
@@ -73,6 +74,8 @@ export interface LaneMesh {
     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>;
+    /** Read-only Board membership check before a command writes lane state. */
+    assertProjectStoriesOnBoard?: (company: LaneCompanyRef, projectId: string, storyIds: readonly string[]) => Promise<void>;
 }
 export interface CreateLaneMeshOptions {
     /** False for detached callers (the watcher). See the token note above. */
@@ -88,6 +91,7 @@ export interface CreateLaneMeshOptions {
         status: string;
     }) => Promise<void>;
 }
+export declare function storyNotOnBoardError(company: LaneCompanyRef, projectId: string, storyId: string): LanesError;
 export declare function createLaneMesh(opts?: CreateLaneMeshOptions): LaneMesh;
 /** Resolve the explicit mesh attribution before falling back to the lane tenant. */
 export declare function laneMeshCompany(lane: Pick<LaneRecord, "company" | "mesh_company">): LaneCompanyRef | undefined;

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

@@ -220,6 +220,31 @@ function isProjectViewNotFound(error) {
     return (candidate.code === "PROJECT_VIEW_NOT_FOUND" ||
         (typeof candidate.message === "string" && candidate.message.includes("PROJECT_VIEW_NOT_FOUND")));
 }
+function isUnknownProjectStory(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    return (candidate.status === 400 &&
+        candidate.code === "PROJECT_VIEW_INVALID" &&
+        typeof candidate.message === "string" &&
+        candidate.message.includes("Unknown story"));
+}
+function shellQuote(value) {
+    return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+export function storyNotOnBoardError(company, projectId, storyId) {
+    const command = "hq mesh project ensure " + shellQuote(projectId) +
+        " --company " + shellQuote(company.slug) +
+        " --stories-file '<prd.json>'";
+    const message = "Story " + JSON.stringify(storyId) + " is not on the Work Mesh Board for project " +
+        JSON.stringify(projectId) + ". Add it to the project PRD, then run: " + command;
+    return new LanesError("story_not_on_board", message, {
+        message,
+        project_id: projectId,
+        story_id: storyId,
+        command,
+    });
+}
 function isAlreadyRegistered(error) {
     if (!error || typeof error !== "object")
         return false;
@@ -293,18 +318,61 @@ export function createLaneMesh(opts = {}) {
                 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;
+            try {
+                const ensured = await ensureLaneMeshThread(tok, resolved, lane.project_id, descriptor, isMeshLaneStatus(laneStatus) ? laneStatus : "running", signal);
+                return ensured.threadId;
+            }
+            catch (error) {
+                if (lane.story_id && isUnknownProjectStory(error)) {
+                    throw storyNotOnBoardError(company, lane.project_id, lane.story_id);
+                }
+                throw error;
+            }
         },
         async appendThreadEvent(company, threadId, event, payload, signal) {
             const wire = toWireThreadEvent(event, payload);
             const tok = await token();
             await appendThreadEvent(tok, company.uid, threadId, wire.eventKind, wire.payload, signal);
         },
+        async assertProjectStoriesOnBoard(company, projectId, storyIds) {
+            if (storyIds.length === 0)
+                return;
+            const tok = await token();
+            let view;
+            try {
+                view = await getProjectView(tok, company.uid, projectId);
+            }
+            catch (error) {
+                // A missing Board has a separate, established repair path in
+                // patchStoryStatus. Keep it available; an existing Board is strict.
+                if (isProjectViewNotFound(error))
+                    return;
+                throw error;
+            }
+            if (view.companyUid !== company.uid || view.projectId !== projectId) {
+                throw new LanesError("project_board_scope_mismatch", "Work Mesh returned a Board for a different company or project", { project_id: projectId });
+            }
+            for (const storyId of storyIds) {
+                if (!view.stories.some((story) => story.id === storyId)) {
+                    throw storyNotOnBoardError(company, projectId, storyId);
+                }
+            }
+        },
         async patchStoryStatus(company, projectId, storyId, status) {
             const tok = await token();
+            const patch = async () => {
+                try {
+                    await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+                }
+                catch (error) {
+                    if (isUnknownProjectStory(error)) {
+                        throw storyNotOnBoardError(company, projectId, storyId);
+                    }
+                    throw error;
+                }
+            };
             try {
-                await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+                await patch();
             }
             catch (error) {
                 if (!isProjectViewNotFound(error))
@@ -316,7 +384,7 @@ export function createLaneMesh(opts = {}) {
                     storyId,
                     status,
                 });
-                await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+                await patch();
             }
         },
     };

package/dist/lib/mesh/live/flush.js

@@ -10,10 +10,12 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { resolveCompany } from "../../work-context/company.js";
+import { readMetaCompanySlug, resolveCompany } from "../../work-context/company.js";
+import { companyBindingChanged, reboundSessionProjection, } from "../../work-context/company-rebind.js";
 import { deriveRemoteOwnerSlug, deriveRepoIdentityKey, } from "../../work-context/repo-remote.js";
 import { rebindNeedsProjectOnPrompt } from "../../work-context/prompt-rebind.js";
-import { readSessionState, updateSessionState } from "../../work-context/state.js";
+import { readSessionState, updateSessionState, writeSessionState } from "../../work-context/state.js";
+import { generateUlid } from "./ulid.js";
 import { repairAckedRegisterStates } from "../../work-context/outbox.js";
 import { workContextRoot } from "../../work-context/paths.js";
 import { defaultSleep, FLUSH_MAX_ATTEMPTS, fullJitterDelayMs, } from "./backoff.js";
@@ -252,6 +254,23 @@ export async function flushSessionEvents(deps) {
             if (deps.signal?.aborted)
                 break sessionLoop;
             let state = readSessionState(sessionId, deps.workContextRoot);
+            state = applySessionMetaCompanyRebind(sessionId, items, state, deps, now);
+            const leaveResult = await postPresenceLeaveIfNeeded({
+                sessionId,
+                items,
+                state,
+                deps,
+                now,
+                maxAttempts,
+                sleep,
+                random,
+                summary,
+                markDisposed,
+            });
+            state = leaveResult.state;
+            if (leaveResult.abort)
+                continue;
+            const remainingItems = leaveResult.items;
             if (state?.companyConfidence === "device_default" &&
                 deps.authorizeDeviceDefaultTenant) {
                 const allowed = await deps.authorizeDeviceDefaultTenant(state);
@@ -259,7 +278,7 @@ export async function flushSessionEvents(deps) {
                 state = readSessionState(sessionId, deps.workContextRoot) ?? state;
                 if (!allowed) {
                     const heldAt = now().toISOString();
-                    for (const item of items) {
+                    for (const item of remainingItems) {
                         appendHeldLine(heldEnvelope(item.event, "NEEDS_COMPANY", item.heldAt ?? heldAt), deps.workMeshRoot);
                         summary.held += 1;
                         markDisposed(item.event);
@@ -269,33 +288,34 @@ export async function flushSessionEvents(deps) {
             }
             // After the company gate (which may restore a cleared company), try to
             // bind a needs_project session to an existing Board before classifying.
-            state = rebindUnboundSession(sessionId, items, state, deps, nowMs);
+            state = rebindUnboundSession(sessionId, remainingItems, state, deps, nowMs);
             const decision = classifySession(state);
             if (decision.action === "drop") {
                 appendDroppedReceipt({
                     v: 1,
                     sessionId,
-                    dropped: items.length,
+                    dropped: remainingItems.length,
                     reason: "untracked",
                     at: now().toISOString(),
                 }, deps.workMeshRoot);
-                summary.dropped += items.length;
-                for (const item of items)
+                summary.dropped += remainingItems.length;
+                for (const item of remainingItems)
                     markDisposed(item.event);
                 continue;
             }
             if (decision.action === "hold") {
                 const heldAt = now().toISOString();
-                for (const item of items) {
+                for (const item of remainingItems) {
                     appendHeldLine(heldEnvelope(item.event, decision.heldReason, item.heldAt ?? heldAt), deps.workMeshRoot);
                     summary.held += 1;
                     markDisposed(item.event);
                 }
                 continue;
             }
-            // Post a bounded portion of this session's backlog. Untouched events
-            // remain in pendingRestore and are put back on the spool below.
-            const flushItems = items.slice(0, SESSION_EVENTS_MAX_PER_SESSION_PER_FLUSH);
+            // Post a bounded portion of this session's remaining backlog (after any
+            // presence-leave). Untouched events stay in pendingRestore and are put
+            // back on the spool below.
+            const flushItems = remainingItems.slice(0, SESSION_EVENTS_MAX_PER_SESSION_PER_FLUSH);
             const stripped = flushItems.map((item) => stripLocalOnlyFields(item.event));
             for (let i = 0; i < stripped.length; i += SESSION_EVENTS_BATCH_MAX) {
                 const chunk = stripped.slice(i, i + SESSION_EVENTS_BATCH_MAX);
@@ -547,6 +567,135 @@ function eventText(event, key) {
     const value = event[key];
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+const SESSION_EVENT_HARNESSES = new Set([
+    "claude-code",
+    "claude-desktop",
+    "codex",
+    "grok",
+    "hq-sessions",
+    "agent-box",
+    "agents-v2",
+]);
+function applySessionMetaCompanyRebind(sessionId, items, state, deps, now) {
+    if (!state)
+        return state;
+    const hqRoot = items.map((item) => eventText(item.event, "hqRoot")).find(Boolean);
+    if (!hqRoot)
+        return state;
+    const meta = readMetaCompanySlug(sessionId, hqRoot);
+    if (!meta)
+        return state;
+    if (!companyBindingChanged(state, { slug: meta }))
+        return state;
+    const next = reboundSessionProjection({
+        prior: state,
+        sessionId,
+        nextSlug: meta,
+        nowIso: now().toISOString(),
+    });
+    writeSessionState(next, deps.workContextRoot);
+    return readSessionState(sessionId, deps.workContextRoot) ?? next;
+}
+function leaveContextStatus(leave) {
+    if (leave.projectId && leave.taskId)
+        return "bound";
+    if (leave.projectId)
+        return "needs_task";
+    return "needs_project";
+}
+function synthesizeSessionEnd(sessionId, sample, seq, at) {
+    const harnessRaw = eventText(sample, "harness");
+    const harness = harnessRaw && SESSION_EVENT_HARNESSES.has(harnessRaw)
+        ? harnessRaw
+        : "claude-code";
+    return stripLocalOnlyFields({
+        v: 1,
+        eventId: generateUlid(),
+        kind: "session_end",
+        sessionId,
+        harness,
+        adapterVersion: eventText(sample, "adapterVersion") || "1.0.0",
+        at,
+        seq,
+    });
+}
+async function postPresenceLeaveIfNeeded(input) {
+    const leave = input.state?.presenceLeave;
+    if (!leave?.companyUid) {
+        return { state: input.state, items: input.items, abort: false };
+    }
+    const oldSlug = leave.companySlug?.trim().toLowerCase();
+    const leaveItems = oldSlug
+        ? input.items.filter((item) => {
+            const slug = eventText(item.event, "companySlug")?.toLowerCase();
+            return slug === oldSlug;
+        })
+        : [];
+    const remaining = input.items.filter((item) => !leaveItems.includes(item));
+    const sample = leaveItems[0]?.event ?? input.items[0]?.event ?? {};
+    const maxSeq = input.items.reduce((max, item) => {
+        const seq = item.event.seq;
+        return typeof seq === "number" && Number.isFinite(seq) ? Math.max(max, seq) : max;
+    }, 0);
+    const sessionEnd = synthesizeSessionEnd(input.sessionId, sample, maxSeq + 1, input.now().toISOString());
+    const events = [
+        ...leaveItems.map((item) => stripLocalOnlyFields(item.event)),
+        sessionEnd,
+    ];
+    const body = {
+        contractVersion: 1,
+        companyUid: leave.companyUid,
+        sessionId: input.sessionId,
+        contextStatus: leaveContextStatus(leave),
+        events,
+    };
+    if (leave.bindingEpisodeId)
+        body.bindingEpisodeId = leave.bindingEpisodeId;
+    if (leave.projectId)
+        body.projectId = leave.projectId;
+    if (leave.taskId)
+        body.taskId = leave.taskId;
+    input.summary.batches += 1;
+    const result = await postBatchWithRetries(input.deps.poster, body, {
+        maxAttempts: input.maxAttempts,
+        sleep: input.sleep,
+        random: input.random,
+        signal: input.deps.signal,
+    });
+    if (!result.ok) {
+        const at = input.now().toISOString();
+        if (!result.retryable) {
+            for (const item of input.items) {
+                appendDeadLetterLine(deadLetterEnvelope(item.event, `HTTP_${result.status}`, result.status, at), input.deps.workMeshRoot);
+                input.summary.deadLettered += 1;
+                input.markDisposed(item.event);
+            }
+            return { state: input.state, items: [], abort: true };
+        }
+        for (const item of input.items) {
+            appendSpoolLine(JSON.stringify(canonicalizeForRestore(item.event)), input.deps.workMeshRoot);
+            input.summary.restored += 1;
+            input.markDisposed(item.event);
+        }
+        return { state: input.state, items: [], abort: true };
+    }
+    accountBatchSuccess({
+        accepted: events.length,
+        duplicates: 0,
+        rejected: [],
+    }, [...leaveItems, { event: sessionEnd }], input.deps.workMeshRoot, input.now, input.summary, input.markDisposed);
+    const cleared = updateSessionState(input.sessionId, input.deps.workContextRoot, (current) => {
+        if (!current)
+            return current;
+        const { presenceLeave: _leave, ...rest } = current;
+        return { ...rest, updatedAt: input.now().toISOString() };
+    });
+    return {
+        state: cleared ?? input.state,
+        items: remaining,
+        abort: false,
+    };
+}
 /**
  * Before a needs_project (or unresolved-with-company) batch is classified,
  * run the prompt-submit bind-best refinement. A bind updates the session

package/dist/lib/work-context/company-rebind.d.ts

@@ -0,0 +1,23 @@
+/**
+ * US-047: when the HQ session company changes, drop the old Work Mesh project
+ * and remember a presence leave for the previous company.
+ */
+import type { SessionStateFile } from "./state.js";
+export declare const NON_CLOUD_COMPANY_SLUG = "personal";
+export declare function isNonCloudCompanySlug(slug?: string | null): boolean;
+export declare function companyBindingChanged(prior: SessionStateFile | null | undefined, next: {
+    slug?: string;
+    uid?: string;
+}): boolean;
+export declare function presenceLeaveFromState(prior: SessionStateFile): NonNullable<SessionStateFile["presenceLeave"]> | undefined;
+export declare function reboundSessionProjection(input: {
+    prior: SessionStateFile;
+    sessionId: string;
+    nextSlug?: string;
+    nextUid?: string;
+    nowIso: string;
+    startedAt?: string;
+    toolWrites?: number;
+    hasTurn?: boolean;
+}): SessionStateFile;
+//# sourceMappingURL=company-rebind.d.ts.map

package/dist/lib/work-context/company-rebind.js

@@ -0,0 +1,59 @@
+/**
+ * US-047: when the HQ session company changes, drop the old Work Mesh project
+ * and remember a presence leave for the previous company.
+ */
+import { sameCompany } from "./company.js";
+import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
+export const NON_CLOUD_COMPANY_SLUG = "personal";
+export function isNonCloudCompanySlug(slug) {
+    return slug?.trim().toLowerCase() === NON_CLOUD_COMPANY_SLUG;
+}
+export function companyBindingChanged(prior, next) {
+    if (!prior)
+        return false;
+    if (!prior.companySlug && !prior.companyUid)
+        return false;
+    if (!next.slug && !next.uid)
+        return false;
+    return !sameCompany({ slug: prior.companySlug, uid: prior.companyUid }, next);
+}
+export function presenceLeaveFromState(prior) {
+    const uid = prior.companyUid?.trim();
+    if (!uid)
+        return undefined;
+    return {
+        companyUid: uid,
+        ...(prior.companySlug ? { companySlug: prior.companySlug } : {}),
+        ...(prior.projectId ? { projectId: prior.projectId } : {}),
+        ...(prior.taskId ? { taskId: prior.taskId } : {}),
+        ...(prior.bindingEpisodeId ? { bindingEpisodeId: prior.bindingEpisodeId } : {}),
+    };
+}
+export function reboundSessionProjection(input) {
+    const nonCloud = isNonCloudCompanySlug(input.nextSlug) || !input.nextUid;
+    const leave = presenceLeaveFromState(input.prior);
+    const out = {
+        contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+        sessionId: input.sessionId,
+        contextStatus: nonCloud ? "needs_company" : "needs_project",
+        updatedAt: input.nowIso,
+    };
+    if (input.nextSlug)
+        out.companySlug = input.nextSlug;
+    if (!nonCloud && input.nextUid)
+        out.companyUid = input.nextUid;
+    const startedAt = input.startedAt ?? input.prior.startedAt;
+    if (startedAt)
+        out.startedAt = startedAt;
+    if (typeof input.toolWrites === "number")
+        out.toolWrites = input.toolWrites;
+    else if (typeof input.prior.toolWrites === "number") {
+        out.toolWrites = input.prior.toolWrites;
+    }
+    if (input.hasTurn || input.prior.hasTurn)
+        out.hasTurn = true;
+    if (leave)
+        out.presenceLeave = leave;
+    return out;
+}
+//# sourceMappingURL=company-rebind.js.map

package/dist/lib/work-context/company.d.ts

@@ -3,8 +3,9 @@
  *
  * Order:
  *   1. trusted explicit (HQ_SPAWN_COMPANY env or observation.trustedContext/explicit)
- *   2. existing authoritative session scope
- *   3. session meta.yaml company_slug (/startwork)
+ *   2. existing authoritative session scope — unless session meta.yaml
+ *      names a different company (hq-session.sh rebind, US-047)
+ *   3. session meta.yaml company_slug (/startwork / hq-session.sh)
  *   4. agent-box identity file (HQ_AGENT_IDENTITY_FILE → companyUid; source
  *      trusted_explicit — never "default company mode"; below HQ_SPAWN_COMPANY,
  *      above device default)

package/dist/lib/work-context/company.js

@@ -3,8 +3,9 @@
  *
  * Order:
  *   1. trusted explicit (HQ_SPAWN_COMPANY env or observation.trustedContext/explicit)
- *   2. existing authoritative session scope
- *   3. session meta.yaml company_slug (/startwork)
+ *   2. existing authoritative session scope — unless session meta.yaml
+ *      names a different company (hq-session.sh rebind, US-047)
+ *   3. session meta.yaml company_slug (/startwork / hq-session.sh)
  *   4. agent-box identity file (HQ_AGENT_IDENTITY_FILE → companyUid; source
  *      trusted_explicit — never "default company mode"; below HQ_SPAWN_COMPANY,
  *      above device default)
@@ -254,12 +255,23 @@ export function resolveCompany(input) {
         ? input.existingState
         : readSessionState(input.sessionId, input.root);
     const prior = authoritativeCompanyFromState(state);
+    // 3. session meta.yaml company_slug — read before existing_scope so an
+    // operator rebind via hq-session.sh can replace a stale Work Mesh company.
+    const metaSlug = input.metaCompanySlug !== undefined
+        ? normalizeSlug(input.metaCompanySlug)
+        : readMetaCompanySlug(input.sessionId, input.hqRoot);
     if (prior) {
         const scoped = {
             slug: prior.slug,
             uid: prior.uid,
             source: "existing_scope",
         };
+        if (metaSlug && !sameCompany(scoped, { slug: metaSlug })) {
+            return {
+                status: "resolved",
+                company: { slug: metaSlug, source: "session_meta" },
+            };
+        }
         // Deterministic evidence from another company never silently replaces a
         // scoped session, even before it has a project binding. Preserve the
         // original scope and surface a conflict before tenant I/O.
@@ -288,10 +300,6 @@ export function resolveCompany(input) {
         }
         return { status: "resolved", company: scoped };
     }
-    // 3. session meta.yaml company_slug
-    const metaSlug = input.metaCompanySlug !== undefined
-        ? normalizeSlug(input.metaCompanySlug)
-        : readMetaCompanySlug(input.sessionId, input.hqRoot);
     if (metaSlug) {
         return {
             status: "resolved",

package/dist/lib/work-context/index.d.ts

@@ -12,6 +12,7 @@ export * from "./config.js";
 export * from "./state.js";
 export * from "./outbox.js";
 export * from "./company.js";
+export { companyBindingChanged, isNonCloudCompanySlug, presenceLeaveFromState, reboundSessionProjection, } from "./company-rebind.js";
 export * from "./project.js";
 export { decisionFromCandidates, digestOrganizePayload, formatOrganizeList, prepareOrganizeDecision, settleOrganizeAskWithoutBind, stableDecisionId, stableOrganizeOperationId, submitOrganizeDecision, } from "./organize.js";
 export type { CandidatesResponse, FetchCandidatesFn, OrganizeCandidate, OrganizeListResult, OrganizeReceipt, OrganizeSubmitDecision, OrganizeSubmitResult, PostOrganizeFn, } from "./organize.js";

package/dist/lib/work-context/index.js

@@ -12,6 +12,7 @@ export * from "./config.js";
 export * from "./state.js";
 export * from "./outbox.js";
 export * from "./company.js";
+export { companyBindingChanged, isNonCloudCompanySlug, presenceLeaveFromState, reboundSessionProjection, } from "./company-rebind.js";
 export * from "./project.js";
 export { decisionFromCandidates, digestOrganizePayload, formatOrganizeList, prepareOrganizeDecision, settleOrganizeAskWithoutBind, stableDecisionId, stableOrganizeOperationId, submitOrganizeDecision, } from "./organize.js";
 export { digestMigratePayload, formatMigrateConfirmation, stableMigrateOperationId, submitSessionMigration, } from "./migrate.js";

package/dist/lib/work-context/reconcile.js

@@ -5,6 +5,7 @@
 import * as fs from "node:fs";
 import { InvalidSessionIdentityError, normalizeSessionIdentity, } from "../mesh/live/session-identity.js";
 import { companyCorrectionPath, companySlugFromCwd, resolveCompany, } from "./company.js";
+import { companyBindingChanged, isNonCloudCompanySlug, presenceLeaveFromState, reboundSessionProjection, } from "./company-rebind.js";
 import { invalidateDefaultCompanyMemberships, } from "./config.js";
 import { WORK_CONTEXT_CONTRACT_VERSION, normalizeTaskId, } from "./contract.js";
 import { EXIT_INVALID_IDENTITY, EXIT_NOT_TRACKING, EXIT_OK, InvalidDecisionOriginError, NotTrackingError, } from "./errors.js";
@@ -354,6 +355,43 @@ export async function reconcileObservation(obs, deps) {
     // A device default is weak, cached evidence: validate it authoritatively on
     // every tenant-I/O path so a membership revocation takes effect immediately.
     let resolvedCompany = company.company;
+    if (isNonCloudCompanySlug(resolvedCompany.slug)) {
+        const projection = prior
+            ? reboundSessionProjection({
+                prior,
+                sessionId,
+                nextSlug: resolvedCompany.slug,
+                nowIso,
+                startedAt,
+                toolWrites,
+                hasTurn,
+            })
+            : {
+                contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+                sessionId,
+                contextStatus: "needs_company",
+                companySlug: resolvedCompany.slug,
+                updatedAt: nowIso,
+                startedAt,
+                ...(typeof toolWrites === "number" ? { toolWrites } : {}),
+                ...(hasTurn ? { hasTurn: true } : {}),
+            };
+        const statePath = writeSessionState(mergeLocalSessionFields({ ...projection, ...transcriptFields }, prior, { preserveBindingEpisode: false, preserveCompanyBinding: false }), deps.root);
+        diagnostics.push(`company rebind to ${resolvedCompany.slug}; cleared project; held (non-cloud)`);
+        return {
+            result: resultOf({
+                kind: "needs_company",
+                classification: "needs_company",
+                delivery: "clean",
+                sessionId,
+                clientOperationId: obs.clientOperationId,
+                companySlug: resolvedCompany.slug,
+            }),
+            exitCode: EXIT_OK,
+            diagnostics: [...diagnostics, "needs_company: non-cloud session company; no tenant I/O"],
+            statePath,
+        };
+    }
     const deviceDefaultRequiresValidation = resolvedCompany.source === "device_default";
     if (deviceDefaultRequiresValidation && !deps.validateMembership) {
         return {
@@ -385,6 +423,7 @@ export async function reconcileObservation(obs, deps) {
                     invalidateDefaultCompanyMemberships({ root: deps.root, now: nowFn });
                 }
                 diagnostics.push(`membership denied for slug=${resolvedCompany.slug}; treating as needs_company`);
+                const deniedLeave = prior ? presenceLeaveFromState(prior) : undefined;
                 const statePath = writeSessionState(mergeLocalSessionFields({
                     contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
                     sessionId,
@@ -395,7 +434,10 @@ export async function reconcileObservation(obs, deps) {
                     ...(typeof toolWrites === "number" ? { toolWrites } : {}),
                     ...(hasTurn ? { hasTurn: true } : {}),
                     ...transcriptFields,
-                }, prior), deps.root);
+                    ...(deniedLeave ? { presenceLeave: deniedLeave } : {}),
+                }, prior, companyBindingChanged(prior, resolvedCompany)
+                    ? { preserveBindingEpisode: false, preserveCompanyBinding: false }
+                    : {}), deps.root);
                 return {
                     result: resultOf({
                         kind: "needs_company",
@@ -431,13 +473,23 @@ export async function reconcileObservation(obs, deps) {
         }
     }
     // Company resolved — resolve project/task (US-007B order).
+    const companyRebind = companyBindingChanged(prior, resolvedCompany);
+    const projectPrior = companyRebind && prior
+        ? {
+            ...prior,
+            projectId: undefined,
+            taskId: undefined,
+            bindingEpisodeId: undefined,
+            contextStatus: "needs_project",
+        }
+        : prior;
     let projectResolved = resolveProjectTask({
         sessionId,
         env,
         trusted,
         cwd,
         hqRoot,
-        existingState: prior,
+        existingState: projectPrior,
     });
     // Deterministic cwd projects belong to the cwd company. A higher-precedence
     // identity UID must not adopt a project from an unrelated/unverified slug.
@@ -537,7 +589,7 @@ export async function reconcileObservation(obs, deps) {
         }
     }
     const projectHint = !projectId
-        ? (prior?.projectHint || projectResolved?.projectId)
+        ? (companyRebind ? projectResolved?.projectId : (prior?.projectHint || projectResolved?.projectId))
         : undefined;
     const bindResultFields = {
         ...(projectBindReason ? { projectBindReason } : {}),
@@ -634,6 +686,10 @@ export async function reconcileObservation(obs, deps) {
     // Do not let a weak later observation erase a server-acknowledged company
     // binding. Keep the result unresolved so the normal candidate threshold can
     // still advance the session, while preserving the durable emitter projection.
+    if (companyRebind && !projectId && resolvedCompany.uid) {
+        registerClassification = "needs_project";
+        diagnostics.push(`company rebind to ${resolvedCompany.slug ?? resolvedCompany.uid}; cleared project`);
+    }
     const stateClassification = registerClassification === "unresolved" &&
         prior?.contextStatus === "needs_project" &&
         prior.companyUid === resolvedCompany.uid &&
@@ -707,9 +763,12 @@ export async function reconcileObservation(obs, deps) {
         };
     }
     let outboxOp;
-    const companyConfidence = company.status === "resolved" && company.company.source === "device_default"
+    const companyConfidence = !companyRebind &&
+        company.status === "resolved" &&
+        company.company.source === "device_default"
         ? "device_default"
         : undefined;
+    const presenceLeave = companyRebind && prior ? presenceLeaveFromState(prior) : undefined;
     try {
         outboxOp = enqueueOutbox({
             clientOperationId: obs.clientOperationId,
@@ -762,9 +821,12 @@ export async function reconcileObservation(obs, deps) {
             ...(hasTurn ? { hasTurn: true } : {}),
             ...(decision ? { decision } : {}),
             ...(companyConfidence ? { companyConfidence } : {}),
+            ...(presenceLeave ? { presenceLeave } : {}),
             ...bindStateFields,
             ...transcriptFields,
-        }, prior);
+        }, prior, companyRebind
+            ? { preserveBindingEpisode: false, preserveCompanyBinding: false }
+            : {});
         statePath = writeSessionState(stateWrite, deps.root);
     }
     catch (err) {
@@ -871,6 +933,7 @@ export async function reconcileObservation(obs, deps) {
                 sessionId,
                 clientOperationId: obs.clientOperationId,
                 companyUid: resolvedCompany.uid,
+                companySlug: resolvedCompany.slug,
                 projectId,
                 taskId,
                 bindingEpisodeId: delivered.receiptId,

package/dist/lib/work-context/state.d.ts

@@ -106,6 +106,17 @@ export interface SessionStateFile {
     projectGate?: "choose" | "missing_board";
     /** Slug the session was trying to bind. Re-checked on the next prompt. */
     projectHint?: string;
+    /**
+     * LOCAL-ONLY. Pending session_end against a company this session just left
+     * (US-047). Flush posts it to that companyUid, then clears the field.
+     */
+    presenceLeave?: {
+        companyUid: string;
+        companySlug?: string;
+        projectId?: string;
+        taskId?: string;
+        bindingEpisodeId?: string;
+    };
     updatedAt: string;
 }
 /**

package/dist/lib/work-context/state.js

@@ -33,6 +33,7 @@ export const SESSION_STATE_ALLOWLIST = new Set([
     "projectCandidates",
     "projectGate",
     "projectHint",
+    "presenceLeave",
     "updatedAt",
 ]);
 const SESSION_STATE_LOCK_TIMEOUT_MS = 5_000;
@@ -240,6 +241,8 @@ export function projectSessionState(state) {
         out.projectGate = state.projectGate;
     if (state.projectHint && !state.projectId)
         out.projectHint = state.projectHint;
+    if (state.presenceLeave?.companyUid)
+        out.presenceLeave = state.presenceLeave;
     return out;
 }
 /**
@@ -298,9 +301,15 @@ export function mergeLocalSessionFields(next, prior, options = {}) {
     if (!out.companyConfidence && prior.companyConfidence && sameCompanyBinding) {
         out.companyConfidence = prior.companyConfidence;
     }
-    if (!out.projectId && !out.projectHint && prior.projectHint) {
+    if (!out.projectId &&
+        !out.projectHint &&
+        prior.projectHint &&
+        sameCompanyBinding) {
         out.projectHint = prior.projectHint;
     }
+    if (!out.presenceLeave && prior.presenceLeave) {
+        out.presenceLeave = prior.presenceLeave;
+    }
     if (out.projectId)
         out.projectHint = undefined;
     const sameBinding = prior.companyUid === out.companyUid &&

package/package.json

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