@indigoai-us/hq-cli 5.345.24 → 5.345.26

package/dist/lib/lanes/store.js

@@ -784,6 +784,25 @@ export function parseLaneRecord(raw, filePath) {
         }
     }
     parseOptionalCompanyField(raw, filePath);
+    if (raw.company_history !== undefined) {
+        if (!Array.isArray(raw.company_history) || raw.company_history.length > HISTORY_CAP) {
+            throw new LaneSchemaError(`company_history must be an array capped at ${HISTORY_CAP} entries`, {
+                path: filePath,
+                field: "company_history",
+            });
+        }
+        for (const [index, entry] of raw.company_history.entries()) {
+            const field = `company_history[${index}]`;
+            if (!isPlainObject(entry) || Object.keys(entry).some((key) => !["from", "to", "at", "by", "reason"].includes(key)) ||
+                entry.from !== null || entry.reason !== "repair_company" || !isPlainObject(entry.to)) {
+                throw new LaneSchemaError(`${field} must be a company repair audit entry`, { path: filePath, field });
+            }
+            requireString(entry.to.slug, `${field}.to.slug`);
+            requireString(entry.to.uid, `${field}.to.uid`);
+            requireString(entry.by, `${field}.by`);
+            requireTimestamp(entry.at, `${field}.at`, filePath);
+        }
+    }
     parseOptionalMeshCompanyField(raw, filePath);
     if (!isPlainObject(raw.senior)) {
         throw new LaneSchemaError("senior must be an object", { path: filePath });
@@ -1242,9 +1261,23 @@ export function mergeLaneRecords(live, sidecars) {
         return live;
     const all = [live, ...sidecars];
     const base = higherVersionRecord(live, sidecars);
+    const attributedCompanies = all.filter((record) => record.company !== null).map((record) => record.company);
+    const conflictingCompanies = attributedCompanies.some((company, index) => attributedCompanies.slice(index + 1).some((other) => company.uid && other.uid
+        ? company.uid !== other.uid
+        : Boolean(company.slug && other.slug && company.slug !== other.slug)));
+    if (conflictingCompanies) {
+        throw new LaneSchemaError("Conflicting company attribution in lane record sidecars", { lane_id: live.lane_id });
+    }
+    const company = base.company ?? attributedCompanies[0] ?? null;
     return {
         ...base,
+        company,
         senior_history: unionHistory(all.map((record) => record.senior_history), entryIdentity, base.senior_history),
+        ...(all.some((record) => record.company_history !== undefined)
+            ? {
+                company_history: unionHistory(all.map((record) => record.company_history ?? []), entryIdentity, base.company_history ?? []),
+            }
+            : {}),
         attribution_history: unionHistory(all.map((record) => record.attribution_history), attributionIdentity, base.attribution_history),
         ...(all.some((record) => record.account_history !== undefined)
             ? {

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

@@ -64,6 +64,8 @@ export declare function laneStoryLedgerEnabled(): boolean;
 export declare function resolveProjectStoryLedger(hqRoot: string, projectId: string, companySlug?: string): ProjectStoryLedger;
 export declare function validateProjectStories(hqRoot: string, projectId: string, storyIds: readonly string[], companySlug?: string): ProjectStoryLedger;
 export declare function syncLaneToProjectStoryLedger(hqRoot: string, lane: LaneRecord, questionRefs?: readonly StoryLedgerQuestionRef[], deps?: StoryLedgerWriteDeps): void;
+/** Remove only this lane's attribution from its former personal story ledgers. */
+export declare function removeLaneFromProjectStoryLedger(hqRoot: string, lane: LaneRecord): void;
 /** Read canonical ledger states for the story ids currently carried by a lane. */
 export declare function readProjectStoryStates(hqRoot: string, projectId: string, storyIds: readonly string[], companySlug?: string): Map<string, string>;
 export declare function buildLaneStatusSnapshot(input: {

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

@@ -643,6 +643,39 @@ export function syncLaneToProjectStoryLedger(hqRoot, lane, questionRefs = [], de
         }, deps);
     }
 }
+/** Remove only this lane's attribution from its former personal story ledgers. */
+export function removeLaneFromProjectStoryLedger(hqRoot, lane) {
+    if (!laneStoryLedgerEnabled())
+        return;
+    const refs = [...new Map(laneStoriesForLedger(lane).map((story) => [
+            story.project_id + "\u0000" + story.story_id,
+            { projectId: story.project_id, storyId: story.story_id },
+        ])).values()];
+    for (const ref of refs) {
+        const ledger = resolveProjectStoryLedger(hqRoot, ref.projectId);
+        if (!fs.existsSync(ledger.path))
+            continue;
+        updateLedgerAtomically(ledger, (current) => {
+            const story = current.userStories.find((item) => item.id === ref.storyId);
+            if (!story)
+                return current;
+            if (Array.isArray(story.lanes)) {
+                story.lanes = story.lanes.filter((entry) => !isJsonObject(entry) || entry.lane_id !== lane.lane_id);
+            }
+            if (Array.isArray(story.pending_questions)) {
+                const pendingQuestions = story.pending_questions.filter((entry) => !isJsonObject(entry) || entry.lane_id !== lane.lane_id);
+                if (pendingQuestions.length === 0)
+                    delete story.pending_questions;
+                else
+                    story.pending_questions = pendingQuestions;
+            }
+            if (isJsonObject(story.lane_status) && isJsonObject(story.lane_status.saved) && Array.isArray(story.lane_status.saved.pending_questions)) {
+                story.lane_status.saved.pending_questions = story.lane_status.saved.pending_questions.filter((entry) => !isJsonObject(entry) || entry.lane_id !== lane.lane_id);
+            }
+            return current;
+        });
+    }
+}
 function storyLaneState(lane, laneStoryStatus, pendingQuestionIds) {
     if (isTerminalLaneState(lane.state))
         return lane.state;

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

@@ -308,6 +308,14 @@ export interface SeniorHistoryEntry {
     by: string;
     reason: string;
 }
+/** Explicit repair of a legacy lane whose company attribution was missing. */
+export interface CompanyHistoryEntry {
+    from: null;
+    to: LaneCompanyRef;
+    at: string;
+    by: string;
+    reason: "repair_company";
+}
 interface LaneStopHistoryEntry {
     at: string;
     reason: string;
@@ -509,6 +517,8 @@ export interface LaneRecord {
     owner_written_by_version?: string;
     /** `null` is a core/personal lane (spec §6.2 / §10). Not an empty slug. */
     company: LaneCompanyRef | null;
+    /** Bounded audit history of explicit company-attribution repairs. */
+    company_history?: CompanyHistoryEntry[];
     /** Explicit Work Mesh attribution for a personal lane; never inferred from cwd. */
     mesh_company?: LaneCompanyRef;
     project_id: string;

package/dist/lib/lanes/types.js

@@ -224,7 +224,7 @@ export const REQUIRED_LANE_RECORD_FIELDS = [
 export const LANE_WRITERS = ["creator", "command", "watcher", "reconcile", "spawn", "story-ledger"];
 /** Field ownership at the durable-record mutation boundary (spec §10.1). */
 export const LANE_FIELD_WRITERS = {
-    schema_version: ["creator"], lane_id: ["creator"], written_by_version: [], owner_written_by_version: [], company: ["creator"],
+    schema_version: ["creator"], lane_id: ["creator"], written_by_version: [], owner_written_by_version: [], company: ["creator", "command"], company_history: ["command"],
     project_id: ["command"], story_id: ["command"], no_story_reason: ["creator", "command"], ledger_sync_error: ["story-ledger"], pending_question_ids: ["story-ledger"], stories: ["creator", "command", "watcher", "reconcile", "spawn"], thread_id: ["creator", "command", "spawn"], mesh_company: ["creator", "command"],
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     hire_grant: ["creator", "command"],

package/dist/lib/search-index/background.js

@@ -3,6 +3,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { Sentry } from '../../sentry.js';
 import { reconcileCollections as defaultReconcileCollections, resolveQmdBin as defaultResolveQmdBin, runQmd as defaultRunQmd, } from './index.js';
+import { qmdCollectionPathRepairEnabled } from './collection-path-repair-flag.js';
 import { applyIndexSizeLimit as defaultApplyIndexSizeLimit } from './max-doc-bytes.js';
 import { acquireEmbedLock as acquireLock, installEmbedLockCleanup, lockPath, lockRoot, lockState, releaseEmbedLock as releaseLock, } from './embed-lock.js';
 import { LoadGateConfigurationError, checkEmbedLoad, defaultLoadGateDependencies, recordSuccessfulEmbed, } from './load-gate.js';
@@ -121,7 +122,7 @@ export function defaultBackgroundDependencies(hqRoot) {
         random: () => Math.random().toString(36).slice(2),
         isProcessAlive: alive,
         resolveQmdBin: defaultResolveQmdBin,
-        reconcileCollections: defaultReconcileCollections,
+        reconcileCollections: (root) => defaultReconcileCollections(root, { repairPathDrift: qmdCollectionPathRepairEnabled() }),
         applyIndexSizeLimit: defaultApplyIndexSizeLimit,
         runQmd: defaultRunQmd,
         spawnWorker: defaultSpawnWorker,

package/dist/lib/search-index/collection-path-repair-flag-constants.d.ts

@@ -0,0 +1,2 @@
+export declare const QMD_COLLECTION_PATH_REPAIR_FLAG = "qmd.collection-path-repair";
+//# sourceMappingURL=collection-path-repair-flag-constants.d.ts.map

package/dist/lib/search-index/collection-path-repair-flag-constants.js

@@ -0,0 +1,2 @@
+export const QMD_COLLECTION_PATH_REPAIR_FLAG = 'qmd.collection-path-repair';
+//# sourceMappingURL=collection-path-repair-flag-constants.js.map

package/dist/lib/search-index/collection-path-repair-flag.d.ts

@@ -1,4 +1,4 @@
-export declare const QMD_COLLECTION_PATH_REPAIR_FLAG = "qmd.collection-path-repair";
+export { QMD_COLLECTION_PATH_REPAIR_FLAG } from './collection-path-repair-flag-constants.js';
 /** Keep collection-path repair off unless the hq-flags registry enables a canary. */
 export declare function qmdCollectionPathRepairEnabled(): boolean;
 //# sourceMappingURL=collection-path-repair-flag.d.ts.map

package/dist/lib/search-index/collection-path-repair-flag.js

@@ -1,5 +1,6 @@
 import { resolveProcessFlagGate } from '../flag-registry.js';
-export const QMD_COLLECTION_PATH_REPAIR_FLAG = 'qmd.collection-path-repair';
+import { QMD_COLLECTION_PATH_REPAIR_FLAG } from './collection-path-repair-flag-constants.js';
+export { QMD_COLLECTION_PATH_REPAIR_FLAG } from './collection-path-repair-flag-constants.js';
 /** Keep collection-path repair off unless the hq-flags registry enables a canary. */
 export function qmdCollectionPathRepairEnabled() {
     return resolveProcessFlagGate(QMD_COLLECTION_PATH_REPAIR_FLAG, { fallback: false }, () => false);

package/dist/lib/search-index/index.js

@@ -14,7 +14,6 @@ import { markExpectedUserError } from '../../utils/expected-cli-error.js';
 import { redactErrorText } from '../../utils/redact-error-text.js';
 import { planCommandSpawn } from '../../utils/windows-spawn.js';
 import { resolveQmdConfigPath } from './max-doc-bytes.js';
-import { qmdCollectionPathRepairEnabled } from './collection-path-repair-flag.js';
 /** The `path` implementation for a (possibly injected) platform. */
 function pathFor(platform) {
     return platform === 'win32' ? path.win32 : path.posix;
@@ -1472,7 +1471,7 @@ export function reconcileCollections(hqRoot, options = {}) {
     const runOptions = { bin: options.bin, runner: options.runner, cwd: hqRoot };
     const registered = listRegisteredCollections(hqRoot, runOptions);
     const expected = deriveCollections(hqRoot);
-    const repairPathDrift = options.repairPathDrift ?? qmdCollectionPathRepairEnabled();
+    const repairPathDrift = options.repairPathDrift ?? false;
     const configured = repairPathDrift ? configuredCollections(hqRoot) : new Map();
     const stale = repairPathDrift
         ? expected.filter((collection) => {

package/dist/lib/search-index/reindex-single-flight-flag-constants.d.ts

@@ -0,0 +1,3 @@
+export declare const QMD_REINDEX_SINGLE_FLIGHT_FLAG = "qmd.reindex-single-flight";
+export declare const QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK = false;
+//# sourceMappingURL=reindex-single-flight-flag-constants.d.ts.map

package/dist/lib/search-index/reindex-single-flight-flag-constants.js

@@ -0,0 +1,3 @@
+export const QMD_REINDEX_SINGLE_FLIGHT_FLAG = "qmd.reindex-single-flight";
+export const QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK = false;
+//# sourceMappingURL=reindex-single-flight-flag-constants.js.map

package/dist/lib/search-index/reindex-single-flight-flag.d.ts

@@ -1,5 +1,4 @@
-export declare const QMD_REINDEX_SINGLE_FLIGHT_FLAG = "qmd.reindex-single-flight";
-export declare const QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK = false;
+export { QMD_REINDEX_SINGLE_FLIGHT_FLAG, QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK } from "./reindex-single-flight-flag-constants.js";
 /** Keep whole update-to-embed passes single-flight only for explicitly enabled canaries. */
 export declare function qmdReindexSingleFlightEnabled(): boolean;
 //# sourceMappingURL=reindex-single-flight-flag.d.ts.map

package/dist/lib/search-index/reindex-single-flight-flag.js

@@ -1,6 +1,6 @@
 import { resolveProcessFlagGate } from "../flag-registry.js";
-export const QMD_REINDEX_SINGLE_FLIGHT_FLAG = "qmd.reindex-single-flight";
-export const QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK = false;
+import { QMD_REINDEX_SINGLE_FLIGHT_FLAG, QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK } from "./reindex-single-flight-flag-constants.js";
+export { QMD_REINDEX_SINGLE_FLIGHT_FLAG, QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK } from "./reindex-single-flight-flag-constants.js";
 /** Keep whole update-to-embed passes single-flight only for explicitly enabled canaries. */
 export function qmdReindexSingleFlightEnabled() {
     return resolveProcessFlagGate(QMD_REINDEX_SINGLE_FLIGHT_FLAG, { fallback: QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK }, () => QMD_REINDEX_SINGLE_FLIGHT_FLAG_FALLBACK);

package/dist/main.js

@@ -392,9 +392,12 @@ function integrationsGatewayCaptureContext(err) {
         ? String(status)
         : status === undefined ? "unknown" : "other";
     const rpcCode = record.rpcCode;
+    const gatewayFailureCode = record.gatewayFailureCode;
     const codeTag = typeof rpcCode === "number" && Number.isInteger(rpcCode)
         ? GATEWAY_RPC_CODE_TAGS.get(rpcCode) ?? "other"
-        : rpcCode === undefined ? "missing" : "other";
+        : gatewayFailureCode === "invalid_envelope"
+            ? gatewayFailureCode
+            : rpcCode === undefined ? "missing" : "other";
     const errorShape = record.gatewayErrorShape;
     const errorShapeTag = typeof errorShape === "string" && GATEWAY_ERROR_SHAPES.has(errorShape)
         ? errorShape

package/dist/utils/install-tree-torn.d.ts

@@ -288,14 +288,14 @@ type VersionGatePhase = "preflight" | "lock_acquired" | "installer_running" | "v
  * app, the box's update timer, another `hq`) cannot make a legitimately-in-progress
  * reinstall look stale:
  *   - UNLOCKED time — wall time observed with no fresh foreign lock — is bounded
- *     by `deadlineMs`. If the target is still missing and the observable tree
+ *     by `deadlineMs`. If the target is still missing and a fully observed tree
  *     signature stays unchanged for `staleProbeMs`, the wait returns `staleTree`
- *     early. When only a named retired npm sibling's deep scan is incomplete,
- *     a stable partial signature ends the wait early as `retiredSiblingUnverified`
- *     instead. That outcome preserves uncertainty and tells the user to wait for
- *     any installer before attempting a repair. Any observed signature change
- *     keeps the ordinary settle deadline in force. `deadlineMs === 0` evaluates
- *     readiness once.
+ *     early. When a named retired npm sibling's deep scan is incomplete, a stable
+ *     partial signature is not enough to call the tree abandoned: the wait keeps
+ *     polling until the bounded deadline, where it returns
+ *     `retiredSiblingUnverified`. Any observed signature change also keeps the
+ *     ordinary settle deadline in force. `deadlineMs === 0` evaluates readiness
+ *     once.
  *   - WRITER time — wall time observed under a fresh foreign lock, or while a
  *     recorded foreign updater pid is alive and the tree has an in-flight signal
  *     — is bounded SEPARATELY by `lockWaitMs` (default the lock contract's own

package/dist/utils/install-tree-torn.js

@@ -949,14 +949,14 @@ const DEFAULT_INSTALL_TREE_STALE_PROBE_MS = 1_500;
  * app, the box's update timer, another `hq`) cannot make a legitimately-in-progress
  * reinstall look stale:
  *   - UNLOCKED time — wall time observed with no fresh foreign lock — is bounded
- *     by `deadlineMs`. If the target is still missing and the observable tree
+ *     by `deadlineMs`. If the target is still missing and a fully observed tree
  *     signature stays unchanged for `staleProbeMs`, the wait returns `staleTree`
- *     early. When only a named retired npm sibling's deep scan is incomplete,
- *     a stable partial signature ends the wait early as `retiredSiblingUnverified`
- *     instead. That outcome preserves uncertainty and tells the user to wait for
- *     any installer before attempting a repair. Any observed signature change
- *     keeps the ordinary settle deadline in force. `deadlineMs === 0` evaluates
- *     readiness once.
+ *     early. When a named retired npm sibling's deep scan is incomplete, a stable
+ *     partial signature is not enough to call the tree abandoned: the wait keeps
+ *     polling until the bounded deadline, where it returns
+ *     `retiredSiblingUnverified`. Any observed signature change also keeps the
+ *     ordinary settle deadline in force. `deadlineMs === 0` evaluates readiness
+ *     once.
  *   - WRITER time — wall time observed under a fresh foreign lock, or while a
  *     recorded foreign updater pid is alive and the tree has an in-flight signal
  *     — is bounded SEPARATELY by `lockWaitMs` (default the lock contract's own
@@ -1085,12 +1085,14 @@ export async function waitForInstallTreeSettled(args) {
                 updaterPidAlive: updaterPidAlive(args.lockPath, fs, isPidAlive),
             };
         }
+        const retiredSiblingUnverified = !lastActivitySnapshot.observed && lastActivitySnapshot.retiredSiblingPresent === true;
         if (!ready &&
             !foreignLockHeld &&
             !updaterPidHeld &&
             !retiredCheckFailed &&
             !sawLock &&
             !sawTreeChange &&
+            !retiredSiblingUnverified &&
             staleObservationStartedAt !== null &&
             t - staleObservationStartedAt >= staleProbeMs) {
             return {
@@ -1129,6 +1131,7 @@ export async function waitForInstallTreeSettled(args) {
                 sawTreeChange,
                 staleTree: false,
                 retiredSiblingPresent: retiredPresent,
+                retiredSiblingUnverified: !lastActivitySnapshot.observed && lastActivitySnapshot.retiredSiblingPresent === true,
                 retiredSiblingKind: retiredSiblingKind(args.packageRoot, fs),
                 installTargetState: installTargetState(args.target, args.packageRoot, fs),
                 updaterPidAlive: updaterPidAlive(args.lockPath, fs, isPidAlive),

package/package.json

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