@indigoai-us/hq-cli 5.121.1 → 5.122.0

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

@@ -18,6 +18,8 @@ import { replayOutbox } from "../../../work-context/outbox.js";
 import { workContextRoot } from "../../../work-context/paths.js";
 import { createSessionEventsPoster, resolveVaultApiBase, } from "../session-events-client.js";
 import { flushSessionEvents, HELD_RETRY_INTERVAL_MS, } from "../flush.js";
+import { backfillHeldSessions, } from "../backfill-held.js";
+import { reconcileObservation } from "../../../work-context/reconcile.js";
 import { workMeshRoot, workMeshSpoolPath } from "../paths.js";
 import { createVaultBoardReader, refreshBoundSessionBoards, BOARD_REFRESH_INTERVAL_MS, } from "./board-refresh.js";
 import { createContract3Fetcher, realTimerHost, } from "./credentials.js";
@@ -31,6 +33,8 @@ import { noteHookSessionsFromSpoolFile, TRANSCRIPT_WATCH_INTERVAL_MS, Transcript
 import { resolveMeshEmitMode, runsEmitPath, } from "./mode.js";
 export const SPOOL_DEBOUNCE_MS = 2_000;
 export const FLUSH_INTERVAL_MS = 10_000;
+/** Keep startup recovery bounded: the next daemon start continues the backlog. */
+export const HELD_BACKFILL_STARTUP_BATCH_SIZE = 100;
 /**
  * Only producer appends to spool.jsonl should wake the watcher. Every other
  * file in the work-mesh root (held.jsonl, spool.<ts>.claimed, held.<ts>.claimed,
@@ -121,6 +125,26 @@ export async function runMeshDaemon(deps = {}) {
             const deliver = createWorkSessionDeliverer({ token: t });
             return replayOutbox(ctxRoot, deliver);
         });
+    const backfillFn = deps.backfillHeld ??
+        (async () => {
+            const token = await getToken();
+            const deliver = createWorkSessionDeliverer({ token });
+            return backfillHeldSessions({
+                workMeshRoot: meshRoot,
+                workContextRoot: ctxRoot,
+                limit: deps.heldBackfillBatchSize ?? HELD_BACKFILL_STARTUP_BATCH_SIZE,
+                env,
+                reconcile: (observation) => reconcileObservation(observation, {
+                    root: ctxRoot,
+                    env,
+                    deliver,
+                    validateMembership: async (slug) => {
+                        const membership = await resolveActiveMembershipCompany(token, slug);
+                        return membership ? { uid: membership.companyUid } : false;
+                    },
+                }),
+            });
+        });
     const boardLast = new Map();
     const refreshFn = deps.refreshBoards ??
         (async () => {
@@ -253,6 +277,23 @@ export async function runMeshDaemon(deps = {}) {
         }
         flushInFlight = (async () => {
             try {
+                // A held session has already ended, so no later hook will naturally
+                // revisit its context. Repair a bounded batch before the first flush;
+                // recovered state is then retried immediately in this same cycle.
+                if (reason === "start") {
+                    try {
+                        const recovered = await backfillFn();
+                        if (recovered.reconciled > 0 ||
+                            recovered.unresolved > 0 ||
+                            recovered.errors > 0) {
+                            log(dir, `held backfill: considered=${recovered.considered} reconciled=${recovered.reconciled} unresolved=${recovered.unresolved} errors=${recovered.errors}`);
+                        }
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        log(dir, `held backfill error: ${msg.slice(0, 200)}`);
+                    }
+                }
                 // Record hook-emitted session ids from spool/held before claim/rename.
                 const at = now().getTime();
                 noteHookSessionsFromSpoolFile(workMeshSpoolPath(meshRoot), lastHookEventAt, at);

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

@@ -10,7 +10,10 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { resolveCompany } from "../../work-context/company.js";
+import { deriveRemoteOwnerSlug, deriveRepoIdentityKey, } from "../../work-context/repo-remote.js";
 import { readSessionState } from "../../work-context/state.js";
+import { repairAckedRegisterStates } from "../../work-context/outbox.js";
 import { workContextRoot } from "../../work-context/paths.js";
 import { defaultSleep, FLUSH_MAX_ATTEMPTS, fullJitterDelayMs, } from "./backoff.js";
 import { LOCAL_ONLY_FIELDS, stripLocalOnlyFields } from "./format-spool-line.js";
@@ -60,6 +63,35 @@ function unwrapHeld(obj) {
 function heldEnvelope(event, heldReason, heldAt) {
     return JSON.stringify({ event, heldReason, heldAt });
 }
+/**
+ * A seven-day retention rule must never beat local recovery. An event can
+ * still carry enough trusted/deterministic context (or have a configured
+ * device default) to reconcile its session on the next daemon startup.
+ */
+function isLocallyReconcilableHeldEvent(event, state, workContextRoot) {
+    const sessionId = sessionIdOf(event);
+    if (!sessionId || state?.companyUid)
+        return Boolean(sessionId && state?.companyUid);
+    const text = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+    const cwd = text(event.cwd);
+    const hqRoot = text(event.hqRoot);
+    const remoteOwnerSlug = cwd
+        ? deriveRemoteOwnerSlug({ cwd, hqRoot }) ?? undefined
+        : undefined;
+    const repoIdentityKey = cwd ? deriveRepoIdentityKey({ cwd }) : null;
+    return (resolveCompany({
+        root: workContextRoot,
+        sessionId,
+        existingState: state,
+        trusted: text(event.companySlug)
+            ? { companySlug: text(event.companySlug) }
+            : undefined,
+        cwd,
+        hqRoot,
+        remoteOwnerSlug,
+        repoIdentityKey,
+    }).status === "resolved");
+}
 function deadLetterEnvelope(event, reason, responseCode, at) {
     return JSON.stringify({ event, reason, responseCode, at });
 }
@@ -157,10 +189,16 @@ export async function flushSessionEvents(deps) {
                     summary.deadLettered += 1;
                     continue;
                 }
-                // Expire held lines older than 7 days.
+                // Expire held lines older than 7 days only when local recovery cannot
+                // still resolve the session. The daemon backfill runs before startup
+                // flush, so retaining these lines gives that deterministic repair a
+                // chance rather than silently losing attributable work.
                 if (heldAt) {
                     const age = now().getTime() - Date.parse(heldAt);
-                    if (Number.isFinite(age) && age > HELD_TTL_MS) {
+                    const state = readSessionState(sessionIdOf(event), deps.workContextRoot);
+                    if (Number.isFinite(age) &&
+                        age > HELD_TTL_MS &&
+                        !isLocallyReconcilableHeldEvent(event, state, deps.workContextRoot)) {
                         appendDeadLetterLine(deadLetterEnvelope(event, "HELD_EXPIRED", "held_ttl", now().toISOString()), deps.workMeshRoot);
                         summary.deadLettered += 1;
                         continue;
@@ -171,6 +209,10 @@ export async function flushSessionEvents(deps) {
             }
         }
         const bySession = groupBySession(collected);
+        // Older clients acknowledged register operations without copying the
+        // authoritative company into the session projection. Repair those files
+        // before classification so a valid receipt cannot be held as NEEDS_COMPANY.
+        repairAckedRegisterStates(deps.workContextRoot, new Set(bySession.keys()), now);
         const markDisposed = (event) => {
             pendingRestore.delete(event);
         };

package/dist/lib/mesh/live/spool.d.ts

@@ -49,4 +49,17 @@ export declare function recoverOrphanClaims(root: string): {
 export declare function removeClaimFile(claimPath: string | null): void;
 export declare function deadLetterNonEmpty(root?: string): boolean;
 export declare function countJsonlLines(filePath: string): number;
+/** Local queues that still lack a usable company attribution. */
+export interface UnattributedEventCounts {
+    spool: number;
+    held: number;
+    deadLetter: number;
+    total: number;
+}
+/**
+ * Count the actionable, unfiled events across all local delivery queues.
+ * This deliberately does not inspect session state: the signal must stay
+ * visible even when state is absent or corrupt.
+ */
+export declare function countUnattributedEvents(root?: string): UnattributedEventCounts;
 //# sourceMappingURL=spool.d.ts.map

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

@@ -195,4 +195,71 @@ export function countJsonlLines(filePath) {
     }
     return n;
 }
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * A queue line can be a raw event, a held envelope, or a dead-letter
+ * envelope. Count the line when it is explicitly marked NEEDS_COMPANY/NONE,
+ * or when its underlying event has no company identity at all.
+ */
+function isUnattributedLine(line) {
+    try {
+        const outer = record(JSON.parse(line));
+        if (!outer)
+            return false;
+        const event = record(outer.event) ?? outer;
+        const markers = [
+            outer.heldReason,
+            outer.reason,
+            outer.contextStatus,
+            event.heldReason,
+            event.reason,
+            event.contextStatus,
+            event.company,
+            event.companyUid,
+            event.companySlug,
+        ];
+        if (markers.some((value) => typeof value === "string" &&
+            ["NEEDS_COMPANY", "NONE"].includes(value.trim().toUpperCase()))) {
+            return true;
+        }
+        return ![
+            event.companyUid,
+            event.companySlug,
+            event.company,
+        ].some((value) => typeof value === "string" && value.trim().length > 0);
+    }
+    catch {
+        // Malformed lines are reported separately by the dead-letter count.
+        return false;
+    }
+}
+function countUnattributedJsonlLines(filePath) {
+    if (!fs.existsSync(filePath))
+        return 0;
+    try {
+        return fs
+            .readFileSync(filePath, "utf8")
+            .split("\n")
+            .filter((line) => line.trim() && isUnattributedLine(line)).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Count the actionable, unfiled events across all local delivery queues.
+ * This deliberately does not inspect session state: the signal must stay
+ * visible even when state is absent or corrupt.
+ */
+export function countUnattributedEvents(root) {
+    const meshRoot = root ?? workMeshRoot();
+    const spool = countUnattributedJsonlLines(workMeshSpoolPath(meshRoot));
+    const held = countUnattributedJsonlLines(workMeshHeldPath(meshRoot));
+    const deadLetter = countUnattributedJsonlLines(workMeshDeadLetterPath(meshRoot));
+    return { spool, held, deadLetter, total: spool + held + deadLetter };
+}
 //# sourceMappingURL=spool.js.map

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

@@ -1,7 +1,6 @@
 /**
  * Device-local default company preference (~/.hq/work-context/config.json).
  * Preference only — never authority. activeCompany is never treated as default.
- * Default-company mode ships dark until migrationCapability (US-017A).
  */
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 export declare const DEVICE_CONFIG_SCHEMA_VERSION: 1;
@@ -61,9 +60,7 @@ export interface DeviceConfigDeps {
 }
 export declare function readDeviceConfig(deps: Pick<DeviceConfigDeps, "root">): WorkContextDeviceConfig;
 export declare function getDefaultCompany(deps: Pick<DeviceConfigDeps, "root">): DeviceDefaultCompany | null;
-export declare function setDefaultCompany(slug: string, deps: DeviceConfigDeps & {
-    allowWithoutMigration?: boolean;
-}): Promise<WorkContextDeviceConfig>;
+export declare function setDefaultCompany(slug: string, deps: DeviceConfigDeps): Promise<WorkContextDeviceConfig>;
 export declare function clearDefaultCompany(deps: DeviceConfigDeps): WorkContextDeviceConfig;
 /**
  * Read the persisted company mapping for a repo identity key (gap 4).

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

@@ -1,12 +1,11 @@
 /**
  * Device-local default company preference (~/.hq/work-context/config.json).
  * Preference only — never authority. activeCompany is never treated as default.
- * Default-company mode ships dark until migrationCapability (US-017A).
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { atomicWriteJson, ensureOwnerDir, resolveRealTarget } from "./atomic.js";
-import { DefaultCompanyLockedError, DefaultCompanyUnavailableError, UnsafeConfigPathError, WorkContextError, } from "./errors.js";
+import { DefaultCompanyUnavailableError, UnsafeConfigPathError, WorkContextError, } from "./errors.js";
 import { workContextConfigPath, workContextRoot } from "./paths.js";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 export const DEVICE_CONFIG_SCHEMA_VERSION = 1;
@@ -116,9 +115,6 @@ export async function setDefaultCompany(slug, deps) {
     if (!trimmed || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed)) {
         throw new WorkContextError("InvalidCompanySlug", `Invalid company slug: ${slug}`);
     }
-    if (!deps.migrationCapability && !deps.allowWithoutMigration) {
-        throw new DefaultCompanyLockedError();
-    }
     if (!deps.validateMembership) {
         throw new DefaultCompanyUnavailableError(`Cannot verify membership for company "${trimmed}" (no membership validator)`);
     }

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

@@ -76,6 +76,14 @@ export declare function enqueueOutbox(input: OutboxEnqueueInput, root: string):
 export declare function readOutboxOperation(operationId: string, root: string): OutboxOperation | null;
 export declare function updateOutboxOperation(op: OutboxOperation, root: string): void;
 export declare function markOutboxAcked(operationId: string, root: string, receiptId: string, now?: () => Date): OutboxOperation | null;
+/**
+ * Write server-acknowledged register scope into the session projection.
+ * This closes the outbox → emitter handoff for both direct reconciliation and
+ * daemon replay. Non-register or incomplete legacy operations are ignored.
+ */
+export declare function writeAckedRegisterState(op: OutboxOperation, root: string, receiptId: string, now?: () => Date): void;
+/** Repair older unresolved session projections from acknowledged registrations. */
+export declare function repairAckedRegisterStates(root: string, sessionIds?: ReadonlySet<string>, now?: () => Date): number;
 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;
 /**

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

@@ -8,6 +8,7 @@ import * as path from "node:path";
 import { WORK_CONTEXT_CONTRACT_VERSION } from "./contract.js";
 import { atomicWriteJson, ensureOwnerDir } from "./atomic.js";
 import { NotTrackingError } from "./errors.js";
+import { readSessionState, writeAcknowledgedRegisterBinding, } from "./state.js";
 import { isSafeWorkContextSegment, workContextOutboxDir, workContextOutboxPath, } from "./paths.js";
 /** Fields allowed on a durable outbox operation (privacy allowlist). */
 export const OUTBOX_ALLOWLIST = [
@@ -258,6 +259,51 @@ export function markOutboxAcked(operationId, root, receiptId, now = () => new Da
     updateOutboxOperation(op, root);
     return op;
 }
+/**
+ * Write server-acknowledged register scope into the session projection.
+ * This closes the outbox → emitter handoff for both direct reconciliation and
+ * daemon replay. Non-register or incomplete legacy operations are ignored.
+ */
+export function writeAckedRegisterState(op, root, receiptId, now = () => new Date()) {
+    if (op.kind !== "register" || !op.companyUid)
+        return;
+    writeAcknowledgedRegisterBinding({
+        kind: "register",
+        sessionId: op.sessionId,
+        companyUid: op.companyUid,
+        companySlug: op.companySlug,
+        projectId: op.projectId,
+        taskId: op.taskId,
+        receiptId,
+    }, root, now);
+}
+/** Repair older unresolved session projections from acknowledged registrations. */
+export function repairAckedRegisterStates(root, sessionIds, now = () => new Date()) {
+    let repaired = 0;
+    for (const op of listOutboxOperations(root)) {
+        if (op.delivery !== "acked" ||
+            !op.receiptId ||
+            op.kind !== "register" ||
+            !op.companyUid ||
+            (sessionIds && !sessionIds.has(op.sessionId))) {
+            continue;
+        }
+        const before = readSessionState(op.sessionId, root);
+        const after = writeAcknowledgedRegisterBinding({
+            kind: "register",
+            sessionId: op.sessionId,
+            companyUid: op.companyUid,
+            companySlug: op.companySlug,
+            projectId: op.projectId,
+            taskId: op.taskId,
+            receiptId: op.receiptId,
+        }, root, now);
+        if (after && (before?.contextStatus === "unresolved" || !before?.companyUid)) {
+            repaired += 1;
+        }
+    }
+    return repaired;
+}
 export function markOutboxQueued(operationId, root, errorCode, now = () => new Date(), random = Math.random) {
     const op = readOutboxOperation(operationId, root);
     if (!op)
@@ -461,6 +507,7 @@ export async function replayOutbox(root, deliver, opts = {}) {
             const result = await deliver(op);
             if (result.ok) {
                 markOutboxAcked(op.operationId, root, result.receiptId, now);
+                writeAckedRegisterState(op, root, result.receiptId, now);
                 delivered += 1;
             }
             else if (result.retryable) {

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

@@ -10,7 +10,7 @@ import { EXIT_INVALID_IDENTITY, EXIT_NOT_TRACKING, EXIT_OK, InvalidDecisionOrigi
 import { decisionFromCandidates, } from "./organize.js";
 import { resolveProjectTask, shouldAskAfter } from "./project.js";
 import { deriveRemoteOwnerSlug, deriveRepoIdentityKey } from "./repo-remote.js";
-import { enqueueOutbox, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, } from "./outbox.js";
+import { enqueueOutbox, markOutboxAcked, markOutboxQuarantined, markOutboxQueued, replayOutbox, writeAckedRegisterState, } from "./outbox.js";
 import { mergeLocalSessionFields, readSessionState, writeSessionState, } from "./state.js";
 function resultOf(parts) {
     const out = {
@@ -482,6 +482,15 @@ export async function reconcileObservation(obs, deps) {
         registerClassification === "unresolved") {
         registerClassification = "needs_project";
     }
+    // Do not let a weak later observation erase a server-acknowledged company
+    // binding. Keep the result unresolved so the normal candidate threshold can
+    // still advance the session, while preserving the durable emitter projection.
+    const stateClassification = registerClassification === "unresolved" &&
+        prior?.contextStatus === "needs_project" &&
+        prior.companyUid === resolvedCompany.uid &&
+        prior.bindingEpisodeId
+        ? "needs_project"
+        : registerClassification;
     let outboxOp;
     try {
         outboxOp = enqueueOutbox({
@@ -524,7 +533,7 @@ export async function reconcileObservation(obs, deps) {
             sessionId,
             companyUid: resolvedCompany.uid,
             companySlug: resolvedCompany.slug,
-            contextStatus: registerClassification,
+            contextStatus: stateClassification,
             projectId,
             taskId,
             updatedAt: nowIso,
@@ -578,6 +587,7 @@ export async function reconcileObservation(obs, deps) {
     const delivered = await deps.deliver(outboxOp);
     if (delivered.ok) {
         markOutboxAcked(outboxOp.operationId, deps.root, delivered.receiptId, nowFn);
+        writeAckedRegisterState(outboxOp, deps.root, delivered.receiptId, nowFn);
         // Persist binding episode on success for bound registrations.
         if (registerClassification === "bound") {
             writeSessionState(mergeLocalSessionFields({

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

@@ -91,6 +91,20 @@ export interface SessionStateFile {
     transcriptMarker?: "from transcript";
     updatedAt: string;
 }
+/**
+ * Metadata from a register operation that the control plane has acknowledged.
+ * Kept structural here so the state projection does not need a runtime
+ * dependency on the outbox implementation.
+ */
+export interface AcknowledgedRegisterBinding {
+    kind: "register";
+    sessionId: string;
+    companyUid?: string;
+    companySlug?: string;
+    projectId?: string;
+    taskId?: string;
+    receiptId: string;
+}
 /** Allowlisted keys that may appear in the durable state projection. */
 export declare const SESSION_STATE_ALLOWLIST: Set<string>;
 export declare function readSessionState(sessionId: string, root: string): SessionStateFile | null;
@@ -102,6 +116,15 @@ export declare function projectSessionState(state: SessionStateFile): SessionSta
  * and reconcile updates do not clobber each other.
  */
 export declare function mergeLocalSessionFields(next: SessionStateFile, prior: SessionStateFile | null): SessionStateFile;
+/**
+ * Upgrade the local projection after the server acknowledges a register.
+ *
+ * A receipt makes the operation's company authoritative, but it must never
+ * erase an explicit untracked choice, a conflicting existing company, or a
+ * more specific binding for the same company. This is also used to repair
+ * state files created by older clients before this write-back existed.
+ */
+export declare function writeAcknowledgedRegisterBinding(binding: AcknowledgedRegisterBinding, root: string, now?: () => Date): SessionStateFile | null;
 /** True when a durable state file was written by the hook / reconcile path. */
 export declare function isHookWrittenSessionState(state: SessionStateFile | null): boolean;
 /** Authoritative prior scope usable for company precedence. */

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

@@ -136,6 +136,73 @@ export function mergeLocalSessionFields(next, prior) {
     }
     return out;
 }
+function acknowledgedStatus(binding) {
+    if (!binding.companyUid)
+        return null;
+    if (binding.projectId && binding.taskId)
+        return "bound";
+    if (binding.projectId)
+        return "needs_task";
+    return "needs_project";
+}
+function bindingStrength(state) {
+    if (state.contextStatus === "bound" && state.projectId && state.taskId)
+        return 3;
+    if (state.contextStatus === "needs_task" && state.projectId)
+        return 2;
+    if (state.contextStatus === "needs_project")
+        return 1;
+    return 0;
+}
+/**
+ * Upgrade the local projection after the server acknowledges a register.
+ *
+ * A receipt makes the operation's company authoritative, but it must never
+ * erase an explicit untracked choice, a conflicting existing company, or a
+ * more specific binding for the same company. This is also used to repair
+ * state files created by older clients before this write-back existed.
+ */
+export function writeAcknowledgedRegisterBinding(binding, root, now = () => new Date()) {
+    const acknowledged = acknowledgedStatus(binding);
+    if (!acknowledged || !isSafeWorkContextSegment(binding.sessionId))
+        return null;
+    const prior = readSessionState(binding.sessionId, root);
+    // Reconcile always writes the local projection before network delivery. Do
+    // not manufacture session files when replay sees an orphaned legacy outbox
+    // record with no corresponding tracked session.
+    if (!prior)
+        return null;
+    if (prior.contextStatus === "untracked" ||
+        (prior.companyUid && prior.companyUid !== binding.companyUid)) {
+        return prior;
+    }
+    const acknowledgementStrength = acknowledged === "bound" ? 3 : acknowledged === "needs_task" ? 2 : 1;
+    const priorStrength = bindingStrength(prior);
+    const preservePriorBinding = Boolean(prior.companyUid === binding.companyUid && priorStrength > acknowledgementStrength);
+    const next = mergeLocalSessionFields({
+        contractVersion: WORK_CONTEXT_CONTRACT_VERSION,
+        sessionId: binding.sessionId,
+        companyUid: binding.companyUid,
+        companySlug: binding.companySlug ?? prior.companySlug,
+        contextStatus: preservePriorBinding ? prior.contextStatus : acknowledged,
+        projectId: preservePriorBinding ? prior.projectId : binding.projectId,
+        taskId: preservePriorBinding ? prior.taskId : binding.taskId,
+        bindingEpisodeId: preservePriorBinding
+            ? prior.bindingEpisodeId ?? binding.receiptId
+            : binding.receiptId,
+        updatedAt: now().toISOString(),
+    }, prior);
+    if (prior.companyUid === next.companyUid &&
+        prior.companySlug === next.companySlug &&
+        prior.contextStatus === next.contextStatus &&
+        prior.projectId === next.projectId &&
+        prior.taskId === next.taskId &&
+        prior.bindingEpisodeId === next.bindingEpisodeId) {
+        return prior;
+    }
+    writeSessionState(next, root);
+    return next;
+}
 /** True when a durable state file was written by the hook / reconcile path. */
 export function isHookWrittenSessionState(state) {
     if (!state)

package/package.json

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