@indigoai-us/hq-cli 5.108.22 → 5.108.23

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [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

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/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/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/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/outbox.d.ts

@@ -78,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

@@ -283,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/package.json

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