@indigoai-us/hq-cli 5.345.134 → 5.345.136

package/dist/lib/lanes/monitor.js

@@ -354,12 +354,24 @@ const WATCH_RUNTIME_EXECUTABLES = ["bun", "deno", "node", "nodejs", "ts-node", "
 // on the raw line, then validate whatever precedes it as an hq invocation.
 // A path form (absolute or ./, ../) is required so an unrelated leading
 // command such as "vim /tmp/hq" is not absorbed into the path.
+//
+// Package managers that install the bin through a shell shim (pnpm, some
+// volta/yarn setups) exec the runtime with the package entrypoint instead of
+// the hq symlink, so the ps line reads
+// "node .../node_modules/@indigoai-us/hq-cli/dist/index.js lanes watch ...".
+// Accept that entrypoint path as an hq executable too.
+const HQ_CLI_ENTRYPOINT_SUFFIX = "/hq-cli/dist/index.js";
 function isHqExecutablePath(candidate) {
     if (candidate === "hq")
         return true;
-    if (!/^\.{0,2}\//u.test(candidate) || path.basename(candidate) !== "hq") {
+    if (!/^\.{0,2}\//u.test(candidate))
+        return false;
+    const isHqBin = path.basename(candidate) === "hq";
+    const isHqEntrypoint = candidate
+        .replace(/\\/gu, "/")
+        .endsWith(HQ_CLI_ENTRYPOINT_SUFFIX);
+    if (!isHqBin && !isHqEntrypoint)
         return false;
-    }
     return !candidate.split(" ").some((piece) => piece.startsWith("-"));
 }
 function isHqInvocationPrefix(prefix) {

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

@@ -66,6 +66,8 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    /** Builds the lane's fingerprint from the worker env. Defaults to laneStartFingerprint. */
+    buildFingerprint?: (hqRoot: string, workerEnv: NodeJS.ProcessEnv) => string | null;
     /** Test seam for the default-off quota account failover registry gate. */
     quotaAccountFailoverEnabled?: boolean;
     /** Return the selected retry transition without writing or starting a worker. */
@@ -255,7 +257,23 @@ export declare function buildProviderCommand(provider: LaneProvider, input: {
 export declare function workerEnv(base: NodeJS.ProcessEnv, resolved: {
     envVar: string;
     home: string;
-}, laneId: string, hqRoot: string, autoCompactTokens?: number, meshCompany?: LaneCompanyRef, workerPolicyDir?: string, registryWorker?: LaneRecord["registry_worker"], homedir?: () => string): NodeJS.ProcessEnv;
+}, laneId: string, hqRoot: string, autoCompactTokens?: number, meshCompany?: LaneCompanyRef, workerPolicyDir?: string, registryWorker?: LaneRecord["registry_worker"], homedir?: () => string, session?: WorkerSessionEnv): NodeJS.ProcessEnv;
+/** Session ids a worker must not inherit from the process that spawns it. */
+export declare const WORKER_SESSION_ENV_VARS: readonly ["HQ_SESSION_ID", "CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "GROK_SESSION_ID"];
+/**
+ * The worker's fingerprint, built offline from the worker env at lane start.
+ * Null when it cannot be built (no identity and no session id, or an error);
+ * the lane still starts.
+ */
+export declare function laneStartFingerprint(hqRoot: string, env: NodeJS.ProcessEnv): string | null;
+export interface WorkerSessionEnv {
+    /** The worker's own provider session id, when known before launch. */
+    workerSessionId?: string;
+    /** The senior's session id, when the senior is a session. */
+    parentSessionId?: string;
+}
+/** The session identity a lane turn exports to its worker (see `workerEnv`). */
+export declare function laneWorkerSessionEnv(lane: Pick<LaneRecord, "senior">, workerSessionId: string | undefined): WorkerSessionEnv;
 export declare const WORKER_POLICY_HOOK_CAPABILITY = "# hq-capability: worker-policy-dir v1";
 /** Grok does not run HQ hooks; Claude and Codex use the installed capability marker. */
 export declare function workerPolicyDeliveryMode(hqRoot: string, provider: LaneProvider): "hook" | "prompt";

package/dist/lib/lanes/spawn.js

@@ -42,6 +42,8 @@ import { MESSAGE_REPLAY_STATE_NAME } from "./message-replay.js";
 import { markAnsweredQuestionsDelivered } from "./questions.js";
 import { hasEarlierEligibleQueuedLane, laneAdmissionCapReason, withLaneAdmissionLock, } from "./admission.js";
 import { resolveAdmissionHost } from "./admission-host.js";
+import { offlineFingerprint } from "../fingerprint/offline.js";
+import { SESSION_ID_ENV_VARS } from "../fingerprint/self-core.js";
 import { checkLaneDiskSpace, laneDiskAccount } from "./disk-guard.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, ENVELOPE_INVALID_REASON, parseLaneProvider, } from "./types.js";
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
@@ -1661,7 +1663,7 @@ export function buildProviderCommand(provider, input) {
         args: appendFastModeFlags(parsed, appendEffortFlag(parsed, appendModelFlag(parsed, appendCodexWorkerPolicyDirFlag(parsed, appendProviderProfileFlags(parsed, args, input.profile), input.workerPolicyDir), input.model), input.effort), input.fastMode),
     };
 }
-export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, meshCompany, workerPolicyDir, registryWorker, homedir) {
+export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, meshCompany, workerPolicyDir, registryWorker, homedir, session) {
     const accepted = Object.values(PROVIDER_HOME_ENV);
     if (!accepted.includes(resolved.envVar)) {
         throw new LanesError("unknown_provider_home_env", `Unknown provider home variable ${JSON.stringify(resolved.envVar)}. Accepted: ${accepted.join(", ")}`, { accepted, value: resolved.envVar });
@@ -1704,8 +1706,48 @@ export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, mes
     else {
         delete env.HQ_SPAWN_COMPANY;
     }
+    if (meshCompany?.slug) {
+        env.HQ_COMPANY = meshCompany.slug;
+    }
+    else {
+        delete env.HQ_COMPANY;
+    }
+    // Session identity precedence for the worker (the fingerprint builder and
+    // the commit-msg hook read HQ_SESSION_ID first, then the harness ids):
+    // 1. HQ_SESSION_ID is the worker's own session, the id `--resume` would
+    //    use. It is set only when that id is known before launch (a resume, or
+    //    a remote-control lane whose id hq-cli mints). A cold first turn leaves
+    //    it unset rather than guessing.
+    // 2. The harness ids (CLAUDE_CODE_SESSION_ID and the rest) are set by the
+    //    worker's own CLI once it starts. Values inherited from the senior are
+    //    dropped so a worker never reports the senior's session as its own.
+    // HQ_PARENT_SESSION_ID names the senior session when the senior is one.
+    for (const name of WORKER_SESSION_ENV_VARS)
+        delete env[name];
+    delete env.HQ_PARENT_SESSION_ID;
+    if (session?.workerSessionId)
+        env.HQ_SESSION_ID = session.workerSessionId;
+    if (session?.parentSessionId)
+        env.HQ_PARENT_SESSION_ID = session.parentSessionId;
     return env;
 }
+/** Session ids a worker must not inherit from the process that spawns it. */
+export const WORKER_SESSION_ENV_VARS = SESSION_ID_ENV_VARS;
+/**
+ * The worker's fingerprint, built offline from the worker env at lane start.
+ * Null when it cannot be built (no identity and no session id, or an error);
+ * the lane still starts.
+ */
+export function laneStartFingerprint(hqRoot, env) {
+    return offlineFingerprint(hqRoot, env, "hq lanes");
+}
+/** The session identity a lane turn exports to its worker (see `workerEnv`). */
+export function laneWorkerSessionEnv(lane, workerSessionId) {
+    return {
+        ...(workerSessionId ? { workerSessionId } : {}),
+        ...(lane.senior.kind === "session" && lane.senior.id ? { parentSessionId: lane.senior.id } : {}),
+    };
+}
 export const WORKER_POLICY_HOOK_CAPABILITY = "# hq-capability: worker-policy-dir v1";
 function installedWorkerPolicyHookSupportsDirectory(hqRoot) {
     const hookPath = path.join(hqRoot, ".claude", "hooks", "inject-policy-on-trigger.sh");
@@ -2445,9 +2487,13 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const autoCompactTokens = lane.provider === "claude"
         ? providerAutoCompactTokens(config.providers.claude)
         : undefined;
-    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: remoteControlHome ?? resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined, workerPolicyDir, lane.registry_worker);
+    const remoteSessionId = existing.remote_control === true
+        ? plan.mode === "resume" ? plan.session_id : randomUUID()
+        : undefined;
+    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: remoteControlHome ?? resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined, workerPolicyDir, lane.registry_worker, undefined, laneWorkerSessionEnv(existing, plan.mode === "resume" ? plan.session_id : remoteSessionId));
     const laneTurnId = randomUUID();
     childEnv.HQ_LANE_TURN_ID = laneTurnId;
+    const fingerprint = (deps.buildFingerprint ?? laneStartFingerprint)(hqRoot, childEnv);
     const model = resolveLaneModel({
         cliModel: pinnedModel,
         profileModel,
@@ -2507,9 +2553,6 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             }),
         }
         : undefined;
-    const remoteSessionId = existing.remote_control === true
-        ? plan.mode === "resume" ? plan.session_id : randomUUID()
-        : undefined;
     const providerCommand = buildProviderCommand(lane.provider, {
         hqRoot,
         briefPath,
@@ -2682,6 +2725,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             pending_settings: undefined,
             account: resolved.id,
             provider_home_at_spawn: remoteControlHome ?? resolved.home,
+            fingerprint,
             working_directory_at_spawn: workerCwd,
             ...(model !== undefined ? { model } : {}),
             ...(model !== undefined
@@ -3094,7 +3138,7 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
     const autoCompactTokens = lane.provider === "claude"
         ? providerAutoCompactTokens(config.providers.claude)
         : undefined;
-    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined, workerPolicyDir, lane.registry_worker);
+    const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined, workerPolicyDir, lane.registry_worker, undefined, laneWorkerSessionEnv(lane, mode === "resume" && sessionId !== null ? sessionId : undefined));
     const accountCfg = config.providers[lane.provider].accounts[resolved.id];
     const model = resolveLaneModel({
         cliModel: pinnedModel,

package/dist/lib/lanes/story-ledger.d.ts

@@ -54,6 +54,7 @@ export interface LaneStatusSnapshot {
         no_story_reason: string | null;
         state: LaneState;
         queued_reason: string | null;
+        fingerprint: string | null;
     }>;
     prs: Array<{
         story_id: string;

package/dist/lib/lanes/story-ledger.js

@@ -812,6 +812,7 @@ export function buildLaneStatusSnapshot(input) {
         no_story_reason: lane.no_story_reason ?? null,
         state: lane.state,
         queued_reason: lane.queued_reason ?? null,
+        fingerprint: lane.fingerprint ?? null,
     }));
     const projectPrs = [];
     const blockers = [];
@@ -905,7 +906,8 @@ export function formatLaneStatusHuman(snapshot) {
                 const account = worker.account ? " account " + worker.account : "";
                 const queued = worker.queued_reason ? " queued: " + worker.queued_reason : "";
                 return "  " + worker.lane_id + "  " + worker.state + "  " + storyLabel +
-                    "  " + worker.provider + model + effort + account + queued;
+                    "  " + worker.provider + model + effort + account + queued +
+                    "\n    fingerprint: " + (worker.fingerprint ?? "-");
             })),
         "PRs (may include merged):",
         ...(snapshot.prs.length === 0

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

@@ -81,6 +81,10 @@ export declare const LANE_ENVELOPE_JSON_SCHEMA: {
             readonly type: "string";
             readonly minLength: 1;
         };
+        readonly fingerprint: {
+            readonly type: readonly ["string", "null"];
+            readonly description: "Optional worker fingerprint (hq fingerprint self); null when it could not be built. Older readers ignore it.";
+        };
     };
     readonly allOf: readonly [{
         readonly if: {
@@ -770,6 +774,12 @@ export interface LaneRecord {
      */
     provider_session_id?: string;
     provider_session_id_absent?: string;
+    /**
+     * The worker's fingerprint, built offline from the worker env when the
+     * lane's run starts (`hq fingerprint self --offline`). Null when it could
+     * not be built; absent on lanes started before fingerprints existed.
+     */
+    fingerprint?: string | null;
     /** Provider home used by the most recently spawned run, for transcript recovery. */
     provider_home_at_spawn?: string;
     /**
@@ -1002,6 +1012,8 @@ export interface LaneEnvelope {
     blocked_reason?: string;
     story_complete?: boolean;
     story_complete_reason?: string;
+    /** The worker's fingerprint, or null when it could not be built. Optional. */
+    fingerprint?: string | null;
 }
 export interface AccountConfig {
     home: string;

package/dist/lib/lanes/types.js

@@ -49,6 +49,10 @@ export const LANE_ENVELOPE_JSON_SCHEMA = {
         blocked_reason: { type: "string" },
         story_complete: { type: "boolean" },
         story_complete_reason: { type: "string", minLength: 1 },
+        fingerprint: {
+            type: ["string", "null"],
+            description: "Optional worker fingerprint (hq fingerprint self); null when it could not be built. Older readers ignore it.",
+        },
     },
     allOf: [
         {
@@ -243,7 +247,7 @@ export const LANE_FIELD_WRITERS = {
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile", "spawn"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile", "spawn", "command"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
-    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], working_directory_at_spawn: ["spawn"], last_resume: ["spawn"], resume_history: ["spawn", "watcher"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
+    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], fingerprint: ["spawn"], provider_home_at_spawn: ["spawn"], working_directory_at_spawn: ["spawn"], last_resume: ["spawn"], resume_history: ["spawn", "watcher"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
 };
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -299,6 +303,7 @@ export function parseLaneEnvelope(raw) {
         "blocked_reason",
         "story_complete",
         "story_complete_reason",
+        "fingerprint",
     ].includes(key));
     if (extra.length > 0) {
         throw new LaneSchemaError(`Lane envelope rejects unknown properties: ${extra.join(", ")}`, { extra });
@@ -382,6 +387,12 @@ export function parseLaneEnvelope(raw) {
     };
     if (nextCheckAt !== undefined)
         envelope.next_check_at = nextCheckAt;
+    if (raw.fingerprint !== undefined) {
+        if (raw.fingerprint !== null && (typeof raw.fingerprint !== "string" || raw.fingerprint.trim().length === 0)) {
+            throw new LaneSchemaError("fingerprint must be a non-empty string or null", { field: "fingerprint" });
+        }
+        envelope.fingerprint = raw.fingerprint;
+    }
     if (storyComplete !== undefined) {
         envelope.story_complete = storyComplete;
         envelope.story_complete_reason = storyCompleteReason;

package/dist/lib/mesh/live/daemon/install.d.ts

@@ -121,6 +121,18 @@ export declare function detectPlatform(platform?: NodeJS.Platform): DaemonInstal
  * binary when both exist.
  */
 export declare function preferStableHqBinary(entry: string, platform?: DaemonInstallPlatform, existsSync?: typeof fs.existsSync): string;
+/**
+ * A path that `node <path>` can run. preferStableHqBinary maps the package
+ * entry to the npm `hq.cmd` shim on Windows, which is right for a task that
+ * launches through cmd.exe but wrong for every caller that runs
+ * `node <hqBinary>`: node parses the batch file as JavaScript and exits with
+ * "SyntaxError: Invalid or unexpected token" on `@ECHO off`
+ * (feedback_a60339e8, feedback_516e4427). Map the shim back to the package's
+ * JS entry, which sits beside it in the same npm prefix and so stays valid
+ * across `npm i -g` updates. Anything that is not a Windows command shim is
+ * returned unchanged.
+ */
+export declare function nodeRunnableHqEntry(hqBinary: string, platform?: DaemonInstallPlatform | NodeJS.Platform, existsSync?: typeof fs.existsSync): string;
 /**
  * Absolute path of the CLI entry that is executing this process.
  * realpath of argv[1] only — never a PATH lookup of `hq`.

package/dist/lib/mesh/live/daemon/install.js

@@ -299,6 +299,28 @@ export function preferStableHqBinary(entry, platform = detectPlatform(), existsS
     }
     return entry;
 }
+/** JS entry of the hq-cli package, relative to an npm global prefix. */
+const HQ_CLI_PACKAGE_ENTRY = ["node_modules", "@indigoai-us", "hq-cli", "dist", "index.js"];
+/**
+ * A path that `node <path>` can run. preferStableHqBinary maps the package
+ * entry to the npm `hq.cmd` shim on Windows, which is right for a task that
+ * launches through cmd.exe but wrong for every caller that runs
+ * `node <hqBinary>`: node parses the batch file as JavaScript and exits with
+ * "SyntaxError: Invalid or unexpected token" on `@ECHO off`
+ * (feedback_a60339e8, feedback_516e4427). Map the shim back to the package's
+ * JS entry, which sits beside it in the same npm prefix and so stays valid
+ * across `npm i -g` updates. Anything that is not a Windows command shim is
+ * returned unchanged.
+ */
+export function nodeRunnableHqEntry(hqBinary, platform = detectPlatform(), existsSync = fs.existsSync) {
+    if (platform !== "win32")
+        return hqBinary;
+    const ext = path.win32.extname(hqBinary).toLowerCase();
+    if (ext !== ".cmd" && ext !== ".bat" && ext !== ".ps1")
+        return hqBinary;
+    const entry = path.win32.join(path.win32.dirname(hqBinary), ...HQ_CLI_PACKAGE_ENTRY);
+    return existsSync(entry) ? entry : hqBinary;
+}
 /**
  * Absolute path of the CLI entry that is executing this process.
  * realpath of argv[1] only — never a PATH lookup of `hq`.

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

@@ -22,7 +22,7 @@ import { defaultSleep, FLUSH_MAX_ATTEMPTS, fullJitterDelayMs, } from "./backoff.
 import { LOCAL_ONLY_FIELDS, stripLocalOnlyFields } from "./format-spool-line.js";
 import { enrichSessionEndEvent } from "./report-summary.js";
 import { createWorkLocationResolver, withWorkLocation, } from "./work-location.js";
-import { SESSION_EVENTS_BATCH_MAX, WRITABLE_CONTEXT_STATUSES, parseSessionEventsBatchAck, } from "./session-events-client.js";
+import { SESSION_EVENTS_BATCH_MAX, WRITABLE_CONTEXT_STATUSES, isSessionOwnerMismatch, parseSessionEventsBatchAck, SESSION_OWNER_MISMATCH, } from "./session-events-client.js";
 import { appendDeadLetterLine, appendDroppedReceipt, appendHeldLinesIfAbsent, appendSpoolLine, claimHeld, claimSpool, countDistinctHeldEvents, countJsonlLines, recoverOrphanClaims, removeClaimFile, } from "./spool.js";
 import { workMeshHeldPath, workMeshRoot } from "./paths.js";
 /** Bound a replayed session backlog so one flush cannot burst hundreds of events. */
@@ -306,7 +306,7 @@ export async function flushSessionEvents(inputDeps) {
                     v: 1,
                     sessionId,
                     dropped: remainingItems.length,
-                    reason: "untracked",
+                    reason: decision.reason,
                     at: now().toISOString(),
                 }, deps.workMeshRoot);
                 summary.dropped += remainingItems.length;
@@ -353,6 +353,22 @@ export async function flushSessionEvents(inputDeps) {
                     accountBatchSuccess(result.body, originalChunk, deps.workMeshRoot, now, summary, markDisposed);
                     continue;
                 }
+                if (!result.retryable && isSessionOwnerMismatch(result.status, result.body)) {
+                    // Another actor already reports this session (feedback_5b4683c2).
+                    // Not an error on this machine: drop the session's remaining events
+                    // with a receipt, remember the answer, and skip it from now on.
+                    const unsent = remainingItems.filter((item) => pendingRestore.has(item.event));
+                    dropOwnerMismatchedSession({
+                        sessionId,
+                        companyUid: decision.companyUid,
+                        items: unsent,
+                        deps,
+                        now,
+                        summary,
+                        markDisposed,
+                    });
+                    continue sessionLoop;
+                }
                 if (!result.retryable && result.status === 404) {
                     const rejectedProjectId = decision.projectId;
                     updateSessionState(sessionId, deps.workContextRoot, (current) => {
@@ -560,15 +576,34 @@ function accountBatchSuccess(body, originalChunk, meshRoot, now, summary, markDi
     }
     const rejectedIds = new Set();
     const at = now().toISOString();
+    let ownerMismatchDropped = 0;
     for (const row of ack.rejected) {
         const item = byId.get(row.eventId);
         if (!item)
             continue;
+        if (row.code === SESSION_OWNER_MISMATCH) {
+            ownerMismatchDropped += 1;
+            summary.dropped += 1;
+            rejectedIds.add(row.eventId);
+            markDisposed(item.event);
+            continue;
+        }
         appendDeadLetterLine(deadLetterEnvelope(item.event, row.code, row.code, at, row.code), meshRoot);
         summary.deadLettered += 1;
         rejectedIds.add(row.eventId);
         markDisposed(item.event);
     }
+    if (ownerMismatchDropped > 0) {
+        const sessionId = sessionIdOf(originalChunk[0].event);
+        appendDroppedReceipt({
+            v: 1,
+            sessionId,
+            dropped: ownerMismatchDropped,
+            reason: "owner_mismatch",
+            code: SESSION_OWNER_MISMATCH,
+            at,
+        }, meshRoot);
+    }
     const remaining = originalChunk.filter((item) => {
         const id = eventIdOf(item.event);
         return !id || !rejectedIds.has(id);
@@ -767,6 +802,26 @@ async function postPresenceLeaveIfNeeded(input) {
     });
     if (!result.ok) {
         const at = input.now().toISOString();
+        if (!result.retryable && isSessionOwnerMismatch(result.status, result.body)) {
+            // The old company says another actor owns this session, so there is no
+            // presence of ours to leave. Drop the leave events, clear the pending
+            // leave, and let the remaining events continue to the new binding.
+            dropOwnerMismatchedSession({
+                sessionId: input.sessionId,
+                companyUid: leave.companyUid,
+                items: leaveItems,
+                deps: input.deps,
+                now: input.now,
+                summary: input.summary,
+                markDisposed: input.markDisposed,
+                clearPresenceLeave: true,
+            });
+            return {
+                state: readSessionState(input.sessionId, input.deps.workContextRoot) ?? input.state,
+                items: remaining,
+                abort: false,
+            };
+        }
         if (!result.retryable) {
             for (const item of input.items) {
                 appendDeadLetterLine(deadLetterEnvelope(item.event, `HTTP_${result.status}`, result.status, at), input.deps.workMeshRoot);
@@ -843,12 +898,60 @@ function rebindUnboundSession(sessionId, items, state, deps, nowMs) {
     }
     return readSessionState(sessionId, deps.workContextRoot) ?? state;
 }
+const loggedOwnerMismatch = new Set();
+/**
+ * Drop a session's events after the server answered 403
+ * SESSION_OWNER_MISMATCH: write one dropped receipt, mark the session state so
+ * later flushes skip it without posting, and log once per session. These
+ * events never reach dead-letter, so daemon health stays clean.
+ */
+function dropOwnerMismatchedSession(input) {
+    const at = input.now().toISOString();
+    if (input.items.length > 0) {
+        appendDroppedReceipt({
+            v: 1,
+            sessionId: input.sessionId,
+            dropped: input.items.length,
+            reason: "owner_mismatch",
+            code: SESSION_OWNER_MISMATCH,
+            companyUid: input.companyUid,
+            at,
+        }, input.deps.workMeshRoot);
+    }
+    input.summary.dropped += input.items.length;
+    for (const item of input.items)
+        input.markDisposed(item.event);
+    updateSessionState(input.sessionId, input.deps.workContextRoot, (current) => {
+        if (!current)
+            return current;
+        if (input.clearPresenceLeave) {
+            const { presenceLeave: _leave, ...rest } = current;
+            return { ...rest, updatedAt: at };
+        }
+        return {
+            ...current,
+            ownerMismatch: { companyUid: input.companyUid, at },
+            updatedAt: at,
+        };
+    });
+    const key = `${input.deps.workContextRoot}\0${input.sessionId}`;
+    if (!loggedOwnerMismatch.has(key)) {
+        loggedOwnerMismatch.add(key);
+        input.deps.log?.(`work-mesh: session ${input.sessionId} is reported by another actor (403 SESSION_OWNER_MISMATCH); dropped ${input.items.length} event(s), not dead-lettered`);
+    }
+}
 function classifySession(state) {
     if (!state) {
         return { action: "hold", heldReason: "STATE_ABSENT" };
     }
     if (state.contextStatus === "untracked") {
-        return { action: "drop" };
+        return { action: "drop", reason: "untracked" };
+    }
+    // The server already told us another actor owns this session in this
+    // company; posting again would only earn another 403.
+    if (state.ownerMismatch?.companyUid &&
+        state.companyUid === state.ownerMismatch.companyUid) {
+        return { action: "drop", reason: "owner_mismatch" };
     }
     if (state.contextStatus === "needs_company") {
         return { action: "hold", heldReason: "NEEDS_COMPANY" };

package/dist/lib/mesh/live/session-events-client.d.ts

@@ -41,6 +41,15 @@ export interface SessionEventsBatchAck {
  */
 export declare function parseSessionEventsBatchAck(body: unknown): SessionEventsBatchAck | null;
 export type SessionEventsPoster = (body: SessionEventsBatchBody) => Promise<SessionEventsPostResult>;
+/**
+ * Server code for a session that another actor in the same company already
+ * reports (for example a local bot's own headless turn, picked up by the
+ * person's daemon). The server will never accept this actor's events for that
+ * session, so the flush drops them with a receipt instead of dead-lettering.
+ */
+export declare const SESSION_OWNER_MISMATCH = "SESSION_OWNER_MISMATCH";
+/** True for the 403 SESSION_OWNER_MISMATCH answer (feedback_5b4683c2). */
+export declare function isSessionOwnerMismatch(status: number, body: unknown): boolean;
 export declare function classifySessionEventsResponse(status: number, networkError?: boolean): Pick<SessionEventsPostResult, "ok" | "retryable" | "networkError">;
 /**
  * Build a poster that uses vaultApiFetch + Cognito token.

package/dist/lib/mesh/live/session-events-client.js

@@ -65,6 +65,21 @@ export function parseSessionEventsBatchAck(body) {
     }
     return { accepted, duplicates, rejected };
 }
+/**
+ * Server code for a session that another actor in the same company already
+ * reports (for example a local bot's own headless turn, picked up by the
+ * person's daemon). The server will never accept this actor's events for that
+ * session, so the flush drops them with a receipt instead of dead-lettering.
+ */
+export const SESSION_OWNER_MISMATCH = "SESSION_OWNER_MISMATCH";
+/** True for the 403 SESSION_OWNER_MISMATCH answer (feedback_5b4683c2). */
+export function isSessionOwnerMismatch(status, body) {
+    if (status !== 403)
+        return false;
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return false;
+    return body.code === SESSION_OWNER_MISMATCH;
+}
 export function classifySessionEventsResponse(status, networkError = false) {
     if (networkError || status === 0) {
         return { ok: false, retryable: true, networkError: true };

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

@@ -117,6 +117,16 @@ export interface SessionStateFile {
         taskId?: string;
         bindingEpisodeId?: string;
     };
+    /**
+     * LOCAL-ONLY. Set when the server answered 403 SESSION_OWNER_MISMATCH for
+     * this session in `companyUid`: another actor already reports it (a local
+     * bot's own turn, a checkpoint helper). While the session stays bound to
+     * that company, flush drops its events locally instead of posting them.
+     */
+    ownerMismatch?: {
+        companyUid: string;
+        at: string;
+    };
     updatedAt: string;
 }
 /**

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

@@ -215,6 +215,8 @@ function projectSessionState(state) {
         out.projectHint = state.projectHint;
     if (state.presenceLeave?.companyUid)
         out.presenceLeave = state.presenceLeave;
+    if (state.ownerMismatch?.companyUid)
+        out.ownerMismatch = state.ownerMismatch;
     return out;
 }
 /**
@@ -282,6 +284,9 @@ export function mergeLocalSessionFields(next, prior, options = {}) {
     if (!out.presenceLeave && prior.presenceLeave) {
         out.presenceLeave = prior.presenceLeave;
     }
+    if (!out.ownerMismatch && prior.ownerMismatch) {
+        out.ownerMismatch = prior.ownerMismatch;
+    }
     if (out.projectId)
         out.projectHint = undefined;
     const sameBinding = prior.companyUid === out.companyUid &&

package/dist/utils/cli-network-lifecycle.d.ts

@@ -1,4 +1,6 @@
 export declare function isMonitorFastPathCommand(argv: readonly string[]): boolean;
+/** The commit-msg hook runs `hq fingerprint self --offline`; it must stay fast and offline. */
+export declare function isOfflineFingerprintCommand(argv: readonly string[]): boolean;
 /** Skip process-wide network lifecycle work for hooks and detached monitor supervisors. */
 export declare function runGlobalNetworkLifecycle<T>(argv: readonly string[], operation: () => T): T | undefined;
 //# sourceMappingURL=cli-network-lifecycle.d.ts.map

package/dist/utils/cli-network-lifecycle.js

@@ -2,9 +2,13 @@ const MONITOR_HIDDEN_NETWORK_BYPASS = new Set(["drain", "wait", "enabled", "_run
 export function isMonitorFastPathCommand(argv) {
     return argv[2] === "monitor" && MONITOR_HIDDEN_NETWORK_BYPASS.has(argv[3] ?? "");
 }
+/** The commit-msg hook runs `hq fingerprint self --offline`; it must stay fast and offline. */
+export function isOfflineFingerprintCommand(argv) {
+    return argv[2] === "fingerprint" && argv[3] === "self" && argv.slice(4).includes("--offline");
+}
 /** Skip process-wide network lifecycle work for hooks and detached monitor supervisors. */
 export function runGlobalNetworkLifecycle(argv, operation) {
-    if (isMonitorFastPathCommand(argv))
+    if (isMonitorFastPathCommand(argv) || isOfflineFingerprintCommand(argv))
         return undefined;
     return operation();
 }

package/dist/utils/cognito-session.d.ts

@@ -19,7 +19,8 @@
  *   HQ_VAULT_API_URL           — vault-service API Gateway URL
  */
 import { isExpiring, isMachineIdentity, type CognitoAuthConfig, type CognitoTokens, type ClientInfo, type VaultServiceConfig } from "@indigoai-us/hq-cloud";
-import { type KeychainReadOptions } from "./token-keychain.js";
+import { loadCachedTokens, personTokenCacheFile, readPersonTokenFile } from "./person-token-cache.js";
+export { loadCachedTokens, personTokenCacheFile, readPersonTokenFile };
 export { isExpiring, isMachineIdentity };
 /** Person browser/login cache vs machine-creds USER_PASSWORD_AUTH mint. */
 export type CognitoTokenSource = "person" | "machine";
@@ -118,13 +119,6 @@ export type EnsureCognitoTokenOptions = {
     /** Cancels bounded, non-interactive person-session refreshes. */
     signal?: AbortSignal;
 };
-/**
- * On-disk person Cognito cache path for `env` (`HQ_STATE_DIR` or `~/.hq`).
- * Deliberately does not use hq-cloud's `loadCachedTokens()`: after a machine
- * mint in this process, that helper returns in-memory machine tokens when the
- * person file is absent, which would falsely block the fresh-box fallback.
- */
-export declare function personTokenCacheFile(home?: string, env?: NodeJS.ProcessEnv): string;
 /**
  * True when a usable person Cognito cache file exists under the effective
  * `HQ_STATE_DIR` (or `~/.hq`). Presence alone keeps human commands on the
@@ -186,19 +180,6 @@ export declare function formatCognitoSubject(tokens: {
     idToken?: string;
     accessToken?: string;
 } | null | undefined): string;
-/**
- * Person session for `env`: the Keychain item and the token file, the newer
- * by `expiresAt` (see ./token-keychain.ts). Does not consult hq-cloud's
- * in-memory fallback, which can surface a different session when the file
- * is missing or unreadable.
- */
-export declare function readPersonTokenFile(home?: string, env?: NodeJS.ProcessEnv, keychain?: KeychainReadOptions): CognitoTokens | null;
-/**
- * The person's cached session: the shared Keychain item and hq-cloud's file
- * loader, the newer by `expiresAt`. Writes still go only to the file in this
- * step.
- */
-export declare function loadCachedTokens(env?: NodeJS.ProcessEnv, keychain?: KeychainReadOptions): CognitoTokens | null;
 /**
  * Refresh the active person session and refuse a subject change.
  *