@indigoai-us/hq-cli 5.221.0 → 5.223.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [5.223.0] — 2026-09-26
+
+### Fixed
+
+- Manual resume and explicitly opted-in keep-alive reconcile can move a lane
+  off a disabled or logged-out Claude account on the same host, preserving the
+  provider session, provider, and model. `hq lanes watch` reports each
+  logged-in-to-logged-out transition once with the affected lane ids. The
+  watcher stops polling terminal keep-alive lanes when no resume can run and
+  shares one local account probe across matching lanes per poll. Quota and
+  model failures keep their existing account-selection path and reason.
+
+## [5.222.0] — 2026-09-26
+
+- Checkpoint ontology, behind `checkpoint.ontology.multi-writer` (off by
+  default): entity versions that sync set aside after losing a push race are
+  merged back at the start of each plan (aliases, back-references, the higher
+  `signal_count`, the later `last_updated`). Any other difference keeps both
+  and leaves the set-aside copy, and an entity deleted since is not
+  re-created. Every entity file the step writes is recorded in
+  `.hq/ontology-outbox/<company>.json`. The apply report counts duplicate
+  entity groups, and `hq core ontology duplicates --company <slug> [--json]`
+  lists them.
+
 ## [5.221.0] — 2026-09-26
 
 ### Added

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

@@ -5124,6 +5124,24 @@ export declare const COMMAND_CATALOG: readonly [{
                 readonly description: "HQ installation to operate on";
             }];
             readonly subcommands: readonly [];
+        }, {
+            readonly name: "duplicates";
+            readonly description: "List same-type entities whose names collide, with a proposed survivor (read-only)";
+            readonly aliases: readonly [];
+            readonly hidden: false;
+            readonly usage: "[options]";
+            readonly arguments: readonly [];
+            readonly options: readonly [{
+                readonly flags: "--company <slug>";
+                readonly description: "company to scan";
+            }, {
+                readonly flags: "--json";
+                readonly description: "print JSON";
+            }, {
+                readonly flags: "--hq-root <path>";
+                readonly description: "HQ installation to operate on";
+            }];
+            readonly subcommands: readonly [];
         }, {
             readonly name: "apply";
             readonly description: "Validate the run's entity candidates and write them to the payload company";

package/dist/command-catalog.generated.js

@@ -6626,6 +6626,29 @@ export const COMMAND_CATALOG = [
                         ],
                         "subcommands": []
                     },
