@indigoai-us/hq-cli 5.345.25 → 5.345.27

package/dist/lib/agent-kit/run/heartbeat.js

@@ -50,25 +50,60 @@ export function readLastHeartbeat(paths) {
         return null;
     }
 }
-export function defaultHeartbeatPost(agentUid, apiBaseUrl) {
-    return async (token, body) => {
+export function defaultHeartbeatPost(identity) {
+    return async (token, body, requestIdentity = identity) => {
         const res = await vaultApiFetch({
             token,
-            baseUrl: apiBaseUrl,
-            path: `/v1/agents/${encodeURIComponent(agentUid)}/heartbeat`,
+            baseUrl: requestIdentity.apiBaseUrl,
+            path: `/v1/agents/${encodeURIComponent(requestIdentity.agentUid)}/heartbeat`,
             method: "POST",
             body: body,
         });
         return { status: res.status, bodyText: await res.text().catch(() => "") };
     };
 }
+function stopForIdentityMismatch(deps, body, now, status, configuredAgentUid, tokenUid) {
+    writeLastHeartbeat(deps.paths, {
+        at: now().toISOString(),
+        components: body.components,
+        status,
+        reason: "identity_mismatch",
+        configuredAgentUid,
+        ...(tokenUid ? { tokenAgentUid: tokenUid } : {}),
+    });
+    deps.log("warn", identityMismatchMessage("heartbeat", configuredAgentUid, tokenUid));
+    (deps.reportIdentityMismatch ?? captureHeartbeatIdentityMismatch)({
+        runner: "agent-kit",
+        configuredAgentUid,
+        ...(tokenUid ? { tokenAgentUid: tokenUid } : {}),
+        agentUidSource: deps.agentUidSource ?? "config_file",
+        credsSource: deps.credsSource ?? "default",
+    });
+    return { ok: false, stop: true };
+}
 async function beatOnceResult(deps) {
     const now = deps.now ?? (() => new Date());
-    const post = deps.post ?? defaultHeartbeatPost(deps.agentUid, deps.apiBaseUrl);
     const body = buildHeartbeatBody(deps.paths, now, undefined, deps.components ?? KIT_COMPONENTS);
     try {
         const token = await deps.getToken();
-        const response = await post(token, body);
+        const tokenUid = tokenAgentUid(token);
+        let identity = { agentUid: deps.agentUid, apiBaseUrl: deps.apiBaseUrl };
+        if (tokenUid !== undefined && tokenUid !== identity.agentUid) {
+            if (deps.getConfiguredAgentIdentity) {
+                try {
+                    identity = deps.getConfiguredAgentIdentity();
+                }
+                catch (err) {
+                    deps.log("error", `heartbeat identity refresh failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            if (tokenUid !== identity.agentUid) {
+                // Status 0 means the client stopped before receiving an HTTP response.
+                return stopForIdentityMismatch(deps, body, now, 0, identity.agentUid, tokenUid);
+            }
+        }
+        const post = deps.post ?? defaultHeartbeatPost(identity);
+        const response = await post(token, body, identity);
         const result = typeof response === "number" ? { status: response } : response;
         const status = result.status;
         const ok = status >= 200 && status < 300;
@@ -78,25 +113,7 @@ async function beatOnceResult(deps) {
         else {
             const failure = parseHeartbeatFailureBody(result.bodyText);
             if (isHeartbeatIdentityMismatch({ status, code: failure.code, message: failure.message })) {
-                const tokenUid = tokenAgentUid(token);
-                writeLastHeartbeat(deps.paths, {
-                    at: now().toISOString(),
-                    components: body.components,
-                    status,
-                    reason: "identity_mismatch",
-                    configuredAgentUid: deps.agentUid,
-                    ...(tokenUid ? { tokenAgentUid: tokenUid } : {}),
-                });
-                const tokenLabel = tokenUid ?? "unknown";
-                deps.log("warn", identityMismatchMessage("heartbeat", deps.agentUid, tokenLabel));
-                (deps.reportIdentityMismatch ?? captureHeartbeatIdentityMismatch)({
-                    runner: "agent-kit",
-                    configuredAgentUid: deps.agentUid,
-                    ...(tokenUid ? { tokenAgentUid: tokenUid } : {}),
-                    agentUidSource: deps.agentUidSource ?? "config_file",
-                    credsSource: deps.credsSource ?? "default",
-                });
-                return { ok: false, stop: true };
+                return stopForIdentityMismatch(deps, body, now, status, identity.agentUid, tokenUid);
             }
         }
         deps.log(ok ? "info" : "warn", `heartbeat ${status} ${Object.entries(body.components)

package/dist/lib/heartbeat-identity.d.ts

@@ -24,7 +24,7 @@ export declare function parseHeartbeatFailureBody(bodyText: string | undefined):
 };
 /** Match the server's registered code/name, never an arbitrary 403. */
 export declare function isHeartbeatIdentityMismatch(failure: HeartbeatFailure): boolean;
-/** Read the agent uid claim for diagnostics only; this never authorizes a call. */
+/** Read the agent uid claim for diagnostics and a fail-closed path consistency check; it never authorizes a call. */
 export declare function tokenAgentUid(token: string): string | undefined;
 export declare function captureHeartbeatIdentityMismatch(context: HeartbeatIdentityMismatchContext, captureMessage?: (message: string, context: CaptureContext) => string): void;
 //# sourceMappingURL=heartbeat-identity.d.ts.map

package/dist/lib/heartbeat-identity.js

@@ -43,7 +43,7 @@ export function isHeartbeatIdentityMismatch(failure) {
     return (message.includes("heartbeatmustbereportedbytheagentsownmachineidentity") ||
         message.includes("agentidentitymismatcherror"));
 }
-/** Read the agent uid claim for diagnostics only; this never authorizes a call. */
+/** Read the agent uid claim for diagnostics and a fail-closed path consistency check; it never authorizes a call. */
 export function tokenAgentUid(token) {
     const claims = peekIdToken(token);
     return (safeAgentUid(claims["custom:entityUid"]) ??

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

@@ -3,7 +3,6 @@ import { LanesError } from "./errors.js";
 export type LaneHireGrantRow = Pick<LaneRecord, "lane_id" | "state" | "senior" | "hire_grant">;
 export declare function isFinishedResumableHireChild(state: LaneRecord["state"]): boolean;
 export declare function laneHoldsHireGrantCarve(lane: Pick<LaneHireGrantRow, "state">, finishedChildrenDoNotCount?: boolean): boolean;
-export declare function aliveDirectChildren<T extends LaneHireGrantRow>(lanes: readonly T[], parentLaneId: string, finishedChildrenDoNotCount?: boolean): T[];
 /** Children whose existing hire grants occupy their senior's carve. */
 export declare function childrenHoldingHireGrantCarve<T extends LaneHireGrantRow>(lanes: readonly T[], parentLaneId: string, finishedChildrenDoNotCount?: boolean): T[];
 export declare function assignedChildHireGrants(children: readonly LaneHireGrantRow[], exceptLaneId?: string): number;

package/dist/lib/lanes/grants.js

@@ -8,9 +8,6 @@ export function laneHoldsHireGrantCarve(lane, finishedChildrenDoNotCount = false
     return !isTerminalLaneState(lane.state) &&
         !(finishedChildrenDoNotCount && isFinishedResumableHireChild(lane.state));
 }
-export function aliveDirectChildren(lanes, parentLaneId, finishedChildrenDoNotCount = false) {
-    return childrenHoldingHireGrantCarve(lanes, parentLaneId, finishedChildrenDoNotCount);
-}
 /** Children whose existing hire grants occupy their senior's carve. */
 export function childrenHoldingHireGrantCarve(lanes, parentLaneId, finishedChildrenDoNotCount = false) {
     return lanes.filter((lane) => lane.senior.kind === "lane" &&
@@ -119,7 +116,7 @@ export function planHireGrantBackfill(lanes, profileMaxConcurrent) {
     const candidates = lanes.filter((lane) => {
         if (isTerminalLaneState(lane.state))
             return false;
-        return aliveDirectChildren(lanes, lane.lane_id).length > 0 ||
+        return childrenHoldingHireGrantCarve(lanes, lane.lane_id).length > 0 ||
             lane.worker_profile === "hq-lanes-manager";
     });
     const candidateIds = new Set(candidates.map((lane) => lane.lane_id));
@@ -133,7 +130,7 @@ export function planHireGrantBackfill(lanes, profileMaxConcurrent) {
             throw new LanesError("hire_grant_backfill_cycle", `Cannot plan hire grants for cyclic lane hierarchy at ${lane.lane_id}`, { lane_id: lane.lane_id });
         }
         active.add(lane.lane_id);
-        const children = aliveDirectChildren(lanes, lane.lane_id);
+        const children = childrenHoldingHireGrantCarve(lanes, lane.lane_id);
         const allocated = children.reduce((sum, child) => {
             if (child.hire_grant !== undefined)
                 return sum + child.hire_grant;
@@ -151,7 +148,7 @@ export function planHireGrantBackfill(lanes, profileMaxConcurrent) {
         proposalFor(lane);
     return candidates
         .map((lane) => {
-        const children = aliveDirectChildren(lanes, lane.lane_id);
+        const children = childrenHoldingHireGrantCarve(lanes, lane.lane_id);
         const profileMax = lane.worker_profile
             ? profileMaxConcurrent.get(lane.worker_profile) ?? null
             : null;

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

@@ -3,7 +3,7 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, childrenHoldingHireGrantCarve, isFinishedResumableHireChild, laneHoldsHireGrantCarve, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
+export { assignedChildHireGrants, childrenHoldingHireGrantCarve, isFinishedResumableHireChild, laneHoldsHireGrantCarve, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
 export type { HireGrantBackfillRow } from "./grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export type { AdmissionCapReason, AdmissionHost } from "./admission.js";
@@ -16,7 +16,7 @@ export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFT
 export type { ConfigLoadDeps, ConfigWriteDeps } from "./config.js";
 export { resolveLanesHqRoot } from "./hq-root.js";
 export type { LanesHqRootOpts } from "./hq-root.js";
-export { LANE_STORY_LEDGER_FLAG, buildLaneStatusSnapshot, formatLaneStatusHuman, laneStoryLedgerEnabled, resolveProjectStoryLedger, syncLaneToProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
+export { LANE_STORY_LEDGER_FLAG, buildLaneStatusSnapshot, formatLaneStatusHuman, laneStoryLedgerEnabled, resolveProjectStoryLedger, syncLaneToProjectStoryLedger, removeLaneFromProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
 export type { LaneStatusSnapshot, ProjectStoryLedger, StoryLedgerWriteDeps } from "./story-ledger.js";
 export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
 export type { OutpostDispatchResult, OutpostPickupPayload, } from "./outpost-dispatch.js";

package/dist/lib/lanes/index.js

@@ -3,14 +3,14 @@
  */
 export { AccountResolutionError, LaneNotFoundError, LaneSchemaError, LaneVersionConflict, LanesConfigError, LanesError, WorkerResolutionError, isLaneVersionConflict, isLanesError, } from "./errors.js";
 export { MAX_LANE_DEPTH } from "./constants.js";
-export { assignedChildHireGrants, aliveDirectChildren, childrenHoldingHireGrantCarve, isFinishedResumableHireChild, laneHoldsHireGrantCarve, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
+export { assignedChildHireGrants, childrenHoldingHireGrantCarve, isFinishedResumableHireChild, laneHoldsHireGrantCarve, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./grants.js";
 export { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, hasEarlierEligibleQueuedLane, laneOccupiesRunningSlot, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, withLaneAdmissionLock, } from "./admission.js";
 export { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "./host-capacity.js";
 export { CONFIG_SCHEMA_VERSION, ENVELOPE_DECISIONS, ENVELOPE_SCHEMA_VERSION, HISTORY_CAP, HOST_KINDS, LANE_PROVIDERS, LANE_SCHEMA_VERSION, LANE_STORY_STATUSES, LANE_STATES, LIVENESS_STATES, QUESTION_BODY_STORES, QUESTION_SCHEMA_VERSION, QUESTION_STATUSES, QUEUED_REASONS, RAISED_VIA, ROUTING_REASONS, SENIOR_KINDS, STORY_STATUSES, TERMINAL_LANE_STATES, isEnvelopeDecision, isHostKind, isLaneProvider, isLaneState, isLivenessState, isQuestionStatus, isSeniorKind, isTerminalLaneState, parseLaneEnvelope, parseLaneProvider, parseLaneState, parseLivenessState, parseMajorSchema, parseQuestionStatus, parseSeniorKind, } from "./types.js";
 export { ACTIVE_LANE_STORY_STATUSES, activeLaneStories, laneStories, laneStory, storyKey, storyStatusForEnvelope, storyWarning, withCurrentStory, withLaneStories, } from "./stories.js";
 export { DEFAULT_ACCOUNT_HOMES, DEFAULT_AUTO_COMPACT_TOKENS, DEFAULT_COMPACT_AFTER_MS, DEFAULT_CPU_BUSY_PAUSE, DEFAULT_CPU_BUSY_RESUME, DEFAULT_LIVE_WITHIN_MS, DEFAULT_LIVENESS_WINDOWS, DEFAULT_MAX_QUEUED, DEFAULT_MIN_AVAILABLE_MEM_MB, DEFAULT_PROVIDER_MAX_RUNNING, DEFAULT_SILENT_LOST_MS, DEFAULT_TURN_START_LOST_MS, LANES_CONFIG_REL, accountMaxRunning, canonicalizeHome, documentedDefaultConfig, expandHome, lanesConfigPath, loadLanesConfig, parseLanesConfig, providerCompactAfterMs, providerAutoCompactTokens, providerQuotaDefaultHoldMs, DEFAULT_QUOTA_HOLD_MS, writeLanesConfig, } from "./config.js";
 export { resolveLanesHqRoot } from "./hq-root.js";
-export { LANE_STORY_LEDGER_FLAG, buildLaneStatusSnapshot, formatLaneStatusHuman, laneStoryLedgerEnabled, resolveProjectStoryLedger, syncLaneToProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
+export { LANE_STORY_LEDGER_FLAG, buildLaneStatusSnapshot, formatLaneStatusHuman, laneStoryLedgerEnabled, resolveProjectStoryLedger, syncLaneToProjectStoryLedger, removeLaneFromProjectStoryLedger, validateProjectStories, } from "./story-ledger.js";
 export { buildOutpostPickupCommand, parseOutpostPickupPayload, } from "./outpost-dispatch.js";
 export { LANES_STORE_REL, LANE_RECORDS_DIR, PENDING_INDEX_DIR, QUESTION_RECORDS_DIR, appendCappedHistory, appendLaneAttribution, appendLaneSeniorHistory, appendQuestionRouting, createLane, createQuestion, isConflictSidecarName, laneRecordPath, lanesStoreRoot, listLaneIds, listQuestionIds, mergeLaneRecords, mergeQuestionRecords, mintLaneId, mintQuestionId, parseLaneRecord, parseQuestionRecord, pendingMarkerPath, questionRecordPath, readAllLanes, readLane, readQuestion, resolveStoreHqRoot, sanitizeHostComponent, tryReadLane, tryReadQuestion, retryUpdateLane, retryUpdateQuestion, syncLaneRecordFromOwner, updateLane, updateQuestion, withLaneHireLocks, } from "./store.js";
 export { DEFAULT_LANE_WATCH_INTERVAL_MS, MAX_LANE_WATCH_INTERVAL_MS, MAX_WATCHED_LANES, MAX_WATCH_OUTPUT_LINES, runLaneWatch, } from "./watch.js";

package/dist/lib/lanes/keep-alive-audit.d.ts

@@ -37,6 +37,11 @@ interface KeepAliveAuditError {
 export interface KeepAliveAuditResult {
     ok: true;
     since: string;
+    companyless_lead_lanes: Array<{
+        lane: string;
+        project: string;
+        reason: "has_juniors" | "can_hire_juniors";
+    }>;
     rows: KeepAliveAuditRow[];
     errors: KeepAliveAuditError[];
     summary: KeepAliveAuditSummary;

package/dist/lib/lanes/keep-alive-audit.js

@@ -478,7 +478,19 @@ export function buildKeepAliveAudit(input) {
     if (sinceMs === undefined || !Number.isFinite(sinceMs)) {
         throw new LanesError("invalid_since", "--since must be a valid ISO date-time", { since: input.since });
     }
-    const lanes = readAllLanes(input.hqRoot).filter((lane) => (input.laneId === undefined || lane.lane_id === input.laneId) &&
+    const allLanes = readAllLanes(input.hqRoot);
+    const companylessLeadLanes = allLanes
+        .filter((lane) => lane.company === null && (input.laneId === undefined || lane.lane_id === input.laneId))
+        .map((lane) => {
+        const hasJuniors = allLanes.some((candidate) => candidate.senior.kind === "lane" && candidate.senior.id === lane.lane_id);
+        const canHireJuniors = (lane.hire_grant ?? 0) > 0;
+        if (!hasJuniors && !canHireJuniors)
+            return null;
+        return { lane: lane.lane_id, project: lane.project_id, reason: hasJuniors ? "has_juniors" : "can_hire_juniors" };
+    })
+        .filter((entry) => entry !== null)
+        .sort((a, b) => a.lane.localeCompare(b.lane));
+    const lanes = allLanes.filter((lane) => (input.laneId === undefined || lane.lane_id === input.laneId) &&
         typeof lane.hire_grant === "number" && Number.isFinite(lane.hire_grant) && lane.hire_grant > 0);
     const rows = [];
     const errors = [];
@@ -544,6 +556,7 @@ export function buildKeepAliveAudit(input) {
     return {
         ok: true,
         since: iso(sinceMs),
+        companyless_lead_lanes: companylessLeadLanes,
         rows,
         summary: {
             by_verdict: byVerdict,
@@ -581,6 +594,7 @@ export function formatKeepAliveAuditText(result) {
         `Since ${result.since}; ${counts}`,
         `not_restarted=${result.summary.not_restarted}, late_restarts_after_window=${result.summary.late_restarts_after_window}, late_over_10m=${result.summary.late_over_10m}, early_wake_by_others=${result.summary.early_wake_by_others}, self_wake=${result.summary.self_wake}`,
         `Stopped and not restarted on their own: ${result.summary.stopped_and_not_restarted_on_their_own}`,
+        ...result.companyless_lead_lanes.map((lane) => `Company-less lead ${lane.lane} (${lane.project}): ${lane.reason}; repair with hq lanes repair-company ${lane.lane} --company <slug>`),
         ...result.errors.map((error) => `Error ${error.lane} (${error.error}) at ${error.path}: ${error.message}`),
     ].join("\n");
 }

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -27,7 +27,7 @@ export interface OutpostDispatchResult {
     stderr: string;
 }
 export interface OutpostLaneCommand {
-    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target";
+    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target" | "repair-company-target";
     laneId: string;
     hqBinary?: string;
     text?: string;
@@ -46,6 +46,7 @@ export interface OutpostLaneCommand {
     approvalContext?: string;
     senior?: string;
     reason?: string;
+    company?: string;
     compact?: boolean;
     tail?: string;
     json?: boolean;

package/dist/lib/lanes/outpost-dispatch.js

@@ -210,6 +210,7 @@ export function buildOutpostLaneCommand(input) {
         ["--failed-resume-context", input.failedResumeContext],
         ["--senior", input.senior],
         ["--reason", input.reason],
+        ["--company", input.company],
     ]) {
         if (value !== undefined)
             args.push(flag, value);

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/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.25",
+  "version": "5.345.27",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {