@indigoai-us/hq-cli 5.345.25 → 5.345.26

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [5.345.26] — 2026-10-06
+- Give users recovery guidance for malformed HTTP 200 integration gateway errors while keeping the gateway defect reportable.
+- Fix Claude plugin setup on CLI versions that reject `--json` for marketplace add and remove. Failed Claude plugin commands show a bounded stderr excerpt with quoted and unquoted credential fields redacted.
+- Add `hq lanes repair-company` for legacy lanes with missing company attribution, report company-less lead lanes in `hq lanes keep-alive-audit`, and inherit company attribution from company-bound seniors when creating child lanes.
+- Resolve resume hire-carve policy from the senior record and remove the misleading alive-child helper alias.
+- Keep install-tree recovery waiting through the bounded settle deadline when a retired npm sibling cannot be fully inspected.
+
 ## [5.345.25] — 2026-10-06
 - Route qmd post-sync indexing and ontology README drift through isolated fast handlers; cover all rebuild-index targets in fast-route parity and benchmarks.
 

package/dist/command-catalog.generated.d.ts

@@ -11395,6 +11395,31 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly hidden: false;
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "repair-company-target";
+        readonly description: "";
+        readonly aliases: readonly [];
+        readonly hidden: true;
+        readonly helpOption: true;
+        readonly helpCommand: false;
+        readonly usage: "[options] <lane-id>";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "lane-id";
+            readonly required: true;
+            readonly variadic: false;
+            readonly description: "Lane id";
+        }];
+        readonly options: readonly [{
+            readonly flags: "--company <slug>";
+            readonly description: "Company slug to assign";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+            readonly hidden: false;
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "grant-target";
         readonly description: "";
@@ -12328,6 +12353,31 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly hidden: false;
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "repair-company";
+        readonly description: "Set missing company attribution on a legacy lane";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: true;
+        readonly helpCommand: false;
+        readonly usage: "[options] <lane-id>";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "lane-id";
+            readonly required: true;
+            readonly variadic: false;
+            readonly description: "Lane id";
+        }];
+        readonly options: readonly [{
+            readonly flags: "--company <slug>";
+            readonly description: "Company slug to assign";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+            readonly hidden: false;
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "logs";
         readonly description: "Print a lane's local logs";

package/dist/command-catalog.generated.js

@@ -13843,6 +13843,37 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "repair-company-target",
+                "description": "",
+                "aliases": [],
+                "hidden": true,
+                "helpOption": true,
+                "helpCommand": false,
+                "usage": "[options] <lane-id>",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "lane-id",
+                        "required": true,
+                        "variadic": false,
+                        "description": "Lane id"
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--company <slug>",
+                        "description": "Company slug to assign",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)",
+                        "hidden": false
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "grant-target",
                 "description": "",
@@ -14991,6 +15022,37 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "repair-company",
+                "description": "Set missing company attribution on a legacy lane",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": true,
+                "helpCommand": false,
+                "usage": "[options] <lane-id>",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "lane-id",
+                        "required": true,
+                        "variadic": false,
+                        "description": "Lane id"
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--company <slug>",
+                        "description": "Company slug to assign",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)",
+                        "hidden": false
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "logs",
                 "description": "Print a lane's local logs",

package/dist/commands/install-global.js

