@indigoai-us/hq-cli 5.108.21 → 5.108.23

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 ## [Unreleased]
 
+## [5.108.23] — 2026-09-08
+
+### Added
+
+- `hq mesh context requeue` flips AUTH_DENIED-quarantined work-context outbox
+  operations (registrations, reconciles) back to queued so a box whose
+  registrations were denied before the ID-token fix recovers without a manual
+  reset (gap 10, #539).
+- `hq mesh context backfill-held` reconciles each unattributed held session
+  through the shared company resolver so the daemon's held retry can drain the
+  ended-session backlog that would otherwise never re-attribute. Opt-in and
+  per-box, with `--dry-run`/`--offline`/`--limit`/`--company`/`--json` (gap 2b,
+  #540).
+
+### Fixed
+
+- Work-context commands (`hq mesh context reconcile`/register) on agent boxes now
+  authenticate with the machine ID token, matching the presence daemon, instead
+  of the access token the server cannot attribute to the agent entity (which
+  answered 403 NO_PERSON_ENTITY and quarantined registrations as AUTH_DENIED).
+  requireToken() mints the machine ID token whenever the box is a machine
+  identity (gap 10, #539).
+- Work Mesh Live session events that carry the `agents-v2` runtime harness are
+  accepted by the shared session-event schema instead of being rejected as
+  SCHEMA_INVALID and dead-lettered; both copies of the schema stay byte-identical
+  (gap 9, #541).
+
+### Testing
+
+- The held-TTL flush tests (`HELD_OVERFLOW`, the 150k mid-flush-throw) inject a
+  deterministic clock instead of the real wall clock, so they no longer flip red
+  the moment the hardcoded `heldAt` fixtures cross the 7-day held TTL (#542).
+
+## [5.108.22] — 2026-09-07
+
+### Fixed
+
+- Work Mesh registrations now retain the runtime harness in the durable outbox
+  and send it to the server, including a compatible fallback for older queued
+  operations. Fleet sessions discover their company from the standard agent
+  identity file without requiring a launcher environment variable, and transcript
+  registration uses the shared company precedence and conflict rules.
+
 ## [5.108.21] — 2026-09-07
 
 ### Fixed

package/dist/commands/mesh.js

@@ -16,6 +16,7 @@ import { DefaultCompanyLockedError, DefaultCompanyUnavailableError, } from "../l
 import { isValidSessionId } from "../lib/mesh/live/session-identity.js";
 import { CLI_KIND_TO_SCHEMA, EnqueueValidationError, enqueueSessionEvent, } from "../lib/mesh/live/index.js";
 import { flushSessionEvents } from "../lib/mesh/live/flush.js";
+import { backfillHeldSessions } from "../lib/mesh/live/backfill-held.js";
 import { createSessionEventsPoster, resolveVaultApiBase, } from "../lib/mesh/live/session-events-client.js";
 import { workMeshRoot } from "../lib/mesh/live/paths.js";
 import { buildInstallPaths, collectDaemonDoctor, daemonServiceStatus, detectPlatform, formatDaemonDoctor, installDaemonService, readDaemonState, runMeshDaemon, uninstallDaemonService, daemonDir, } from "../lib/mesh/live/daemon/index.js";
@@ -24,6 +25,7 @@ import { formatMigrateConfirmation, submitSessionMigration, } from "../lib/work-
 import { formatOrganizeList, prepareOrganizeDecision, settleOrganizeAskWithoutBind, submitOrganizeDecision, } from "../lib/work-context/organize.js";
 import { readSessionState } from "../lib/work-context/state.js";
 import { loadObservationFromFile, markUntracked, parseObservationJson, reconcileObservation, } from "../lib/work-context/reconcile.js";
+import { requeueQuarantinedOutbox } from "../lib/work-context/outbox.js";
 export function formatCheckLines(threads, company, projectId) {
     if (threads.length === 0) {
         return ["Work mesh: no active project threads found."];
@@ -178,6 +180,75 @@ async function runContextReconcile(opts) {
     }
     process.exitCode = outcome.exitCode;
 }
+async function runContextBackfillHeld(opts) {
+    const root = workContextHomeRoot();
+    const meshRoot = workMeshRoot(undefined, process.env);
+    const dryRun = Boolean(opts.dryRun);
+    const parsedLimit = opts.limit ? Number.parseInt(opts.limit, 10) : 0;
+    const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : 0;
+    const companyHint = opts.company?.trim() || undefined;
+    // Build the reconcile network seam exactly like `hq mesh context reconcile`.
+    // Not needed in --dry-run (reconcile is never invoked then). Explicit types
+    // because these are captured in the reconcile closure below (no control-flow
+    // narrowing, unlike the inline reconcile handler).
+    let deliver;
+    let fetchCandidates;
+    let validateMembership;
+    let offline = Boolean(opts.offline);
+    if (!dryRun && !offline) {
+        try {
+            const token = await requireToken();
+            deliver = createWorkSessionDeliverer({ token });
+            fetchCandidates = createCandidatesFetcher({ token });
+            validateMembership = async (candidate) => {
+                const membership = await resolveActiveMembershipCompany(token, candidate);
+                if (!membership)
+                    return false;
+                return { uid: membership.companyUid };
+            };
+        }
+        catch {
+            offline = true;
+            if (!opts.json) {
+                console.error(chalk.yellow("No Cognito session; reconciling offline (outbox only)."));
+            }
+        }
+    }
+    const result = await backfillHeldSessions({
+        workMeshRoot: meshRoot,
+        workContextRoot: root,
+        dryRun,
+        limit,
+        reconcile: (obs) => reconcileObservation(
+        // Pass --company as a non-forcing hint (remoteOwnerSlug feeds
+        // deterministic resolution BELOW the identity-file / device default,
+        // so the shared resolver still wins, as in normal reconcile).
+        companyHint ? { ...obs, remoteOwnerSlug: companyHint } : obs, {
+            root,
+            env: process.env,
+            deliver,
+            fetchCandidates,
+            offline,
+            validateMembership,
+        }),
+    });
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, action: "backfill-held", ...result }, null, 2));
+        return;
+    }
+    const verb = dryRun ? "would reconcile" : "reconciled";
+    console.log(`Backfill held: scanned ${result.scanned} session(s)` +
+        `${limit > 0 ? ` (considered ${result.considered})` : ""}; ` +
+        `${result.alreadyAttributed} already attributed, ` +
+        `${verb} ${result.reconciled}, ` +
+        `${result.unresolved} unresolved, ` +
+        `${result.errors} error(s).` +
+        (dryRun ? " (dry-run: nothing written)" : ""));
+    if (!dryRun && result.reconciled > 0) {
+        console.log("Reconciled session state files were rewritten with a resolved company; " +
+            "the mesh daemon's held retry will re-attribute and post those events.");
+    }
+}
 async function runContextDefaultGet(opts) {
     const root = workContextHomeRoot();
     const cfg = readDeviceConfig({ root });
@@ -393,6 +464,30 @@ async function runContextDefaultClear(opts) {
     }
     console.log("Default company cleared.");
 }
+async function runContextRequeue(opts) {
+    const root = workContextHomeRoot();
+    // Default: only AUTH_DENIED (the gap 10 regression). --all clears the code
+    // filter entirely; --error-code targets one specific lastErrorCode.
+    const errorCode = opts.all
+        ? null
+        : opts.errorCode?.trim()
+            ? opts.errorCode.trim()
+            : undefined;
+    const requeued = requeueQuarantinedOutbox(root, { errorCode });
+    if (opts.json) {
+        console.log(JSON.stringify({
+            ok: true,
+            requeued: requeued.length,
+            errorCode: errorCode === undefined ? "AUTH_DENIED" : errorCode,
+            operationIds: requeued.map((op) => op.operationId),
+        }, null, 2));
+        return;
+    }
+    const scope = errorCode === null
+        ? "all quarantine reasons"
+        : `lastErrorCode=${errorCode === undefined ? "AUTH_DENIED" : errorCode}`;
+    console.log(`Requeued ${requeued.length} quarantined outbox operation${requeued.length === 1 ? "" : "s"} (${scope}). The mesh daemon will retry them on its next replay.`);
+}
 async function runContextUntracked(sessionId, opts) {
     if (!isValidSessionId(sessionId)) {
         fail(`Invalid session id: ${sessionId}`);
@@ -524,6 +619,7 @@ const HARNESSES = new Set([
     "grok",
     "hq-sessions",
     "agent-box",
+    "agents-v2",
 ]);
 function workMeshHomeRoot() {
     return workMeshRoot(os.homedir(), process.env);
@@ -537,7 +633,7 @@ async function runSessionEnqueue(cliKind, opts) {
         fail(`Unknown session verb: ${cliKind}`);
     const harness = (opts.harness?.trim() || "");
     if (!HARNESSES.has(harness)) {
-        fail("--harness is required (claude-code|codex|grok|hq-sessions|agent-box)");
+        fail("--harness is required (claude-code|codex|grok|hq-sessions|agent-box|agents-v2)");
     }
     const adapterVersion = opts.adapterVersion?.trim();
     if (!adapterVersion)
@@ -621,7 +717,7 @@ function addSessionEnqueueFlags(cmd) {
     return cmd
         .option("--enqueue", "Append one line to ~/.hq/work-mesh/spool.jsonl (no network)")
         .option("--session-id <id>", "Session id (else HQ_SESSION_ID / harness env)")
-        .option("--harness <name>", "claude-code|codex|grok|hq-sessions|agent-box")
+        .option("--harness <name>", "claude-code|codex|grok|hq-sessions|agent-box|agents-v2")
         .option("--adapter-version <ver>", "Hook / adapter version")
         .option("--runtime-version <ver>", "Host runtime version")
         .option("--seq <n>", "Monotonic per-session sequence (>= 1)")
@@ -712,6 +808,15 @@ export function registerMeshCommand(program) {
         .option("--machine", "Write exactly one ContextResult JSON line to stdout")
         .option("--offline", "Skip network; leave register operations queued in the outbox")
         .action((opts) => wrap(() => runContextReconcile(opts))());
+    context
+        .command("backfill-held")
+        .description("Reconcile ENDED sessions whose held events lack a company so the daemon re-attributes the backlog (explicit, opt-in; no fleet fan-out)")
+        .option("--dry-run", "Report what would be reconciled; write nothing, no network")
+        .option("--offline", "Reconcile outbox-only (no candidates/register network)")
+        .option("--limit <n>", "Cap sessions processed (default 0 = no cap)")
+        .option("--company <slug>", "Optional non-forcing company hint (resolver default still wins)")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runContextBackfillHeld(opts))());
     context
         .command("organize")
         .description("List or submit one-time project/task decisions (US-007B / US-005B)")
@@ -744,6 +849,13 @@ export function registerMeshCommand(program) {
         .option("--json", "Print machine-readable JSON")
         .option("--machine", "Compact JSON on stdout")
         .action((opts) => wrap(() => runContextCorrect(opts))());
+    context
+        .command("requeue")
+        .description("Requeue quarantined outbox operations (default: only AUTH_DENIED — work-mesh-live gap 10 recovery)")
+        .option("--all", "Requeue every quarantined op regardless of lastErrorCode")
+        .option("--error-code <code>", "Requeue quarantined ops with this lastErrorCode")
+        .option("--json", "Print machine-readable JSON")
+        .action((opts) => wrap(() => runContextRequeue(opts))());
     const def = context
         .command("default")
         .description("Manage the device-local default company preference");

package/dist/lib/doctor/checks/runtime-probe.js

@@ -300,7 +300,7 @@ export function checkRuntimeProbe(context) {
                 status: "PASS",
                 checkId,
                 target,
-                message: `Host platform is agents-v2 (hermes fleet): the on-box adapter wrote the ` +
+                message: `Host platform is the Agents v2 runtime: the on-box adapter wrote the ` +
                     `policy-trigger ledger through the same .claude hooks, so hook dispatch was ` +
                     `observed this session — the ledger has an entry${scope}.`,
             },

package/dist/lib/mesh/api.js

@@ -5,7 +5,7 @@
  * machine cache apps already read. Does not spawn the pack helper and does
  * not start MQTT listen.
  */
-import { ensureCognitoToken } from "../../utils/cognito-session.js";
+import { ensureCognitoToken, isMachineIdentity } from "../../utils/cognito-session.js";
 import { peekIdToken } from "../../utils/id-token.js";
 import { getCompanyUid, vaultApiFetch } from "../../utils/vault-api.js";
 import { meshCacheRoot, removeSessionFallbackFiles, writeMeshCacheFile, } from "./cache.js";
@@ -119,6 +119,19 @@ export async function resolveActiveMembershipCompany(token, slug) {
     return null;
 }
 export async function requireToken() {
+    // Agent/machine boxes must authenticate the way the mesh daemon does:
+    // an agent's identity claims (custom:entityType=agent, custom:entityUid)
+    // ride the ID token ONLY; a person-cache ACCESS token on the box carries
+    // no entity claims and the server answers 403 NO_PERSON_ENTITY, which the
+    // outbox then quarantines as AUTH_DENIED (work-mesh-live gap 10). Force
+    // the machine mint whenever machine creds are readable so we always send
+    // the agent ID token, matching src/lib/mesh/live/daemon/run.ts. Per the
+    // hard policy indigo-agent-caller-resolution-id-token, agent claims ride
+    // the ID token only; the server is correct to require it. Humans keep the
+    // person access token (unchanged).
+    if (isMachineIdentity()) {
+        return ensureCognitoToken({ tokenSource: "machine" });
+    }
     return ensureCognitoToken();
 }
 function asRecord(value) {

package/dist/lib/mesh/client.js

@@ -24,6 +24,8 @@ export function createWorkSessionDeliverer(opts) {
             contractVersion: 1,
             companyUid,
             sessionId: op.sessionId,
+            // Pre-upgrade outbox records have no harness; do not invent a provider.
+            harness: op.harness?.trim() || "unknown",
             clientOperationId: op.clientOperationId,
             operationId: op.operationId,
             digest: op.digest,

package/dist/lib/mesh/live/backfill-held.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Backfill held session events by reconciling their ENDED sessions (gap 2b).
+ *
+ * Background: hq-cli 5.108.22 fixed company resolution for sessions reconciled
+ * from now on, but the daemon's held retry (see flush.ts `classifySession` →
+ * NEEDS_COMPANY) decides purely from the per-session work-context state file,
+ * and only a reconcile rewrites that file. Held events belong to sessions that
+ * already ENDED, so nothing reconciles them again — the held backlog sits held
+ * forever.
+ *
+ * This module re-runs `reconcileObservation` once per distinct held session
+ * that still lacks a companyUid, which rewrites its state file with the resolved
+ * company (via the identity-file default resolver shipped in 5.108.22). The
+ * daemon's next held retry then re-attributes and posts those events naturally.
+ *
+ * Constraints (owner directive):
+ * - Explicit, opt-in only. Never automatic; never wired into a hook or daemon.
+ * - Idempotent: sessions that already carry a companyUid are skipped.
+ * - Never deletes held events; the daemon posts them on the next retry.
+ * - Purely local to the box it runs on; no fleet fan-out.
+ */
+import type { ReconcileObservation, ReconcileOutcome } from "../../work-context/reconcile.js";
+import { type SessionStateFile } from "../../work-context/state.js";
+/** One distinct session discovered in held.jsonl, with its harness. */
+export interface HeldSessionRef {
+    sessionId: string;
+    harness?: string;
+}
+export interface BackfillHeldResult {
+    /** Distinct sessions found in held.jsonl (before --limit). */
+    scanned: number;
+    /** Distinct sessions considered this run (after --limit). */
+    considered: number;
+    /** Skipped because state already has a companyUid. */
+    alreadyAttributed: number;
+    /** Reconcile invoked and a company was resolved (would-reconcile in dry-run). */
+    reconciled: number;
+    /** Reconcile ran but resolver found no company. */
+    unresolved: number;
+    /** Sessions that errored during reconcile. */
+    errors: number;
+    dryRun: boolean;
+}
+export interface BackfillHeldDeps {
+    /** Work-mesh root that holds held.jsonl. */
+    workMeshRoot: string;
+    /** Work-context root that holds sessions/<sid>.json. */
+    workContextRoot: string;
+    /** Report only; write nothing, call no network, invoke no reconcile. */
+    dryRun?: boolean;
+    /** Cap distinct sessions processed. 0 (default) = no cap. */
+    limit?: number;
+    /** Contract version stamped on the synthesized observation. */
+    contractVersion?: number;
+    /** Fresh clientOperationId per reconcile. Default crypto.randomUUID. */
+    newOperationId?: () => string;
+    /** State reader seam. Default readSessionState. */
+    readState?: (sessionId: string, root: string) => SessionStateFile | null;
+    /**
+     * Reconcile one observation. NOT called in dry-run. The CLI wrapper wires
+     * this to reconcileObservation with the real deliver/fetchCandidates/
+     * validateMembership seam (or offline fallback), exactly mirroring the
+     * `hq mesh context reconcile` handler.
+     */
+    reconcile: (obs: ReconcileObservation) => Promise<ReconcileOutcome>;
+    /** Optional progress logger. */
+    log?: (message: string) => void;
+}
+/**
+ * Read held.jsonl and return distinct sessions (first occurrence wins),
+ * carrying the harness from whichever held event we saw first for that session.
+ * Lines that fail to parse or carry no sessionId are ignored (the daemon owns
+ * their disposition; this backfill never mutates or deletes held lines).
+ */
+export declare function readHeldSessions(workMeshRoot: string): HeldSessionRef[];
+/**
+ * Reconcile ended sessions whose held events lack a company. Idempotent:
+ * re-running skips sessions that already carry a companyUid.
+ */
+export declare function backfillHeldSessions(deps: BackfillHeldDeps): Promise<BackfillHeldResult>;
+//# sourceMappingURL=backfill-held.d.ts.map

package/dist/lib/mesh/live/backfill-held.js

@@ -0,0 +1,131 @@
+/**
+ * Backfill held session events by reconciling their ENDED sessions (gap 2b).
+ *
+ * Background: hq-cli 5.108.22 fixed company resolution for sessions reconciled
+ * from now on, but the daemon's held retry (see flush.ts `classifySession` →
+ * NEEDS_COMPANY) decides purely from the per-session work-context state file,
+ * and only a reconcile rewrites that file. Held events belong to sessions that
+ * already ENDED, so nothing reconciles them again — the held backlog sits held
+ * forever.
+ *
+ * This module re-runs `reconcileObservation` once per distinct held session
+ * that still lacks a companyUid, which rewrites its state file with the resolved
+ * company (via the identity-file default resolver shipped in 5.108.22). The
+ * daemon's next held retry then re-attributes and posts those events naturally.
+ *
+ * Constraints (owner directive):
+ * - Explicit, opt-in only. Never automatic; never wired into a hook or daemon.
+ * - Idempotent: sessions that already carry a companyUid are skipped.
+ * - Never deletes held events; the daemon posts them on the next retry.
+ * - Purely local to the box it runs on; no fleet fan-out.
+ */
+import * as fs from "node:fs";
+import { readSessionState } from "../../work-context/state.js";
+import { WORK_CONTEXT_CONTRACT_VERSION } from "../../work-context/contract.js";
+import { workMeshHeldPath } from "./paths.js";
+/**
+ * Read held.jsonl and return distinct sessions (first occurrence wins),
+ * carrying the harness from whichever held event we saw first for that session.
+ * Lines that fail to parse or carry no sessionId are ignored (the daemon owns
+ * their disposition; this backfill never mutates or deletes held lines).
+ */
+export function readHeldSessions(workMeshRoot) {
+    const heldPath = workMeshHeldPath(workMeshRoot);
+    let raw;
+    try {
+        raw = fs.readFileSync(heldPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const seen = new Map();
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        const obj = parsed;
+        // Peel the held envelope { event, heldReason, heldAt } if present.
+        const event = obj.event &&
+            typeof obj.event === "object" &&
+            !Array.isArray(obj.event) &&
+            typeof obj.heldReason === "string"
+            ? obj.event
+            : obj;
+        const sessionId = typeof event.sessionId === "string" && event.sessionId.trim()
+            ? event.sessionId.trim()
+            : null;
+        if (!sessionId || seen.has(sessionId))
+            continue;
+        const harness = typeof event.harness === "string" && event.harness.trim()
+            ? event.harness.trim()
+            : undefined;
+        seen.set(sessionId, { sessionId, harness });
+    }
+    return [...seen.values()];
+}
+/**
+ * Reconcile ended sessions whose held events lack a company. Idempotent:
+ * re-running skips sessions that already carry a companyUid.
+ */
+export async function backfillHeldSessions(deps) {
+    const dryRun = Boolean(deps.dryRun);
+    const limit = deps.limit && deps.limit > 0 ? deps.limit : 0;
+    const contractVersion = deps.contractVersion ?? WORK_CONTEXT_CONTRACT_VERSION;
+    const readState = deps.readState ?? readSessionState;
+    const newOperationId = deps.newOperationId ?? (() => globalThis.crypto.randomUUID());
+    const sessions = readHeldSessions(deps.workMeshRoot);
+    const considered = limit > 0 ? sessions.slice(0, limit) : sessions;
+    const result = {
+        scanned: sessions.length,
+        considered: considered.length,
+        alreadyAttributed: 0,
+        reconciled: 0,
+        unresolved: 0,
+        errors: 0,
+        dryRun,
+    };
+    for (const { sessionId, harness } of considered) {
+        const state = readState(sessionId, deps.workContextRoot);
+        if (state?.companyUid) {
+            result.alreadyAttributed += 1;
+            continue;
+        }
+        if (dryRun) {
+            // Would reconcile: no state read/write beyond the skip check above.
+            result.reconciled += 1;
+            deps.log?.(`would reconcile ${sessionId}${harness ? ` (${harness})` : ""}`);
+            continue;
+        }
+        const obs = {
+            contractVersion,
+            identity: harness ? { sessionId, harness } : { sessionId },
+            clientOperationId: newOperationId(),
+        };
+        try {
+            const outcome = await deps.reconcile(obs);
+            if (outcome.result.companyUid) {
+                result.reconciled += 1;
+                deps.log?.(`reconciled ${sessionId} → ${outcome.result.companyUid}`);
+            }
+            else {
+                result.unresolved += 1;
+                deps.log?.(`unresolved ${sessionId} (no company)`);
+            }
+        }
+        catch (err) {
+            result.errors += 1;
+            deps.log?.(`error ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=backfill-held.js.map

package/dist/lib/mesh/live/daemon/transcript-watch.d.ts

@@ -219,10 +219,11 @@ export declare function isTranscriptHookCovered(sessionId: string, opts: {
 }): boolean;
 /**
  * Resolve local registration for a transcript session. Never asks, never
- * creates a project. Uses deterministic cwd/remote mapping only.
+ * creates a project. Shares reconcile's company precedence and conflict rules.
  */
 export declare function resolveTranscriptRegistration(input: {
     sessionId: string;
+    env?: NodeJS.ProcessEnv;
     cwd?: string;
     hqRoot?: string;
     workContextRoot: string;

package/dist/lib/mesh/live/daemon/transcript-watch.js

@@ -29,8 +29,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { CLI_VERSION } from "../../../../cli-version.js";
-import { companySlugFromCwd, projectIdFromCwd, resolveDeterministicCompany, } from "../../../work-context/company.js";
-import { getDefaultCompany } from "../../../work-context/config.js";
+import { companySlugFromCwd, projectIdFromCwd, resolveCompany, } from "../../../work-context/company.js";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "../../../work-context/contract.js";
 import { reconcileObservation, } from "../../../work-context/reconcile.js";
 import { deriveRemoteOwnerSlug } from "../../../work-context/repo-remote.js";
@@ -441,7 +440,7 @@ export function isTranscriptHookCovered(sessionId, opts) {
 }
 /**
  * Resolve local registration for a transcript session. Never asks, never
- * creates a project. Uses deterministic cwd/remote mapping only.
+ * creates a project. Shares reconcile's company precedence and conflict rules.
  */
 export function resolveTranscriptRegistration(input) {
     const now = input.now ?? (() => new Date());
@@ -449,33 +448,26 @@ export function resolveTranscriptRegistration(input) {
     const remoteOwnerSlug = input.cwd
         ? deriveRemoteOwnerSlug({ cwd: input.cwd, hqRoot: input.hqRoot })
         : null;
-    const deterministic = resolveDeterministicCompany({
+    const resolution = resolveCompany({
+        root: input.workContextRoot,
+        sessionId: input.sessionId,
+        env: input.env,
         cwd: input.cwd,
         hqRoot: input.hqRoot,
         remoteOwnerSlug,
     });
-    const projectId = projectIdFromCwd(input.cwd, input.hqRoot);
-    // Prefer company slug from deterministic evidence; optionally adopt uid when
-    // the enabled device default names the same slug (no conflict ask).
-    const companySlug = deterministic?.slug ?? companySlugFromCwd(input.cwd, input.hqRoot);
-    let companyUid;
-    const device = getDefaultCompany({ root: input.workContextRoot });
-    if (companySlug &&
-        device?.enabled &&
-        device.slug &&
-        device.slug.toLowerCase() === companySlug.toLowerCase()) {
-        companyUid = device.uid;
-    }
-    let contextStatus;
-    if (!companySlug) {
-        contextStatus = "needs_company";
-    }
-    else if (projectId) {
-        contextStatus = "needs_task";
-    }
-    else {
-        contextStatus = "unresolved";
-    }
+    const company = resolution.status === "resolved" ? resolution.company : undefined;
+    const companySlug = company?.slug;
+    const companyUid = company?.uid;
+    // A cwd project belongs to its cwd company, never to a higher-precedence
+    // identity or explicit scope naming another (or not-yet-mapped) company.
+    const cwdCompany = companySlugFromCwd(input.cwd, input.hqRoot);
+    const projectId = companySlug && cwdCompany?.toLowerCase() === companySlug.toLowerCase()
+        ? projectIdFromCwd(input.cwd, input.hqRoot)
+        : undefined;
+    const contextStatus = resolution.status === "company_conflict"
+        ? "company_conflict"
+        : !company ? "needs_company" : projectId ? "needs_task" : "unresolved";
     const state = {
         contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
         sessionId: input.sessionId,

package/dist/lib/mesh/live/format-spool-line.d.ts

@@ -7,7 +7,7 @@ export type LocalOnlyField = (typeof LOCAL_ONLY_FIELDS)[number];
 /** Network + local key order matching work-mesh-enqueue.sh. */
 export declare const SPOOL_KEY_ORDER: readonly ["v", "eventId", "kind", "sessionId", "harness", "adapterVersion", "runtimeVersion", "source", "at", "seq", "taskId", "status", "reason", "summary", "cwd", "hqRoot", "companySlug", "project", "task", "toolWrites"];
 export type SessionEventKind = "session_start" | "turn_start" | "turn_end" | "session_end" | "task_status" | "blocked" | "note";
-export type SessionEventHarness = "claude-code" | "claude-desktop" | "codex" | "grok" | "hq-sessions" | "agent-box";
+export type SessionEventHarness = "claude-code" | "claude-desktop" | "codex" | "grok" | "hq-sessions" | "agent-box" | "agents-v2";
 export type SessionEventSource = "hooks" | "transcript";
 export interface SpoolEventInput {
     v?: 1;

package/dist/lib/mesh/live/session-event.schema.json

@@ -52,7 +52,8 @@
         "codex",
         "grok",
         "hq-sessions",
-        "agent-box"
+        "agent-box",
+        "agents-v2"
       ]
     },
     "adapterVersion": {

package/dist/lib/mesh/live/validate-session-event.d.ts

@@ -8,7 +8,7 @@
 import type { ValidateFunction } from "ajv";
 export declare const SESSION_EVENT_SCHEMA_PATH: string;
 /** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
-export declare const SESSION_EVENT_SCHEMA_SHA256 = "be300120b4793a5c6f1e713bf9f72b2fd22f6ac082bef8eedfa507b684b09ccb";
+export declare const SESSION_EVENT_SCHEMA_SHA256 = "4284bcc3718b8c9008c26156c1f79ae5cfd70fdd248beb2b1c776988f109e415";
 export declare const PROHIBITED_CONTENT_CLASSES: readonly ["prompts", "model_output", "transcripts", "message_bodies", "tokens", "credentials"];
 export type ProhibitedContentClass = (typeof PROHIBITED_CONTENT_CLASSES)[number];
 /** Fixture field name → prohibited class. */

package/dist/lib/mesh/live/validate-session-event.js

@@ -13,7 +13,7 @@ import Ajv2020 from "ajv/dist/2020.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 export const SESSION_EVENT_SCHEMA_PATH = join(HERE, "session-event.schema.json");
 /** Expected SHA-256 of the canonical schema bytes (hq-pro + hq-cli must match). */
-export const SESSION_EVENT_SCHEMA_SHA256 = "be300120b4793a5c6f1e713bf9f72b2fd22f6ac082bef8eedfa507b684b09ccb";
+export const SESSION_EVENT_SCHEMA_SHA256 = "4284bcc3718b8c9008c26156c1f79ae5cfd70fdd248beb2b1c776988f109e415";
 export const PROHIBITED_CONTENT_CLASSES = [
     "prompts",
     "model_output",

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

@@ -58,9 +58,11 @@ export interface CompanyResolveInput {
 }
 /** Env naming the on-box identity.json (fleet agent boxes). */
 export declare const HQ_AGENT_IDENTITY_FILE_ENV = "HQ_AGENT_IDENTITY_FILE";
+export declare const DEFAULT_AGENT_IDENTITY_FILE = "/var/lib/hq-agent/identity.json";
 /**
  * Read `companyUid` from the agent identity file when
- * `HQ_AGENT_IDENTITY_FILE` is set. Missing/unreadable/malformed → undefined
+ * `HQ_AGENT_IDENTITY_FILE` is set, or the conventional fleet path otherwise.
+ * Missing/unreadable/malformed → undefined
  * (never throws; never logs file contents).
  */
 export declare function readAgentIdentityCompanyUid(env?: NodeJS.ProcessEnv): string | undefined;

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

@@ -26,6 +26,7 @@ export function companyCorrectionPath(sessionId) {
 const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 /** Env naming the on-box identity.json (fleet agent boxes). */
 export const HQ_AGENT_IDENTITY_FILE_ENV = "HQ_AGENT_IDENTITY_FILE";
+export const DEFAULT_AGENT_IDENTITY_FILE = "/var/lib/hq-agent/identity.json";
 function normalizeSlug(value) {
     if (!value)
         return undefined;
@@ -36,11 +37,14 @@ function normalizeSlug(value) {
 }
 /**
  * Read `companyUid` from the agent identity file when
- * `HQ_AGENT_IDENTITY_FILE` is set. Missing/unreadable/malformed → undefined
+ * `HQ_AGENT_IDENTITY_FILE` is set, or the conventional fleet path otherwise.
+ * Missing/unreadable/malformed → undefined
  * (never throws; never logs file contents).
  */
 export function readAgentIdentityCompanyUid(env = process.env) {
-    const file = env[HQ_AGENT_IDENTITY_FILE_ENV]?.trim();
+    // An explicit override (including empty/missing paths) never falls back to
+    // another identity. This prevents accidental attribution to a different box.
+    const file = (env[HQ_AGENT_IDENTITY_FILE_ENV] ?? DEFAULT_AGENT_IDENTITY_FILE).trim();
     if (!file)
         return undefined;
     try {

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

@@ -5,7 +5,7 @@
 import type { DeliveryState } from "./contract.js";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 /** Fields allowed on a durable outbox operation (privacy allowlist). */
-export declare const OUTBOX_ALLOWLIST: readonly ["contractVersion", "operationId", "clientOperationId", "sessionId", "companyUid", "companySlug", "projectId", "taskId", "kind", "digest", "delivery", "createdAt", "updatedAt", "attemptCount", "lastErrorCode", "receiptId", "destinationCompanyUid", "destinationCompanySlug", "nextAttemptAt"];
+export declare const OUTBOX_ALLOWLIST: readonly ["contractVersion", "operationId", "clientOperationId", "sessionId", "harness", "companyUid", "companySlug", "projectId", "taskId", "kind", "digest", "delivery", "createdAt", "updatedAt", "attemptCount", "lastErrorCode", "receiptId", "destinationCompanyUid", "destinationCompanySlug", "nextAttemptAt"];
 /** Base delay for outbox retry backoff (attempt 1 → 30s). */
 export declare const OUTBOX_RETRY_BASE_MS = 30000;
 /** Cap for outbox retry backoff (6 hours). */
@@ -20,6 +20,7 @@ export interface OutboxOperation {
     operationId: string;
     clientOperationId: string;
     sessionId: string;
+    harness?: string;
     companyUid?: string;
     companySlug?: string;
     projectId?: string;
@@ -41,6 +42,7 @@ export interface OutboxOperation {
 export interface OutboxEnqueueInput {
     clientOperationId: string;
     sessionId: string;
+    harness?: string;
     companyUid?: string;
     companySlug?: string;
     projectId?: string;
@@ -54,6 +56,7 @@ export declare function clearOutboxListCache(): void;
 export declare function stableOperationId(clientOperationId: string, sessionId: string): string;
 export declare function digestOperation(parts: {
     sessionId: string;
+    harness?: string;
     clientOperationId: string;
     companyUid?: string;
     companySlug?: string;
@@ -75,6 +78,25 @@ export declare function updateOutboxOperation(op: OutboxOperation, root: string)
 export declare function markOutboxAcked(operationId: string, root: string, receiptId: string, now?: () => Date): OutboxOperation | null;
 export declare function markOutboxQueued(operationId: string, root: string, errorCode: string, now?: () => Date, random?: () => number): OutboxOperation | null;
 export declare function markOutboxQuarantined(operationId: string, root: string, errorCode: string, now?: () => Date): OutboxOperation | null;
+/**
+ * Requeue quarantined outbox operations so the daemon's replay picks them up
+ * again. Quarantine is otherwise terminal: after the work-mesh-live gap 10 fix
+ * (agent boxes now send the ID token, see src/lib/mesh/api.ts requireToken),
+ * ops previously quarantined as AUTH_DENIED — 403 NO_PERSON_ENTITY caused by
+ * sending the person ACCESS token — will not retry on their own. This flips
+ * them back to `queued`, resets attemptCount, and clears nextAttemptAt so they
+ * are due immediately.
+ *
+ * `opts.errorCode` selects which quarantined ops to requeue by lastErrorCode:
+ *   - omitted → defaults to "AUTH_DENIED" (a bare call only recovers the gap 10
+ *     regression, never e.g. VALIDATION_FAILED ops that are genuinely bad).
+ *   - a string → only ops whose lastErrorCode matches.
+ *   - `null` → every quarantined op regardless of code.
+ */
+export declare function requeueQuarantinedOutbox(root: string, opts?: {
+    errorCode?: string | null;
+    now?: () => Date;
+}): OutboxOperation[];
 export type OutboxListReadFile = (filePath: string) => string;
 export declare function listOutboxOperations(root: string, deps?: {
     readFile?: OutboxListReadFile;

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

@@ -15,6 +15,7 @@ export const OUTBOX_ALLOWLIST = [
     "operationId",
     "clientOperationId",
     "sessionId",
+    "harness",
     "companyUid",
     "companySlug",
     "projectId",
@@ -59,6 +60,7 @@ export function digestOperation(parts) {
     const canonical = JSON.stringify({
         v: 1,
         sessionId: parts.sessionId,
+        ...(parts.harness ? { harness: parts.harness } : {}),
         clientOperationId: parts.clientOperationId,
         companyUid: parts.companyUid ?? null,
         companySlug: parts.companySlug ?? null,
@@ -83,6 +85,8 @@ function projectOutbox(op) {
         updatedAt: op.updatedAt,
         attemptCount: op.attemptCount,
     };
+    if (op.harness)
+        out.harness = op.harness;
     if (op.companyUid)
         out.companyUid = op.companyUid;
     if (op.companySlug)
@@ -132,6 +136,7 @@ export function enqueueOutbox(input, root) {
     }
     const digest = digestOperation({
         sessionId: input.sessionId,
+        harness: input.harness,
         clientOperationId: input.clientOperationId,
         companyUid: input.companyUid,
         companySlug: input.companySlug,
@@ -144,7 +149,14 @@ export function enqueueOutbox(input, root) {
     const now = (input.now ?? (() => new Date()))().toISOString();
     const existing = readOutboxOperation(operationId, root);
     if (existing) {
-        if (existing.digest !== digest) {
+        // A pre-upgrade operation has no harness in its digest. Preserve its
+        // original receipt identity when the same observation is enqueued again.
+        const legacyReplay = !existing.harness && input.harness && existing.digest === digestOperation({
+            ...input,
+            harness: undefined,
+            kind,
+        });
+        if (existing.digest !== digest && !legacyReplay) {
             throw new NotTrackingError(`Idempotency conflict for ${operationId}`, "IdempotencyConflictError");
         }
         return existing;
@@ -154,6 +166,7 @@ export function enqueueOutbox(input, root) {
         operationId,
         clientOperationId: input.clientOperationId,
         sessionId: input.sessionId,
+        harness: input.harness,
         companyUid: input.companyUid,
         companySlug: input.companySlug,
         projectId: input.projectId,
@@ -270,6 +283,40 @@ export function markOutboxQuarantined(operationId, root, errorCode, now = () =>
     updateOutboxOperation(op, root);
     return op;
 }
+/**
+ * Requeue quarantined outbox operations so the daemon's replay picks them up
+ * again. Quarantine is otherwise terminal: after the work-mesh-live gap 10 fix
+ * (agent boxes now send the ID token, see src/lib/mesh/api.ts requireToken),
+ * ops previously quarantined as AUTH_DENIED — 403 NO_PERSON_ENTITY caused by
+ * sending the person ACCESS token — will not retry on their own. This flips
+ * them back to `queued`, resets attemptCount, and clears nextAttemptAt so they
+ * are due immediately.
+ *
+ * `opts.errorCode` selects which quarantined ops to requeue by lastErrorCode:
+ *   - omitted → defaults to "AUTH_DENIED" (a bare call only recovers the gap 10
+ *     regression, never e.g. VALIDATION_FAILED ops that are genuinely bad).
+ *   - a string → only ops whose lastErrorCode matches.
+ *   - `null` → every quarantined op regardless of code.
+ */
+export function requeueQuarantinedOutbox(root, opts = {}) {
+    const errorCode = opts.errorCode === undefined ? "AUTH_DENIED" : opts.errorCode;
+    const now = opts.now ?? (() => new Date());
+    const requeued = [];
+    for (const op of listOutboxOperations(root)) {
+        if (op.delivery !== "quarantined")
+            continue;
+        if (errorCode !== null && op.lastErrorCode !== errorCode)
+            continue;
+        op.delivery = "queued";
+        op.attemptCount = 0;
+        op.lastErrorCode = undefined;
+        op.nextAttemptAt = undefined;
+        op.updatedAt = now().toISOString();
+        updateOutboxOperation(op, root);
+        requeued.push(op);
+    }
+    return requeued;
+}
 export function listOutboxOperations(root, deps = {}) {
     const readFile = deps.readFile ?? ((filePath) => fs.readFileSync(filePath, "utf8"));
     const dir = workContextOutboxDir(root);

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

@@ -4,7 +4,7 @@
  */
 import * as fs from "node:fs";
 import { InvalidSessionIdentityError, normalizeSessionIdentity, } from "../mesh/live/session-identity.js";
-import { companyCorrectionPath, resolveCompany, } from "./company.js";
+import { companyCorrectionPath, companySlugFromCwd, resolveCompany, } from "./company.js";
 import { WORK_CONTEXT_CONTRACT_VERSION, normalizeTaskId, } from "./contract.js";
 import { EXIT_INVALID_IDENTITY, EXIT_NOT_TRACKING, EXIT_OK, InvalidDecisionOriginError, NotTrackingError, } from "./errors.js";
 import { decisionFromCandidates, } from "./organize.js";
@@ -385,7 +385,7 @@ export async function reconcileObservation(obs, deps) {
         }
     }
     // Company resolved — resolve project/task (US-007B order).
-    const projectResolved = resolveProjectTask({
+    let projectResolved = resolveProjectTask({
         sessionId,
         env,
         trusted,
@@ -393,6 +393,14 @@ export async function reconcileObservation(obs, deps) {
         hqRoot,
         existingState: prior,
     });
+    // Deterministic cwd projects belong to the cwd company. A higher-precedence
+    // identity UID must not adopt a project from an unrelated/unverified slug.
+    if (projectResolved?.source === "deterministic_cwd") {
+        const cwdCompany = companySlugFromCwd(cwd, hqRoot);
+        if (!resolvedCompany.slug || cwdCompany?.toLowerCase() !== resolvedCompany.slug.toLowerCase()) {
+            projectResolved = null;
+        }
+    }
     const projectId = projectResolved?.projectId;
     const taskId = projectResolved?.taskId;
     // Trusted / deterministic auto-bind never asks.
@@ -475,6 +483,7 @@ export async function reconcileObservation(obs, deps) {
         outboxOp = enqueueOutbox({
             clientOperationId: obs.clientOperationId,
             sessionId,
+            harness: obs.identity.harness,
             companyUid: resolvedCompany.uid,
             companySlug: resolvedCompany.slug,
             projectId,

package/package.json

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