+                    {
+                        "name": "duplicates",
+                        "description": "List same-type entities whose names collide, with a proposed survivor (read-only)",
+                        "aliases": [],
+                        "hidden": false,
+                        "usage": "[options]",
+                        "arguments": [],
+                        "options": [
+                            {
+                                "flags": "--company <slug>",
+                                "description": "company to scan"
+                            },
+                            {
+                                "flags": "--json",
+                                "description": "print JSON"
+                            },
+                            {
+                                "flags": "--hq-root <path>",
+                                "description": "HQ installation to operate on"
+                            }
+                        ],
+                        "subcommands": []
+                    },
                     {
                         "name": "apply",
                         "description": "Validate the run's entity candidates and write them to the payload company",

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

@@ -18,5 +18,11 @@ export interface OntologyCommandDeps {
 }
 export declare function runOntologyPlan(hqRoot: string, runDirOption: string | undefined, deps?: OntologyCommandDeps): Promise<string>;
 export declare function runOntologyApply(hqRoot: string, runDirOption: string | undefined, deps?: OntologyCommandDeps): string;
+/**
+ * `hq core ontology duplicates`: every group of same-type entities whose
+ * names collide, with a proposed survivor. Read-only; gated by
+ * `checkpoint.ontology.multi-writer`.
+ */
+export declare function runOntologyDuplicates(hqRoot: string, slug: string | undefined, json: boolean, deps?: OntologyCommandDeps): Promise<string>;
 export declare function registerCoreOntologyCommand(core: Command): void;
 //# sourceMappingURL=core-ontology.d.ts.map

package/dist/commands/core-ontology.js

@@ -11,9 +11,11 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
-import { planOntologyRun } from "../lib/checkpoint-ontology/plan.js";
+import { MULTI_WRITER_FLAG, planOntologyRun, } from "../lib/checkpoint-ontology/plan.js";
 import { applyOntologyRun, ApplyError } from "../lib/checkpoint-ontology/apply.js";
-import { WriteBoundsError } from "../lib/checkpoint-ontology/company.js";
+import { resolveOntologyCompany, WriteBoundsError } from "../lib/checkpoint-ontology/company.js";
+import { findDuplicateGroups, summarizeMergeBack, } from "../lib/checkpoint-ontology/multi-writer.js";
+import { buildEntityIndex } from "../lib/checkpoint-ontology/tree.js";
 export const ONTOLOGY_PAYLOAD_FILE = "payload.json";
 class OntologyUsageError extends Error {
 }
@@ -49,6 +51,16 @@ function companyBriefSuffix(brief) {
         return "";
     return `; company brief ${brief.status}${brief.reason ? ` (${brief.reason})` : ""}`;
 }
+function multiWriterSuffix(start) {
+    if (!start)
+        return "";
+    const parts = [];
+    if (start.merge_back.length > 0)
+        parts.push(`set-aside versions: ${summarizeMergeBack(start.merge_back)}`);
+    if (start.error)
+        parts.push(`multi-writer error ${start.error}`);
+    return parts.length > 0 ? `; ${parts.join("; ")}` : "";
+}
 export async function runOntologyPlan(hqRoot, runDirOption, deps = {}) {
     const runDir = requireRunDir(runDirOption);
     const outcome = await planOntologyRun({
@@ -59,12 +71,13 @@ export async function runOntologyPlan(hqRoot, runDirOption, deps = {}) {
         now: deps.now?.(),
     });
     if (outcome.status === "skipped") {
-        return `ontology: skipped (${outcome.reason})${companyBriefSuffix(outcome.companyBrief)}`;
+        return `ontology: skipped (${outcome.reason})${companyBriefSuffix(outcome.companyBrief)}${multiWriterSuffix(outcome.multiWriter)}`;
     }
     const { plan } = outcome;
     return (`ontology: planned ${plan.inputs.length} input(s), ~${plan.budget.planned_tokens} tokens, ` +
         `${plan.pending_after_run} left for later runs; plan at ${outcome.planPath}` +
-        companyBriefSuffix(outcome.companyBrief));
+        companyBriefSuffix(outcome.companyBrief) +
+        multiWriterSuffix(plan.multi_writer));
 }
 export function runOntologyApply(hqRoot, runDirOption, deps = {}) {
     const runDir = requireRunDir(runDirOption);
@@ -78,7 +91,36 @@ export function runOntologyApply(hqRoot, runDirOption, deps = {}) {
     return (`ontology: ${report.created.length} created, ${report.updated.length} updated, ` +
         `${report.matched} matched, ${report.rejected.length} rejected, ${report.deferred.length} deferred, ` +
         `${report.suspect_duplicates.length} suspect duplicate(s), ${report.write_errors.length} write error(s)` +
-        companyBriefSuffix(report.company_brief));
+        companyBriefSuffix(report.company_brief) +
+        (report.multi_writer?.duplicates ? `; ${report.multi_writer.duplicates.groups} duplicate group(s) in the company` : "") +
+        (report.multi_writer?.error ? `; multi-writer error ${report.multi_writer.error}` : ""));
+}
+/**
+ * `hq core ontology duplicates`: every group of same-type entities whose
+ * names collide, with a proposed survivor. Read-only; gated by
+ * `checkpoint.ontology.multi-writer`.
+ */
+export async function runOntologyDuplicates(hqRoot, slug, json, deps = {}) {
+    const resolution = resolveOntologyCompany(hqRoot, slug);
+    if (!resolution.ok)
+        throw new OntologyUsageError(`ontology: company rejected: ${resolution.reason}`);
+    const company = resolution.company;
+    if (!(await (deps.readFlag ?? registryFlagReader)(MULTI_WRITER_FLAG, company))) {
+        return json ? JSON.stringify({ company: company.slug, skipped: "flag off" }) : `ontology duplicates: skipped (${MULTI_WRITER_FLAG} is off)`;
+    }
+    const groups = findDuplicateGroups(buildEntityIndex(company.dir));
+    if (json)
+        return JSON.stringify({ company: company.slug, groups }, null, 2);
+    if (groups.length === 0)
+        return `ontology duplicates: none in ${company.slug}`;
+    const lines = [`ontology duplicates: ${groups.length} group(s) in ${company.slug}`];
+    for (const group of groups) {
+        lines.push(`${group.type} (${group.reason.replaceAll("_", " ")}), keep ${group.survivor}`);
+        for (const rel of group.paths)
+            if (rel !== group.survivor)
+                lines.push(`  ${rel}`);
+    }
+    return lines.join("\n");
 }
 function fail(error) {
     if (error instanceof OntologyUsageError || error instanceof ApplyError || error instanceof WriteBoundsError) {
@@ -105,6 +147,20 @@ export function registerCoreOntologyCommand(core) {
             fail(error);
         }
     });
+    ontology
+        .command("duplicates")
+        .description("List same-type entities whose names collide, with a proposed survivor (read-only)")
+        .requiredOption("--company <slug>", "company to scan")
+        .option("--json", "print JSON")
+        .option("--hq-root <path>", "HQ installation to operate on")
+        .action(async (options) => {
+        try {
+            process.stdout.write(`${await runOntologyDuplicates(rootFor(options), options.company, options.json === true)}\n`);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
     ontology
         .command("apply")
         .description("Validate the run's entity candidates and write them to the payload company")

package/dist/commands/lanes.js

@@ -42,7 +42,7 @@ import { effectiveAccountHome } from "../lib/lanes/account-home.js";
 import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
-import { keepAliveExclusion, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
+import { keepAliveExclusion, LEAD_LANE_KEEP_ALIVE_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 { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -1262,10 +1262,75 @@ function resolveMonitorEngine(requested, env) {
 }
 async function runWatch(ctx, laneIds, opts) {
     const rawInterval = opts.intervalMs === undefined ? undefined : Number(opts.intervalMs);
-    await runLaneWatch(ctx.hqRoot(), laneIds, {
+    const hqRoot = ctx.hqRoot();
+    await runLaneWatch(hqRoot, laneIds, {
         intervalMs: rawInterval,
         sleep: ctx.sleep,
+        keepAliveEnabled: (lane) => readLanesRegistryFlag(LEAD_LANE_KEEP_ALIVE_FLAG, {
+            company: lane.company,
+            env: ctx.env,
+        }),
+        readAccountStatuses: async (lanes) => {
+            if (lanes.length === 0)
+                return [];
+            const config = loadLanesConfig(hqRoot);
+            const currentHost = laneHostFromCtx(ctx);
+            const currentHostname = ctx.hostname().trim();
+            const isCurrentHost = (host) => (host.kind === currentHost.kind && host.id === currentHost.id) ||
+                (host.kind === "local" && host.id === currentHostname);
+            const remoteOutpostIds = [...new Set(lanes
+                    .filter((lane) => lane.host.kind === "outpost" && !isCurrentHost(lane.host))
+                    .map((lane) => lane.host.id))];
+            const remoteOutposts = await Promise.all(remoteOutpostIds.map(async (id) => [id, await readOutpostCapacity(ctx, id)]));
+            const outpostSnapshots = new Map(remoteOutposts);
+            const remoteLocalLanes = lanes.filter((lane) => lane.host.kind === "local" && !isCurrentHost(lane.host));
+            const remoteLocalHosts = remoteLocalLanes.length > 0
+                ? await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config)
+                : undefined;
+            const localStatusCache = new Map();
+            return lanes.map((lane) => {
+                if (config.providers[lane.provider].accounts[lane.account] === undefined) {
+                    throw new LanesError("watch_account_unconfigured", `Lane ${lane.lane_id} records unconfigured ${lane.provider} account ${lane.account}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
+                }
+                let loggedIn;
+                if (isCurrentHost(lane.host)) {
+                    const key = JSON.stringify([lane.provider, lane.account, currentHost.kind, currentHost.id]);
+                    if (!localStatusCache.has(key)) {
+                        localStatusCache.set(key, accountStatus(lane.provider, lane.account, config, {
+                            existsSync: ctx.existsSync,
+                            probe: ctx.probeProvider,
+                            env: ctx.env,
+                            hostname: currentHostname,
+                        }).logged_in);
+                    }
+                    loggedIn = localStatusCache.get(key);
+                }
+                else if (lane.host.kind === "outpost") {
+                    loggedIn = outpostSnapshots.get(lane.host.id)?.providers[lane.provider].accounts[lane.account]?.logged_in;
+                }
+                else {
+                    const snapshot = remoteLocalHosts?.snapshots.find((candidate) => candidate.capacity.host.kind === lane.host.kind &&
+                        candidate.capacity.host.id === lane.host.id);
+                    if (!snapshot) {
+                        const gap = remoteLocalHosts?.unavailableHosts.find((candidate) => candidate.host.kind === lane.host.kind && candidate.host.id === lane.host.id);
+                        throw new LanesError("watch_account_host_unavailable", `Cannot check ${lane.provider} account ${lane.account} on ${lane.host.kind}:${lane.host.id}${gap ? `: ${gap.reason}` : ""}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
+                    }
+                    loggedIn = snapshot.capacity.providers[lane.provider].accounts[lane.account]?.logged_in;
+                }
+                if (loggedIn === undefined) {
+                    throw new LanesError("watch_account_unconfigured", `Lane ${lane.lane_id} records unconfigured ${lane.provider} account ${lane.account} on ${lane.host.kind}:${lane.host.id}`, { lane_id: lane.lane_id, provider: lane.provider, account: lane.account, host: lane.host });
+                }
+                return {
+                    lane_id: lane.lane_id,
+                    provider: lane.provider,
+                    account: lane.account,
+                    host: lane.host,
+                    logged_in: loggedIn,
+                };
+            });
+        },
         writeLine: (line) => console.log(opts.json ? JSON.stringify({ event: line }) : line),
+        writeAccountEvent: (event) => console.log(opts.json ? JSON.stringify(event) : `account_logged_out provider=${event.provider} account=${event.account} host=${event.host.kind}:${event.host.id} lane_ids=${event.lane_ids.join(",")}`),
         writeError: (line) => process.stderr.write(`${line}\n`),
     });
     return 0;
@@ -5002,7 +5067,8 @@ function resolveResumeProfile(ctx, lane, workerId) {
 function validateResumeProfileModel(ctx, lane, profile) {
     if (profile.meta.provider !== lane.provider ||
         profile.meta.model === undefined ||
-        lane.model_source === "cli") {
+        lane.model_source === "cli" ||
+        lane.model_source === "preserved") {
         return;
     }
     const hqRoot = ctx.hqRoot();
@@ -5036,7 +5102,7 @@ function applyResumeProfileAndEffort(current, next, input) {
                 : undefined;
             next.keep_alive_blocked_reason = undefined;
         }
-        if (next.model_source !== "cli") {
+        if (next.model_source !== "cli" && next.model_source !== "preserved") {
             if (profile.meta.provider === current.provider && profile.meta.model !== undefined) {
                 next.model = profile.meta.model;
                 next.model_source = "profile";
@@ -5130,7 +5196,7 @@ function resolveResumeEffort(ctx, lane, input) {
         ? undefined
         : providerConfig.accounts[accountId];
     const profileDefaultsApply = input.profile?.profile.meta.provider === lane.provider;
-    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli"
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
         : undefined;
     const model = resolveLaneModel({
@@ -5225,11 +5291,11 @@ async function prepareAccountMove(ctx, lane, input) {
         ? loadWorkerProfile(hqRoot, lane.worker_profile)
         : undefined);
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === lane.provider;
-    const pinnedModel = input.workerProfile !== undefined
-        ? lane.model_source === "cli" ? lane.model : undefined
-        : lane.model_source === undefined || lane.model_source === "cli"
+    const pinnedModel = input.preservedModel ?? (input.workerProfile !== undefined
+        ? lane.model_source === "cli" || lane.model_source === "preserved" ? lane.model : undefined
+        : lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
             ? lane.model
-            : undefined;
+            : undefined);
     const profileModel = profileDefaultsApply ? profile?.meta.model : undefined;
     if (input.cliModel === undefined && profileDefaultsApply && profileModel !== undefined && pinnedModel === undefined) {
         validateProfileLaneModel(lane.provider, profileModel, targetHome, profile.id, {
@@ -5313,12 +5379,14 @@ async function prepareAccountMove(ctx, lane, input) {
                 provider_session_id_absent: undefined,
                 ...(input.cliModel !== undefined
                     ? { model: input.cliModel, model_source: "cli" }
-                    : {}),
+                    : input.preservedModel !== undefined
+                        ? { model: input.preservedModel, model_source: "preserved" }
+                        : {}),
                 account_history: appendCappedHistory(current.account_history ?? [], {
                     from,
                     to: target,
                     at,
-                    reason: SESSION_MOVE_REASON,
+                    reason: input.accountHistoryReason ?? SESSION_MOVE_REASON,
                 }),
                 pending_resume: input.deferTurnStart
                     ? undefined
@@ -5345,31 +5413,39 @@ async function prepareAccountMove(ctx, lane, input) {
         return { lane: moved, from, to: target, copy, queued };
     }, ctx.sleep);
 }
-async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
+async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, options = {}) {
     if (lane.provider !== "claude")
         return undefined;
-    if (!await ctx.laneClaudeAccountBalanceEnabled(lane.company)) {
+    const balanceEnabled = await ctx.laneClaudeAccountBalanceEnabled(lane.company);
+    const hqRoot = ctx.hqRoot();
+    const config = loadLanesConfig(hqRoot);
+    const currentConfig = lane.account === undefined
+        ? undefined
+        : config.providers.claude.accounts[lane.account];
+    const currentLogin = lane.account === undefined || currentConfig === undefined
+        ? false
+        : accountStatus("claude", lane.account, config, {
+            existsSync: ctx.existsSync,
+            hostname: ctx.hostname(),
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        }).logged_in;
+    const accountNeedsRepair = lane.account !== undefined &&
+        (currentConfig?.enabled !== true || currentLogin === false);
+    const repairUnavailableAccount = options.repairUnavailableAccount === true && accountNeedsRepair;
+    if (!balanceEnabled && !(options.repairUnavailableAccount && accountNeedsRepair)) {
         if (lane.account === undefined)
             return undefined;
-        const config = loadLanesConfig(ctx.hqRoot());
-        const currentConfig = config.providers.claude.accounts[lane.account];
         if (currentConfig === undefined || !currentConfig.enabled) {
             throw new AccountResolutionError(currentConfig === undefined ? "unknown_account" : "account_disabled", currentConfig === undefined
                 ? `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for claude`
                 : `Account ${JSON.stringify(lane.account)} is unavailable for claude`, { provider: "claude", account: lane.account });
         }
-        if (accountStatus("claude", lane.account, config, {
-            existsSync: ctx.existsSync,
-            hostname: ctx.hostname(),
-            probe: ctx.probeProvider,
-            env: ctx.env,
-        }).logged_in === false) {
+        if (currentLogin === false) {
             throw new LanesError("account_not_logged_in", `Account ${lane.account} for claude is not logged in`, { provider: "claude", account: lane.account, lane_id: lane.lane_id });
         }
         return undefined;
     }
-    const hqRoot = ctx.hqRoot();
-    const config = loadLanesConfig(hqRoot);
     const profile = workerProfile?.profile ?? (lane.worker_profile !== undefined
         ? loadWorkerProfile(hqRoot, lane.worker_profile)
         : undefined);
@@ -5380,33 +5456,45 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
     const allowedAccounts = profilePin !== undefined && lane.admission_accounts !== undefined
         ? profilePin.filter((account) => lane.admission_accounts.includes(account))
         : profilePin ?? lane.admission_accounts;
-    const currentConfig = lane.account === undefined
-        ? undefined
-        : config.providers.claude.accounts[lane.account];
-    const currentLogin = lane.account === undefined || currentConfig === undefined
-        ? false
-        : accountStatus("claude", lane.account, config, {
-            existsSync: ctx.existsSync,
-            hostname: ctx.hostname(),
-            probe: ctx.probeProvider,
-            env: ctx.env,
-        }).logged_in;
     const pinnedModel = workerProfile !== undefined
-        ? lane.model_source === "cli" ? lane.model : undefined
-        : lane.model_source === undefined || lane.model_source === "cli"
+        ? lane.model_source === "cli" || lane.model_source === "preserved" ? lane.model : undefined
+        : lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
             ? lane.model
             : undefined;
+    const preservedModel = repairUnavailableAccount && lane.model_source === "account"
+        ? lane.model ?? currentConfig?.model
+        : undefined;
     const model = resolveLaneModel({
-        cliModel: pinnedModel,
+        cliModel: preservedModel ?? pinnedModel,
         profileModel: profileDefaultsApply ? profile?.meta.model : undefined,
         accountModel: lane.account === undefined ? undefined : config.providers.claude.accounts[lane.account]?.model,
         providerModel: config.providers.claude.model,
     });
-    const accountNeedsRepair = currentConfig?.enabled !== true || currentLogin === false;
     const mayRebalance = BALANCE_MOVABLE_STATES.includes(lane.state);
     if (!accountNeedsRepair && !mayRebalance)
         return undefined;
-    const balanceHosts = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
+    const balanceHosts = balanceEnabled
+        ? await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config)
+        : (() => {
+            const lanes = loadAllLanes(hqRoot).filter((candidate) => candidate.host.kind === lane.host.kind && candidate.host.id === lane.host.id);
+            return {
+                snapshots: [{
+                        capacity: buildHostCapacitySnapshot({
+                            host: lane.host,
+                            lanes,
+                            config,
+                            existsSync: ctx.existsSync,
+                            probe: ctx.probeProvider,
+                            env: ctx.env,
+                            hostname: ctx.hostname(),
+                            now: ctx.now(),
+                        }),
+                        lanes,
+                        laneListAvailable: true,
+                    }],
+                unavailableHosts: [],
+            };
+        })();
     const targetHost = balanceHosts.snapshots.find((host) => host.capacity.host.kind === lane.host.kind && host.capacity.host.id === lane.host.id);
     const currentTargetAccount = lane.account === undefined
         ? undefined
@@ -5423,11 +5511,15 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile) {
         hosts: balanceHosts.snapshots,
         targetHost: lane.host,
         config,
-        ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
+        ...(!repairUnavailableAccount && allowedAccounts !== undefined ? { allowedAccounts } : {}),
         ...(model !== undefined ? { model } : {}),
         unavailableHosts: balanceHosts.unavailableHosts,
     });
-    return { ...selected, selected_at: ctx.now().toISOString() };
+    return {
+        selection: { ...selected, selected_at: ctx.now().toISOString() },
+        ...(repairUnavailableAccount ? { historyReason: "recorded_account_logged_out" } : {}),
+        ...(preservedModel !== undefined ? { preservedModel } : {}),
+    };
 }
 function accountRequestKeepsCurrentLane(lane, rawAccount) {
     const raw = rawAccount.trim();
@@ -5525,7 +5617,7 @@ async function runMessage(ctx, laneId, opts) {
     const resumeEffort = resolveResumeEffort(ctx, lane, {
         cliEffort,
         profile: resumeProfile,
-        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.account,
+        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
         model: opts.model,
     });
     const messageId = mintMessageId();
@@ -5585,12 +5677,14 @@ async function runMessage(ctx, laneId, opts) {
         }
     }
     else if (mechanism === "resume") {
-        const selection = automaticAccountSelection;
-        if (selection !== undefined) {
+        const automatic = automaticAccountSelection;
+        if (automatic !== undefined) {
+            const selection = automatic.selection;
             if (selection.account !== lane.account) {
                 move = await prepareAccountMove(ctx, lane, {
                     account: selection.account,
                     cliModel: undefined,
+                    ...(automatic.historyReason !== undefined ? { accountHistoryReason: automatic.historyReason } : {}),
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     pending: {
@@ -6063,12 +6157,12 @@ async function runResume(ctx, laneId, opts) {
         validateResumeProfileModel(ctx, lane, resumeProfile.profile);
     }
     const automaticAccountSelection = opts.account === undefined
-        ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile)
+        ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile, { repairUnavailableAccount: true })
         : undefined;
     const resumeEffort = resolveResumeEffort(ctx, lane, {
         cliEffort,
         profile: resumeProfile,
-        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.account,
+        account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
         model: opts.model,
     });
     let move = null;
@@ -6089,10 +6183,17 @@ async function runResume(ctx, laneId, opts) {
         lane = move.lane;
     }
     else if (automaticAccountSelection !== undefined) {
-        if (automaticAccountSelection.account !== lane.account) {
+        const selection = automaticAccountSelection.selection;
+        if (selection.account !== lane.account) {
             move = await prepareAccountMove(ctx, lane, {
-                account: automaticAccountSelection.account,
+                account: selection.account,
                 cliModel: undefined,
+                ...(automaticAccountSelection.historyReason !== undefined
+                    ? { accountHistoryReason: automaticAccountSelection.historyReason }
+                    : {}),
+                ...(automaticAccountSelection.preservedModel !== undefined
+                    ? { preservedModel: automaticAccountSelection.preservedModel }
+                    : {}),
                 ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                 ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                 pending: {
@@ -6102,12 +6203,12 @@ async function runResume(ctx, laneId, opts) {
                     ...(messageId !== undefined ? { message_id: messageId } : {}),
                     compact: opts.compact !== false,
                 },
-                accountSelection: automaticAccountSelection,
+                accountSelection: selection,
             });
             lane = move.lane;
         }
         else {
-            lane = persistClaudeAccountSelection(hqRoot, lane, automaticAccountSelection);
+            lane = persistClaudeAccountSelection(hqRoot, lane, selection);
         }
     }
     lane = recordResumeSetup(ctx, lane, {
@@ -8412,6 +8513,11 @@ async function runReconcile(ctx, opts) {
         dryRun: Boolean(opts.dryRun),
         spawnLaneDeps: {
             env: ctx.env,
+            modelDeps: {
+                readFileSync: ctx.readFileSync,
+                probe: ctx.probeProvider,
+                env: ctx.env,
+            },
             existsSync: ctx.existsSync,
             spawnProcess: ctx.spawnProcess,
             proveDetached: ctx.proveDetached,

package/dist/lib/checkpoint-ontology/aliases.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Alias rules shared by `apply` and the multi-writer merge-back.
+ */
+import type { EntityIndex } from "./tree.js";
+/** Longest canonical name or alias the writer accepts. */
+export declare const MAX_NAME_LENGTH = 200;
+/** The index key for a normalised name of one type. */
+export declare function entityKey(type: string, normalized: string): string;
+/**
+ * Aliases worth adding to the entity at `self`: new to it, and held by no
+ * other entity of any type, so an alias can never make a later match
+ * ambiguous. `own` holds the normalised names the entity already answers to.
+ */
+export declare function freshAliases(index: EntityIndex, type: string, self: string, own: Set<string>, names: string[]): string[];
+/** The normalised names an indexed entity answers to, plus aliases queued this run. */
+export declare function ownNames(index: EntityIndex, rel: string, queued: string[]): Set<string>;
+//# sourceMappingURL=aliases.d.ts.map

package/dist/lib/checkpoint-ontology/aliases.js

@@ -0,0 +1,44 @@
+/**
+ * Alias rules shared by `apply` and the multi-writer merge-back.
+ */
+import { canonicalizeName, isRejectedName, normalizeEntityName } from "./identity.js";
+/** Longest canonical name or alias the writer accepts. */
+export const MAX_NAME_LENGTH = 200;
+/** The index key for a normalised name of one type. */
+export function entityKey(type, normalized) {
+    return `${type}\0${normalized}`;
+}
+/**
+ * Aliases worth adding to the entity at `self`: new to it, and held by no
+ * other entity of any type, so an alias can never make a later match
+ * ambiguous. `own` holds the normalised names the entity already answers to.
+ */
+export function freshAliases(index, type, self, own, names) {
+    const seen = new Set(own);
+    const out = [];
+    for (const raw of names) {
+        const alias = canonicalizeName(raw);
+        if (!alias || alias.length > MAX_NAME_LENGTH)
+            continue;
+        const normalized = normalizeEntityName(alias, type);
+        if (!normalized || seen.has(normalized) || isRejectedName(normalized))
+            continue;
+        const holders = [
+            ...(index.canonical.get(entityKey(type, normalized)) ?? []),
+            ...(index.alias.get(entityKey(type, normalized)) ?? []),
+        ];
+        if (holders.some((holder) => holder !== self))
+            continue;
+        if ([...(index.types.get(normalized) ?? [])].some((other) => other !== type))
+            continue;
+        seen.add(normalized);
+        out.push(alias);
+    }
+    return out;
+}
+/** The normalised names an indexed entity answers to, plus aliases queued this run. */
+export function ownNames(index, rel, queued) {
+    const entity = index.byRel.get(rel);
+    return new Set([entity.canonical_name, ...entity.aliases, ...queued].map((name) => normalizeEntityName(name, entity.type)));
+}
+//# sourceMappingURL=aliases.js.map