@@ -76,8 +76,23 @@ function runClaudeCli(args, home, env) {
     const childEnv = { ...process.env, ...env, HOME: home, CLAUDE_CONFIG_DIR: path.join(home, '.claude') };
     const result = spawnSync('claude', ['plugin', ...args], { encoding: 'utf8', env: childEnv, timeout: 120_000, windowsHide: true });
     if (result.error || result.status !== 0) {
+        if (result.error?.code === 'ENOENT') {
+            throw Object.assign(new Error('Claude Code plugin command failed because the Claude Code CLI was not found. Ensure the Claude Code CLI is installed and try again.'), { expected: true });
+        }
+        const stderr = typeof result.stderr === 'string' ? result.stderr : '';
+        let excerpt = stderr.replace(/\s+/g, ' ').trim();
+        excerpt = excerpt
+            .replace(/\bBearer\s+\S+/gi, 'Bearer [redacted]')
+            .replace(/(?:"((?:(?:access|refresh|id)[_-]?)?token|secret|password|authorization|api[_-]?key)"|'((?:(?:access|refresh|id)[_-]?)?token|secret|password|authorization|api[_-]?key)'|\b((?:(?:access|refresh|id)[_-]?)?token|secret|password|authorization|api[_-]?key)\b)\s*[:=]\s*(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,}\]]+)/gi, (_match, doubleQuotedKey, singleQuotedKey, unquotedKey) => `${doubleQuotedKey ?? singleQuotedKey ?? unquotedKey}=[redacted]`)
+            .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, '[redacted]')
+            .replace(/\b(?:gh[pousr]_|github_pat_|sk-|xox[baprs]-)[A-Za-z0-9_-]{16,}\b/g, '[redacted]');
+        for (const value of Object.values(childEnv).filter((value) => typeof value === 'string' && value.length >= 4).sort((a, b) => b.length - a.length)) {
+            excerpt = excerpt.split(value).join('[redacted]');
+        }
+        excerpt = excerpt.slice(0, 240);
         const cause = result.error?.message ?? `exit status ${String(result.status)}`;
-        throw Object.assign(new Error(`Claude Code plugin command failed (${cause}). Ensure the Claude Code CLI is installed and try again.`), { expected: true });
+        const detail = excerpt ? `; stderr: ${excerpt}` : '';
+        throw Object.assign(new Error(`Claude Code plugin command failed (${cause}${detail}).`), { expected: true });
     }
 }
 function removePluginSettings(doc, plugin, removePlugin, removeMarketplace, pluginSettingBefore) {
@@ -374,7 +389,7 @@ export function installGlobalClaude(opts) {
         try {
             if (marketplaceNeedsAdd) {
                 marketplaceMayNeedRollback = true;
-                runClaude(['marketplace', 'add', '--scope', 'user', '--json', pluginSource.sourceDir], home, env);
+                runClaude(['marketplace', 'add', '--scope', 'user', pluginSource.sourceDir], home, env);
             }
             if (pluginNeedsInstall)
                 runClaude(['install', '--scope', 'user', '--json', '-y', pluginSource.pluginId], home, env);
@@ -391,7 +406,7 @@ export function installGlobalClaude(opts) {
             }
             if (marketplaceMayNeedRollback) {
                 try {
-                    runClaude(['marketplace', 'remove', '--scope', 'user', '--json', pluginSource.marketplaceName], home, env);
+                    runClaude(['marketplace', 'remove', '--scope', 'user', pluginSource.marketplaceName], home, env);
                 }
                 catch (rollbackError) {
                     rollbackErrors.push(`marketplace removal: ${rollbackError.message}`);
@@ -574,7 +589,7 @@ export function uninstallGlobalClaude(opts = {}) {
         runClaude(['uninstall', '--scope', 'user', '--json', pluginSource.pluginId], home, env);
     }
     if (pluginSource && state?.plugin?.marketplaceAdded) {
-        runClaude(['marketplace', 'remove', '--scope', 'user', '--json', pluginSource.marketplaceName], home, env);
+        runClaude(['marketplace', 'remove', '--scope', 'user', pluginSource.marketplaceName], home, env);
     }
     unregisterClaudeServer({ name: HQ_MCP_SERVER_NAME, pack: HQ_ANYWHERE_PACK, env: { home } });
     if (fs.existsSync(t.settingsJson)) {

package/dist/commands/integrations-core.d.ts

@@ -113,6 +113,7 @@ interface GatewayMessage {
     error?: unknown;
 }
 export type GatewayErrorShape = "string_error" | "object_no_code" | "object_code" | "string_code" | "nested_code" | "empty" | "redacted_empty";
+export type GatewayFailureCode = "invalid_envelope";
 export declare class IntegrationsCliError extends Error {
     /**
      * True when the error is the caller's request/state/permission (a client 4xx
@@ -152,6 +153,8 @@ export declare class IntegrationsCliError extends Error {
     readonly gatewaySubcommand?: "tools_list" | "tools_call" | "other";
     /** Fixed vocabulary describing the shape of an upstream JSON-RPC error. */
     readonly gatewayErrorShape?: GatewayErrorShape;
+    /** Fixed classification for malformed gateway envelopes. */
+    readonly gatewayFailureCode?: GatewayFailureCode;
     /**
      * HQ's own OAuth callback URL, carried on the errors that say a provider
      * refused to register HQ automatically. The provider must register the exact
@@ -168,6 +171,7 @@ export declare class IntegrationsCliError extends Error {
         rpcCode?: number;
         gatewaySubcommand?: "tools_list" | "tools_call" | "other";
         gatewayErrorShape?: GatewayErrorShape;
+        gatewayFailureCode?: GatewayFailureCode;
         redirectUri?: string;
     });
 }

package/dist/commands/integrations-core.js

@@ -59,6 +59,8 @@ export class IntegrationsCliError extends Error {
     gatewaySubcommand;
     /** Fixed vocabulary describing the shape of an upstream JSON-RPC error. */
     gatewayErrorShape;
+    /** Fixed classification for malformed gateway envelopes. */
+    gatewayFailureCode;
     /**
      * HQ's own OAuth callback URL, carried on the errors that say a provider
      * refused to register HQ automatically. The provider must register the exact
@@ -83,6 +85,8 @@ export class IntegrationsCliError extends Error {
             this.gatewaySubcommand = opts.gatewaySubcommand;
         if (opts.gatewayErrorShape !== undefined)
             this.gatewayErrorShape = opts.gatewayErrorShape;
+        if (opts.gatewayFailureCode !== undefined)
+            this.gatewayFailureCode = opts.gatewayFailureCode;
         if (opts.redirectUri !== undefined) {
             Object.defineProperty(this, "redirectUri", {
                 value: opts.redirectUri,
@@ -523,6 +527,15 @@ export async function callGateway(token, params, idempotencyKey) {
     }
     if (terminalMessage?.error) {
         const gatewayError = gatewayErrorDetails(terminalMessage.error);
+        const invalidEnvelope = gatewayError.rpcCode === undefined && !gatewayError.message;
+        const gatewayFailureCode = invalidEnvelope
+            ? "invalid_envelope"
+            : undefined;
+        const userMessage = invalidEnvelope
+            ? "Integration gateway returned an invalid response. Try again. If it keeps happening, contact support."
+            : gatewayError.message ||
+                expectedGatewayErrorFallback(gatewayError.rpcCode) ||
+                "Integration gateway returned an error.";
         // The gateway's error text is minted UPSTREAM (hq-pro, the integration
         // factory, and beyond it the third-party provider), so it is untrusted:
         // scrub credentials and bound the length here, at the throw site, because
@@ -531,13 +544,12 @@ export async function callGateway(token, params, idempotencyKey) {
         // The chain is idempotent, so the unexpected path scrubbing again is a
         // no-op. This preserves PR #298's user-visible diagnostic; it only makes
         // it safe on the newly-expected path.
-        throw new IntegrationsCliError(gatewayError.message ||
-            expectedGatewayErrorFallback(gatewayError.rpcCode) ||
-            "Integration gateway returned an error.", {
+        throw new IntegrationsCliError(userMessage, {
             expected: isExpectedGatewayError(gatewayError.rpcCode),
             status: terminalStatus,
             gatewaySubcommand,
             gatewayErrorShape: gatewayError.shape,
+            ...(gatewayFailureCode ? { gatewayFailureCode } : {}),
             // Carry the protocol code to the capture site as a bounded grouping
             // discriminator (HQ-CLI collision, Sentry 7642756130). This does not
             // alter the `expected` decision above; it only labels the error.

package/dist/commands/lanes.js

@@ -62,19 +62,21 @@ import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, lan
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { listLaneReviews } from "../lib/lanes/reviews.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, isFinishedResumableHireChild, aliveDirectChildren, childrenHoldingHireGrantCarve, laneHoldsHireGrantCarve, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readAllLanes, readLane, sanitizeHostComponent, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, DEAD_HOST_MS, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, readWorkerRunResult, resumeCommandRefusal, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, isFinishedResumableHireChild, childrenHoldingHireGrantCarve, laneHoldsHireGrantCarve, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, syncLaneToProjectStoryLedger, removeLaneFromProjectStoryLedger, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readAllLanes, readLane, sanitizeHostComponent, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, DEAD_HOST_MS, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, readWorkerRunResult, resumeCommandRefusal, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
 import { laneStories, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { laneCompanyUidSource, resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveNextCheckAtMs, keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
+import { writeQuestionBody } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
 import { readLatestEnvelopeRecord } from "../lib/lanes/watcher.js";
 import { loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
+import { readCompaniesManifestMap } from "../lib/work-context/repo-remote.js";
 import { resolveManagerStatusTarget, } from "../lib/lanes/manager-status-gate.js";
 import { blockerFreshnessFingerprint, resolveBlockerFreshnessForLane, } from "../lib/lanes/blocker-freshness.js";
 import { resolveKrFreshnessForShow } from "../lib/lanes/kr-freshness.js";
@@ -496,7 +498,7 @@ function loadAllLanes(hqRoot) {
 function laneHireFields(lane, lanes, aliveChildrenByParent, finishedChildrenDoNotCount = false) {
     const aliveChildCount = aliveChildrenByParent
         ? aliveChildrenByParent.get(lane.lane_id) ?? 0
-        : aliveDirectChildren(lanes, lane.lane_id, finishedChildrenDoNotCount).length;
+        : childrenHoldingHireGrantCarve(lanes, lane.lane_id, finishedChildrenDoNotCount).length;
     const hireGrant = lane.hire_grant ?? 0;
     const hireSummary = `hire ${aliveChildCount}/${hireGrant}`;
     return {
@@ -1046,9 +1048,13 @@ async function withResumeHireAdmission(ctx, lane, fn, grantContext) {
         const seniorLaneId = lane.senior.kind === "lane" ? lane.senior.id : undefined;
         const resumeSenior = seniorLaneId
             ? grantContext?.hierarchy.find((entry) => entry.lane_id === seniorLaneId) ??
-                (listLaneIds(hqRoot).includes(seniorLaneId) ? readLane(hqRoot, seniorLaneId) : lane)
+                (listLaneIds(hqRoot).includes(seniorLaneId) ? readLane(hqRoot, seniorLaneId) : undefined)
             : lane;
-        finishedChildrenDoNotCount = await hireGrantFinishedChildrenDoNotCount(ctx, resumeSenior);
+        if (resumeSenior) {
+            finishedChildrenDoNotCount = await hireGrantFinishedChildrenDoNotCount(ctx, resumeSenior);
+        }
+        // A missing senior record keeps the live-only flag off, so finished
+        // children continue to count. Never borrow the child's company for this gate.
     }
     const shouldCheckGrant = isTerminalLaneState(lane.state) ||
         (finishedChildrenDoNotCount && isFinishedResumableHireChild(lane.state));
@@ -2134,6 +2140,16 @@ function companyBindingFromSessionMeta(meta) {
         return { binding: "none" };
     return { binding: "company", slug, uid };
 }
+function canonicalCompanySlugForUid(hqRoot, uid, senior) {
+    const companies = readCompaniesManifestMap(hqRoot);
+    const matches = companies
+        ? Object.entries(companies).filter(([, entry]) => entry?.cloud_uid === uid).map(([slug]) => slug)
+        : [];
+    if (matches.length !== 1) {
+        throw new LanesError("senior_company_unresolved", `Cannot resolve senior ${seniorKey(senior)} to one company slug from uid ${uid}`, { senior, company_uid: uid, matches });
+    }
+    return matches[0];
+}
 function serializeSeniorCompany(seniorCompany) {
     if (seniorCompany.binding === "unknown")
         return null;
@@ -3064,9 +3080,17 @@ async function runCreate(ctx, opts) {
     }
     const senior = opts.senior ? parseSeniorRef(opts.senior) : defaultSenior(ctx);
     assertSeniorExists(hqRoot, senior, ctx);
-    const company = companyFlag
+    let company = companyFlag
         ? await ctx.resolveCompany(companyFlag)
         : null;
+    const seniorCompany = companyOfSenior(hqRoot, senior, ctx);
+    if (company === null && seniorCompany.binding === "company") {
+        const seniorCompanyIdentifier = seniorCompany.slug ?? (seniorCompany.uid
+            ? canonicalCompanySlugForUid(hqRoot, seniorCompany.uid, senior)
+            : undefined);
+        if (seniorCompanyIdentifier)
+            company = await ctx.resolveCompany(seniorCompanyIdentifier);
+    }
     const callerAuthorization = requestedHireGrant !== undefined || ctx.env.HQ_LANE_ID?.trim()
         ? callerSeniorAuthorization(ctx, senior)
         : { authorized: true };
@@ -3122,7 +3146,6 @@ async function runCreate(ctx, opts) {
     if (requestedPlacement !== undefined || defaultPlacement !== undefined) {
         await assertPlacementEnabled(ctx, resolvePlacementCompany(), placementEnabled);
     }
-    const seniorCompany = companyOfSenior(hqRoot, senior, ctx);
     assertSameTenant(company, senior, seniorCompany);
     const createStoryWarnings = [];
     const knownAbsentStories = new Set();
@@ -4333,7 +4356,7 @@ function laneRunsHereForOperatorMutation(ctx, lane) {
 function assertLaneRunsHereForOperatorMutation(ctx, lane, action) {
     if (laneRunsHereForOperatorMutation(ctx, lane))
         return;
-    throw new LanesError("lane_remote", `Cannot ${action} lane ${lane.lane_id} from this host; its state is owned by ${lane.host.kind}:${lane.host.id}`, { lane_id: lane.lane_id, host: lane.host, action });
+    throw new LanesError("lane_remote", `Cannot ${action} lane ${lane.lane_id} from this host; its state is owned by ${lane.host.kind === "outpost" ? `Outpost ${lane.host.id}` : `host ${lane.host.id}`}. Run this command on the owning host.`, { lane_id: lane.lane_id, host: lane.host, action });
 }
 async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior = {}) {
     if (lane.host.kind !== "outpost") {
@@ -4399,9 +4422,11 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
                         ? "reparent-target"
                         : action === "approve"
                             ? "approve-target"
-                            : action,
+                            : action === "repair-company"
+                                ? "repair-company-target"
+                                : action,
                 laneId: lane.lane_id,
-                hqBinary: action === "grant" || action === "reparent"
+                hqBinary: action === "grant" || action === "reparent" || action === "repair-company"
                     ? outpostCliOverride(ctx, outpostId)
                     : undefined,
                 text: options.text,
@@ -4416,6 +4441,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
                 hire: options.hire,
                 senior: options.senior,
                 reason: options.reason,
+                company: options.company,
                 grantContext: contexts.grantContext,
                 profileRepinContext: contexts.profileRepinContext,
                 failedResumeContext: contexts.failedResumeContext,
@@ -4534,23 +4560,28 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
                 : action === "approve"
                     ? remote.checkpoint === options.checkpoint &&
                         remote.lane !== null && typeof remote.lane === "object" && !Array.isArray(remote.lane)
-                    : action === "reparent"
-                        ? remote.lane !== null && typeof remote.lane === "object" &&
-                            Array.isArray(remote.changed_descendant_ids)
-                        : (((remote.delivery_status === "worker_spawned" ||
-                            remote.delivery_status === "queued_on_target_account") &&
-                            remote.lane !== undefined) ||
-                            (remote.delivery_status === "queued_on_admission" &&
-                                remote.lane !== null &&
-                                typeof remote.lane === "object" &&
-                                !Array.isArray(remote.lane) &&
-                                remote.lane.state === "queued") ||
-                            (remote.delivery_status === "queued_for_reconcile" &&
-                                remote.lane !== null &&
-                                typeof remote.lane === "object" &&
-                                !Array.isArray(remote.lane) &&
-                                remote.lane.state === "queued" &&
-                                remote.lane.queued_reason !== "worker_profile_changed")));
+                    : action === "repair-company"
+                        ? remote.lane !== null && typeof remote.lane === "object" && !Array.isArray(remote.lane) &&
+                            remote.lane.company !== null &&
+                            remote.lane.company !== undefined &&
+                            remote.lane.company.slug === options.company
+                        : action === "reparent"
+                            ? remote.lane !== null && typeof remote.lane === "object" &&
+                                Array.isArray(remote.changed_descendant_ids)
+                            : (((remote.delivery_status === "worker_spawned" ||
+                                remote.delivery_status === "queued_on_target_account") &&
+                                remote.lane !== undefined) ||
+                                (remote.delivery_status === "queued_on_admission" &&
+                                    remote.lane !== null &&
+                                    typeof remote.lane === "object" &&
+                                    !Array.isArray(remote.lane) &&
+                                    remote.lane.state === "queued") ||
+                                (remote.delivery_status === "queued_for_reconcile" &&
+                                    remote.lane !== null &&
+                                    typeof remote.lane === "object" &&
+                                    !Array.isArray(remote.lane) &&
+                                    remote.lane.state === "queued" &&
+                                    remote.lane.queued_reason !== "worker_profile_changed")));
     if (!resultConfirmed) {
         throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} completed exec without a confirmed ${action} result for lane ${lane.lane_id}`, {
             lane_id: lane.lane_id,
@@ -4609,7 +4640,7 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
             printJson(response);
         return response;
     }
-    if (action === "approve" || action === "reparent" || action === "resume") {
+    if (action === "approve" || action === "reparent" || action === "resume" || action === "repair-company") {
         const ownerLane = dispatchedOwnerLane(ctx, lane.lane_id, outpostId, remote.lane, behavior);
         const descendants = [];
         if (action === "reparent") {
@@ -6198,7 +6229,7 @@ async function runBackfillGrants(ctx, opts) {
     const allLanes = loadAllLanes(hqRoot);
     const profileIds = new Set(allLanes
         .filter((lane) => !isTerminalLaneState(lane.state) &&
-        (aliveDirectChildren(allLanes, lane.lane_id).length > 0 ||
+        (childrenHoldingHireGrantCarve(allLanes, lane.lane_id).length > 0 ||
             lane.worker_profile === "hq-lanes-manager"))
         .map((lane) => lane.worker_profile)
         .filter((id) => Boolean(id)));
@@ -7121,6 +7152,10 @@ function runReparentLocked(ctx, laneId, opts, finishedChildrenDoNotCount = false
         throw new LanesError("lane_terminal", `Cannot re-parent a lane in terminal state ${lane.state}`, { lane_id: laneId, state: lane.state });
     }
     const seniorCompany = companyOfSenior(hqRoot, nextSenior, ctx);
+    if (lane.company === null && seniorCompany.binding === "company") {
+        const company = seniorCompany.slug ?? seniorCompany.uid ?? "<company>";
+        throw new LanesError("lane_company_missing", `Lane ${laneId} has no company attribution. Repair it with hq lanes repair-company ${laneId} --company ${company}, then retry reparent.`, { lane_id: laneId, senior: nextSenior, senior_company: serializeSeniorCompany(seniorCompany) });
+    }
     assertSameTenant(lane.company, nextSenior, seniorCompany, { lane_id: laneId });
     if (nextSenior.kind === "lane" && seniorKey(lane.senior) !== seniorKey(nextSenior)) {
         const parent = readLane(hqRoot, nextSenior.id);
@@ -7239,6 +7274,108 @@ function runReparentLocked(ctx, laneId, opts, finishedChildrenDoNotCount = false
             .map((descendant) => descendant.laneId),
     };
 }
+async function runRepairCompany(ctx, laneId, opts) {
+    const lane = readLane(ctx.hqRoot(), laneId);
+    if (lane.host.kind === "outpost" && !laneRunsHere(lane, reconcileHostFromCtx(ctx))) {
+        const companySlug = opts.company?.trim();
+        if (!companySlug)
+            throw new LanesError("missing_company", "--company is required", {});
+        const company = await ctx.resolveCompany(companySlug);
+        await dispatchOutpostLaneCommand(ctx, lane, "repair-company", { company: company.slug });
+        return;
+    }
+    await repairCompanyOnOwner(ctx, laneId, opts);
+}
+async function repairCompanyOnOwner(ctx, laneId, opts) {
+    const hqRoot = ctx.hqRoot();
+    const companySlug = opts.company?.trim();
+    if (!companySlug) {
+        throw new LanesError("missing_company", "--company is required", {});
+    }
+    const company = await ctx.resolveCompany(companySlug);
+    const initial = readLane(hqRoot, laneId);
+    assertLaneRunsHereForOperatorMutation(ctx, initial, "repair company for");
+    const initialSeniorCompany = companyOfSenior(hqRoot, initial.senior, ctx);
+    if (initialSeniorCompany.binding === "company" && !sameTenant(company, initial.senior, initialSeniorCompany)) {
+        throw new LanesError("lane_company_conflict", `Cannot repair lane ${laneId} to ${company.slug}: its senior belongs to a different company`, { lane_id: laneId, requested_company: company.slug, senior_company: serializeSeniorCompany(initialSeniorCompany) });
+    }
+    if (initial.mesh_company && !sameLaneCompany(initial.mesh_company, company)) {
+        throw new LanesError("lane_company_conflict", `Cannot repair lane ${laneId} to ${company.slug}: its mesh company is ${initial.mesh_company.slug}`, { lane_id: laneId, requested_company: company.slug, mesh_company: initial.mesh_company });
+    }
+    const pendingQuestionMigrations = loadAllQuestions(hqRoot)
+        .filter((entry) => entry.lane_id === laneId && entry.status === "pending")
+        .map((question) => {
+        if (question.company && !sameLaneCompany(question.company, company)) {
+            throw new LanesError("lane_company_conflict", `Cannot repair lane ${laneId}: pending question ${question.question_id} belongs to ${question.company.slug}`, { lane_id: laneId, question_id: question.question_id, question_company: question.company, requested_company: company.slug });
+        }
+        if (question.company && sameLaneCompany(question.company, company))
+            return null;
+        const oldBodyPath = questionBodyAbsPath(hqRoot, question);
+        const body = readQuestionBody(hqRoot, question);
+        if (!body) {
+            throw new LanesError("question_body_missing", `Cannot repair lane ${laneId}: pending question ${question.question_id} has no readable body`, { lane_id: laneId, question_id: question.question_id });
+        }
+        return { question, oldBodyPath, body };
+    })
+        .filter((entry) => entry !== null);
+    const at = ctx.now().toISOString();
+    casUpdateLane(hqRoot, laneId, (current) => {
+        assertLaneRunsHereForOperatorMutation(ctx, current, "repair company for");
+        const seniorCompany = companyOfSenior(hqRoot, current.senior, ctx);
+        if (seniorCompany.binding === "company" && !sameTenant(company, current.senior, seniorCompany)) {
+            throw new LanesError("lane_company_conflict", `Cannot repair lane ${laneId} to ${company.slug}: its senior belongs to a different company`, { lane_id: laneId, requested_company: company.slug, senior_company: serializeSeniorCompany(seniorCompany) });
+        }
+        if (current.mesh_company && !sameLaneCompany(current.mesh_company, company)) {
+            throw new LanesError("lane_company_conflict", `Cannot repair lane ${laneId} to ${company.slug}: its mesh company is ${current.mesh_company.slug}`, { lane_id: laneId, requested_company: company.slug, mesh_company: current.mesh_company });
+        }
+        if (current.company !== null) {
+            if (sameLaneCompany(current.company, company))
+                return current;
+            throw new LanesError("lane_company_already_set", `Lane ${laneId} already belongs to ${current.company.slug}; company repair only fills missing attribution`, { lane_id: laneId, company: current.company.slug, requested_company: company.slug });
+        }
+        return {
+            ...current,
+            company,
+            company_history: appendCappedHistory(current.company_history ?? [], {
+                from: null,
+                to: company,
+                at,
+                by: sessionIdFromEnv(ctx.env) ?? "user",
+                reason: "repair_company",
+            }),
+        };
+    });
+    const migratedQuestionRefs = [];
+    for (const { question, oldBodyPath, body } of pendingQuestionMigrations) {
+        const bodyRef = writeQuestionBody(hqRoot, {
+            ...question,
+            company,
+            body: { ...question.body, store: "company" },
+        }, body);
+        casUpdateQuestion(hqRoot, question.question_id, (current) => {
+            if (current.lane_id !== laneId || current.status !== "pending" || current.company !== null) {
+                throw new LanesError("question_changed_during_company_repair", `Pending question ${question.question_id} changed during company repair`, { lane_id: laneId, question_id: question.question_id });
+            }
+            return { ...current, company, body: bodyRef };
+        });
+        fs.rmSync(oldBodyPath, { force: true });
+        migratedQuestionRefs.push({ question_id: question.question_id, project_id: question.project_id, story_id: question.story_id });
+    }
+    const repairedLane = readLane(hqRoot, laneId);
+    syncLaneToProjectStoryLedger(hqRoot, repairedLane, migratedQuestionRefs);
+    removeLaneFromProjectStoryLedger(hqRoot, initial);
+    printJson({ ok: true, action: "repair-company", lane_id: laneId, lane: repairedLane, migrated_pending_questions: migratedQuestionRefs.length });
+}
+async function runRepairCompanyOwnerTarget(ctx, laneId, opts) {
+    if (!ctx.isSsmOwnerDispatch()) {
+        throw new LanesError("outpost_repair_company_dispatch_unauthorized", "The Outpost company-repair target is available only to an SSM Run Command dispatch", { lane_id: laneId });
+    }
+    const lane = readLane(ctx.hqRoot(), laneId);
+    if (lane.host.kind !== "outpost" || !laneIsHostedHere(ctx, lane)) {
+        throw new LanesError("lane_remote", `Outpost repair-company target cannot mutate lane ${laneId} on this host`, { lane_id: laneId, host: lane.host });
+    }
+    await repairCompanyOnOwner(ctx, laneId, opts);
+}
 const CANONICAL_LOG_STREAMS = [
     "watcher.err",
     "watcher.out",
@@ -8671,6 +8808,13 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, opts) => {
         await runReparentOwnerTarget(ctx, laneId, opts);
     }));
+    lanes
+        .command("repair-company-target", { hidden: true })
+        .argument("<lane-id>", "Lane id")
+        .requiredOption("--company <slug>", "Company slug to assign")
+        .action(wrap(async (laneId, opts) => {
+        await runRepairCompanyOwnerTarget(ctx, laneId, opts);
+    }));
     lanes
         .command("grant-target", { hidden: true })
         .argument("<lane-id>", "Lane id")
@@ -8976,6 +9120,14 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, opts) => {
         await runReparent(ctx, laneId, opts);
     }));
+    lanes
+        .command("repair-company")
+        .description("Set missing company attribution on a legacy lane")
+        .argument("<lane-id>", "Lane id")
+        .requiredOption("--company <slug>", "Company slug to assign")
+        .action(wrap(async (laneId, opts) => {
+        await runRepairCompany(ctx, laneId, opts);
+    }));
     lanes
         .command("logs")
         .description("Print a lane's local logs")

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