@indigoai-us/hq-cli 5.276.0 → 5.278.0

package/dist/commands/core.js

@@ -30,6 +30,7 @@
  */
 import { Option } from "commander";
 import { registerCoreCheckpointCommand } from "./core-checkpoint.js";
+import { registerCoreDelegateCommand } from "./core-delegate.js";
 import { registerCoreOntologyCommand } from "./core-ontology.js";
 import { registerCoreCheckpointGateSettingCommand } from "./core-checkpoint-gate-setting.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
@@ -213,6 +214,14 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/lib/session-scope-capability.sh", root: "live", summary: "Session scope-capability lib sourced by hq-session" },
     { asset: "core/scripts/lib/session-id.sh", root: "live", summary: "Session-id resolver lib sourced by hq-session" },
     { asset: "core/scripts/lib/work-mesh-enqueue.sh", root: "live", summary: "Work Mesh Live spool enqueue lib sourced by hooks" },
+    // Wave 1a delegate shells remain bundled as the default-off rollback path.
+    // Their roots mirror the original scripts; pickup does not read an HQ root.
+    { asset: "core/scripts/hq-delegate-resolve.sh", root: "live", summary: "Rollback shell for native delegate resolve" },
+    { asset: "core/scripts/hq-delegate-pickup.sh", root: "cwd", summary: "Rollback shell for native delegate pickup (root independent)" },
+    { asset: "core/scripts/hq-delegate-repo.sh", root: "live", summary: "Rollback shell for native delegate repo" },
+    { asset: "core/scripts/hq-delegate-secrets.sh", root: "live", summary: "Rollback shell for native delegate secrets" },
+    { asset: "core/scripts/hq-delegate-transfer.sh", root: "live", summary: "Rollback shell for native delegate transfer" },
+    { asset: "core/scripts/lib/secret-patterns.sh", root: "live", summary: "Secret-pattern library sourced by the delegate rollback shells" },
     ...NATIVE_UTILITY_COMMANDS.map(({ asset, root, summary }) => ({
         asset,
         root,
@@ -288,6 +297,7 @@ export function registerCoreCommands(program) {
     registerCoreCheckpointCommand(core);
     registerCoreOntologyCommand(core);
     registerCoreCheckpointGateSettingCommand(core);
+    registerCoreDelegateCommand(core);
     // These command names intentionally own native implementations. Their
     // similarly named scaffold assets are forwarders, so sending them through
     // runEntry would recurse back into this command forever.

package/dist/commands/daemon.d.ts

@@ -16,6 +16,7 @@
 import type { Command } from "commander";
 import { type LegacyUnit } from "../lib/daemon/legacy.js";
 import type { HostApp } from "../lib/daemon/supervisor.js";
+import { type SyncModeVaultClient } from "./sync-mode.js";
 import type { RunCommand } from "../lib/service-manager/launchd.js";
 export interface DaemonCommandDeps {
     env: NodeJS.ProcessEnv;
@@ -38,6 +39,8 @@ export interface DaemonCommandDeps {
     userHome: (user: string) => string;
     /** The pid is a live `hq daemon run`. */
     daemonAlive: (pid: number) => boolean;
+    /** Test seam for the company sync-mode commands. */
+    syncModeClient?: () => Promise<SyncModeVaultClient>;
     windowsUser?: string;
     windowsHeadlessLauncher?: string;
     systemUnitDir?: string;

package/dist/commands/daemon.js

@@ -18,7 +18,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { major as semverMajor, valid as validSemver } from "semver";
 import { DEFAULT_SERVICES, SERVICE_DESCRIPTIONS, enabledServices, hqCloudUnits } from "../lib/daemon/catalog.js";
-import { applyServiceToggle, readDaemonConfig, writeDaemonConfig } from "../lib/daemon/config.js";
+import { applyServiceToggle, effectiveSyncOwner, readDaemonConfig, writeDaemonConfig } from "../lib/daemon/config.js";
 import { daemonUnitInstalled } from "../lib/daemon/handoff.js";
 import { adoptLegacyUnits, readAdoptedUnits, restoreLegacyUnits } from "../lib/daemon/migrate.js";
 import { ROOT_REFUSAL, SYSTEM_UNIT_DIR, daemonRootRefusal, installDaemonUnit, installScopeFor, uninstallDaemonUnit, } from "../lib/daemon/install.js";
@@ -27,7 +27,10 @@ import { isDaemonProcess, runningDaemonPid } from "../lib/daemon/lock.js";
 import { bundledHqCloud } from "../lib/daemon/hq-cloud.js";
 import { MACHINE_TYPE_MARKER_PATH, detectMachineType, homeFromPasswd, } from "../lib/daemon/machine-type.js";
 import { daemonPaths } from "../lib/daemon/paths.js";
+import { processCommandLine } from "../lib/daemon/lock.js";
 import { writeControlRequest } from "../lib/daemon/requests.js";
+import { isSyncRunnerCommandLine, readWatchRunnerOwnerStatus, watchRunnerOwnerStatusPath } from "../lib/daemon/sync-runner.js";
+import { getSyncModeForCompany, setSyncMode } from "./sync-mode.js";
 import { resolveDefaultHqRoot } from "../utils/cognito-session.js";
 class DaemonCommandError extends Error {
 }
@@ -96,6 +99,7 @@ async function loadDefaults(over) {
         windowsUser: over.windowsUser ?? (platform === "win32" ? mesh.resolveWindowsUser(env) : ""),
         windowsHeadlessLauncher: over.windowsHeadlessLauncher ?? (platform === "win32" ? mesh.resolveWindowsHeadlessLauncher(env) : undefined),
         systemUnitDir: over.systemUnitDir ?? SYSTEM_UNIT_DIR,
+        syncModeClient: over.syncModeClient,
         systemRecordPath: over.systemRecordPath ?? path.join(SYSTEM_ADOPTED_ROOT, "adopted.json"),
     };
 }
@@ -373,6 +377,135 @@ function queueRequest(d, request, what) {
     const running = runningDaemonPid(paths.lockPath, d.daemonAlive) !== null;
     d.out(running ? `Asked the daemon to ${what}.` : `Queued "${what}"; the daemon is not running, so it applies when it starts.`);
 }
+function daemonSyncModeClient(d) {
+    if (d.syncModeClient)
+        return d.syncModeClient();
+    return (async () => {
+        const [{ VaultClient }, { buildVaultConfig, ensureCognitoToken }] = await Promise.all([
+            import("@indigoai-us/hq-cloud"),
+            import("../utils/cognito-session.js"),
+        ]);
+        const token = await ensureCognitoToken();
+        return new VaultClient(buildVaultConfig(token));
+    })();
+}
+function daemonSyncStatus(d) {
+    const host = currentHost(d);
+    const { paths } = host;
+    const config = readDaemonConfig(paths.configPath);
+    const daemonPid = runningDaemonPid(paths.lockPath, d.daemonAlive);
+    const daemonState = daemonPid === null ? null : readState(paths);
+    const syncUnit = daemonState?.units.find((unit) => unit.id === "sync");
+    const hqRoot = config.hqRoot ?? d.env.HQ_ROOT?.trim();
+    let ownerStatusCandidate = null;
+    if (hqRoot) {
+        try {
+            ownerStatusCandidate = readWatchRunnerOwnerStatus(watchRunnerOwnerStatusPath(hqRoot, d.home, d.env));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            d.err(`Could not read sync runner owner status; treating it as unavailable: ${detail}`);
+        }
+    }
+    const ownerCommandLine = ownerStatusCandidate
+        ? processCommandLine(ownerStatusCandidate.pid, { platform: d.platform, run: d.run })
+        : null;
+    const ownerStatus = ownerCommandLine && isSyncRunnerCommandLine(ownerCommandLine)
+        ? ownerStatusCandidate
+        : null;
+    return {
+        running: syncUnit?.status === "running",
+        paused: config.syncPaused === true,
+        syncOwner: effectiveSyncOwner(config, host.detected.type),
+        owner: ownerStatus?.owner ?? (syncUnit?.status === "running" ? "hq-daemon" : null),
+        runnerPid: ownerStatus?.pid ?? syncUnit?.pid ?? null,
+        hqCloudVersion: ownerStatus?.version ?? null,
+        lastHeartbeat: syncUnit?.lastHeartbeatAt ?? ownerStatus?.heartbeatAt ?? null,
+        lastPassResult: syncUnit?.lastPassResult ?? null,
+        unitStatus: syncUnit?.status ?? "not-running",
+        reason: syncUnit?.reason ?? null,
+        logPath: paths.unitLogPath("sync"),
+    };
+}
+async function runDaemonSyncStatus(d, opts) {
+    const status = daemonSyncStatus(d);
+    if (opts.json) {
+        d.out(JSON.stringify(status, null, 2));
+        return;
+    }
+    d.out(`Sync ${status.running ? "running" : status.unitStatus}${status.paused ? " (paused)" : ""}.`);
+    d.out(`Configured sync owner: ${status.syncOwner}.`);
+    d.out(`Owner: ${status.owner ?? "none"}; runner pid: ${status.runnerPid ?? "none"}; hq-cloud: ${status.hqCloudVersion ?? "unknown"}.`);
+    if (status.reason)
+        d.out(`Reason: ${status.reason}`);
+    d.out(`Log: ${status.logPath}`);
+}
+function queueDaemonSyncControl(d, request) {
+    const host = currentHost(d);
+    writeControlRequest(host.paths.requestsDir, request);
+    handOver(d, host);
+    return runningDaemonPid(host.paths.lockPath, d.daemonAlive) !== null;
+}
+async function runDaemonSyncNow(d, opts) {
+    const host = currentHost(d);
+    const config = readDaemonConfig(host.paths.configPath);
+    if (config.syncPaused)
+        throw new DaemonCommandError("sync is paused; run `hq daemon sync resume` first");
+    if (!enabledServices(host.detected.type, config).includes("sync")) {
+        throw new DaemonCommandError("sync is disabled for this machine; run `hq daemon enable sync` first");
+    }
+    const running = queueDaemonSyncControl(d, { action: "restart", unit: "sync" });
+    const result = { accepted: true, action: "restart-sync-runner", daemonRunning: running };
+    d.out(opts.json ? JSON.stringify(result, null, 2) : running ? "Asked the daemon to start a fresh sync pass." : "Queued a fresh sync pass for the next daemon start.");
+}
+async function runDaemonSyncPause(d, paused, opts) {
+    const host = currentHost(d);
+    const config = readDaemonConfig(host.paths.configPath);
+    if (config.syncPaused !== paused)
+        writeDaemonConfig(host.paths.configPath, { ...config, syncPaused: paused });
+    const daemonRunning = queueDaemonSyncControl(d, { action: "reconcile" });
+    const result = { paused, persisted: true, daemonRunning };
+    d.out(opts.json ? JSON.stringify(result, null, 2) : `Sync ${paused ? "paused" : "resumed"}${daemonRunning ? "" : "; the setting will apply when the daemon starts"}.`);
+}
+async function runDaemonSyncTakeOwnership(d, opts) {
+    const host = currentHost(d);
+    const config = readDaemonConfig(host.paths.configPath);
+    if (config.syncOwner !== "daemon")
+        writeDaemonConfig(host.paths.configPath, { ...config, syncOwner: "daemon" });
+    const daemonRunning = queueDaemonSyncControl(d, { action: "reconcile" });
+    const result = { syncOwner: "daemon", persisted: true, daemonRunning };
+    d.out(opts.json ? JSON.stringify(result, null, 2) : `Daemon sync ownership persisted${daemonRunning ? "; asked the daemon to reconcile" : "; it applies when the daemon starts"}.`);
+}
+async function runDaemonSyncModeGet(d, companySlug, opts) {
+    const result = await getSyncModeForCompany({ companySlug, vaultClient: await daemonSyncModeClient(d) });
+    const value = {
+        companySlug: result.companySlug,
+        membershipId: result.membershipId,
+        mode: result.config.syncMode,
+        isDefault: result.config.isDefault,
+        ...(result.config.updatedAt ? { updatedAt: result.config.updatedAt } : {}),
+    };
+    d.out(opts.json ? JSON.stringify(value, null, 2) : `${value.companySlug}: ${value.mode}${value.isDefault ? " (default)" : ""}`);
+}
+async function runDaemonSyncModeSet(d, companySlug, mode, opts) {
+    if (mode !== "all" && mode !== "shared") {
+        throw new DaemonCommandError(`Invalid sync mode '${mode}'. Use all or shared.`);
+    }
+    const result = await setSyncMode({
+        mode,
+        companySlug,
+        vaultClient: await daemonSyncModeClient(d),
+    });
+    const value = {
+        companySlug: result.companySlug,
+        membershipId: result.membershipId,
+        previousMode: result.previousMode,
+        mode: result.newMode,
+        isDefault: result.newConfig.isDefault,
+        ...(result.newConfig.updatedAt ? { updatedAt: result.newConfig.updatedAt } : {}),
+    };
+    d.out(opts.json ? JSON.stringify(value, null, 2) : `${value.companySlug}: ${value.previousMode} → ${value.mode}`);
+}
 async function runToggle(d, action, services) {
     const host = currentHost(d);
     const { paths } = host;
@@ -609,6 +742,45 @@ export function registerDaemonCommand(program, over = {}) {
         .description("Show the machine type and each service's state")
         .option("--json", "Print machine-readable JSON")
         .action(wrap((d, opts) => runStatus(d, opts)));
+    const sync = daemon
+        .command("sync")
+        .description("Inspect and control the daemon's company sync runner");
+    sync
+        .command("status")
+        .description("Show sync ownership, heartbeat, last pass and log path")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncStatus(d, opts)));
+    sync
+        .command("now")
+        .description("Start a fresh sync pass immediately")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncNow(d, opts)));
+    sync
+        .command("pause")
+        .description("Pause daemon sync until resumed")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncPause(d, true, opts)));
+    sync
+        .command("resume")
+        .description("Resume daemon sync after a pause")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncPause(d, false, opts)));
+    sync
+        .command("take-ownership")
+        .description("Persist daemon ownership of desktop sync and reconcile")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, opts) => runDaemonSyncTakeOwnership(d, opts)));
+    const mode = sync.command("mode").description("Read or change a company's sync footprint");
+    mode
+        .command("get <company>")
+        .description("Read a company's current all/shared sync mode")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, company, opts) => runDaemonSyncModeGet(d, company, opts)));
+    mode
+        .command("set <company> <mode>")
+        .description("Set a company's sync mode to all or shared")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, company, mode, opts) => runDaemonSyncModeSet(d, company, mode, opts)));
     daemon
         .command("logs [unit]")
         .description("Print the supervisor log, or one service's log")

package/dist/commands/dm.d.ts

@@ -368,5 +368,7 @@ export declare function agentCallerUid(token: string, machine?: () => boolean):
 export declare const AGENT_THREAD_UNAVAILABLE: string;
 /** One-line summary of an agent inbox item (DM, email, … — shapes vary by channel). Pure. */
 export declare function formatAgentInboxItem(item: Record<string, unknown>): string;
+/** Remove delegated execution context before agent inbox items can be emitted. */
+export declare function redactAgentInboxItem<T extends object>(item: T): Omit<T, "actingContext">;
 export declare function registerDmCommand(program: Command): void;
 //# sourceMappingURL=dm.d.ts.map

package/dist/commands/dm.js

@@ -1064,16 +1064,22 @@ export function formatAgentInboxItem(item) {
     const text = str("text") || str("body") || str("subject");
     return `${chalk.bold(from)} ${chalk.dim(`[${channel}] ${id}${when ? ` ${when}` : ""}`)}\n  ${firstLine(text)}`;
 }
+/** Remove delegated execution context before agent inbox items can be emitted. */
+export function redactAgentInboxItem(item) {
+    const { actingContext: _actingContext, ...safe } = item;
+    return safe;
+}
 async function runAgentInbox(token, agentUid, opts) {
     const route = `/v1/agents/${encodeURIComponent(agentUid)}/inbox`;
     const res = await vaultApiFetch({ token, path: route });
     if (!res.ok) {
-        const text = await res.text().catch(() => "");
-        console.error(chalk.red(`GET ${route} → ${res.status}${text ? `: ${text.slice(0, 300)}` : ""}`));
+        // Error bodies are not constrained to the success response shape. Do not
+        // echo them: a proxy or partial failure could include inbox items.
+        console.error(chalk.red(`GET ${route} → ${res.status}`));
         process.exit(1);
     }
     const data = (await res.json().catch(() => ({})));
-    let items = Array.isArray(data.messages) ? data.messages : [];
+    let items = (Array.isArray(data.messages) ? data.messages : []).map(redactAgentInboxItem);
     if (opts.limit && Number(opts.limit) > 0)
         items = items.slice(0, Number(opts.limit));
     if (opts.json) {
@@ -1251,7 +1257,8 @@ async function runDmChannel(target, opts) {
         }
         const data = (await res.json());
         const messages = data.messages ?? [];
-        const ordered = [...messages].reverse(); // oldest-first for reading
+        const agentCaller = agentCallerUid(token) !== null;
+        const ordered = [...messages].reverse().map((message) => agentCaller ? redactAgentInboxItem(message) : message); // oldest-first for reading; agent JSON must not expose delegated context
         if (opts.json) {
             console.log(JSON.stringify(ordered, null, 2));
         }

package/dist/commands/lanes-accounts.js

@@ -130,6 +130,10 @@ export function createLaneAccountsHandlers(deps) {
             return {
                 ...status,
                 effective_home: status.home,
+                ...(status.auth_state === "home_missing" ? {
+                    error: "home_missing",
+                    fix_command: `hq lanes accounts set-home ${provider} ${status.id} <host-home>`,
+                } : {}),
                 model: accountCfg?.model ?? null,
                 effort: accountCfg?.effort ?? null,
                 effective_model: model ?? null,
@@ -165,6 +169,7 @@ export function createLaneAccountsHandlers(deps) {
         // Retain the established response field for clients; balancing is now
         // unconditional, so this compatibility value is always true.
         const balanceGateEnabled = true;
+        const recentUsageEnabled = await deps.readClaudeAccountBalanceSignalsEnabled(ctx);
         const loads = accountLoadsForReport({ hosts: loaded.snapshots, config });
         const suggestions = planClaudeBalanceMoves({ hosts: loaded.snapshots, config });
         const selections = loaded.snapshots.map((host) => {
@@ -173,6 +178,8 @@ export function createLaneAccountsHandlers(deps) {
                     hosts: loaded.snapshots,
                     targetHost: host.capacity.host,
                     config,
+                    recentUsageEnabled,
+                    now: ctx.now(),
                     unavailableHosts: loaded.unavailableHosts,
                 });
                 return {
@@ -192,11 +199,19 @@ export function createLaneAccountsHandlers(deps) {
         });
         const accounts = Object.keys(config.providers.claude.accounts).sort().map((account) => {
             const load = loads.find((row) => row.account === account);
+            const currentStatus = loaded.snapshots[0]?.capacity.providers.claude.accounts[account];
+            const currentHomeMissing = config.providers.claude.accounts[account]?.enabled === true &&
+                currentStatus?.auth_state === "home_missing";
             return {
                 account,
                 enabled: config.providers.claude.accounts[account]?.enabled === true,
                 live_lanes: load?.live_lanes ?? 0,
                 counts_complete: load?.counts_complete ?? false,
+                ...(load ? { recent_usage_at: load.recent_usage_at } : {}),
+                ...(currentHomeMissing ? {
+                    error: "home_missing",
+                    fix_command: `hq lanes accounts set-home claude ${account} <host-home>`,
+                } : {}),
                 hosts: loaded.snapshots.map((host) => {
                     const accountStatus = host.capacity.providers.claude.accounts[account];
                     const accountLoad = load?.hosts.find((row) => row.host.kind === host.capacity.host.kind && row.host.id === host.capacity.host.id);
@@ -204,6 +219,11 @@ export function createLaneAccountsHandlers(deps) {
                         host: host.capacity.host,
                         enabled: accountStatus?.enabled ?? false,
                         logged_in: accountStatus?.logged_in ?? null,
+                        ...(accountStatus?.auth_state !== undefined ? { auth_state: accountStatus.auth_state } : {}),
+                        ...(accountStatus?.auth_state === "home_missing" ? {
+                            error: "home_missing",
+                            fix_command: `hq lanes accounts set-home claude ${account} <host-home>`,
+                        } : {}),
                         live_lanes: accountLoad?.live_lanes ?? null,
                         lane_counts: accountLoad?.lane_counts ?? { running: null, queued: null, awaiting_input: null },
                         count_source: accountLoad?.count_source ?? "unavailable",
@@ -251,6 +271,10 @@ export function createLaneAccountsHandlers(deps) {
             suggestions,
             ...(opts.apply ? { moved, skipped } : {}),
         });
+        const currentHostMissing = Object.entries(config.providers.claude.accounts).some(([account, accountConfig]) => accountConfig.enabled &&
+            loaded.snapshots[0]?.capacity.providers.claude.accounts[account]?.auth_state === "home_missing");
+        if (currentHostMissing)
+            process.exitCode = 1;
     }
     async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
         const callerCwd = ctx.callerCwd();
@@ -276,6 +300,12 @@ export function createLaneAccountsHandlers(deps) {
         if (opts.company !== undefined) {
             await resolveSelectedAccountHomeCompany(ctx, opts.company);
         }
+        if (process.platform === "linux" &&
+            requestedHome === undefined &&
+            registeredAccount !== undefined &&
+            effectiveAccountHome(registeredAccount, hostname).source !== "host") {
+            throw new LanesError("account_host_home_required", `Account ${id} for ${provider} has no home for this Linux host; pass --home <host-home> to store a host-specific home`, { provider, account: id, hostname });
+        }
         const homeRaw = requestedHome ??
             (registeredAccount !== undefined
                 ? effectiveAccountHome(registeredAccount, hostname).home
@@ -291,10 +321,22 @@ export function createLaneAccountsHandlers(deps) {
             existsSync: (p) => fs.existsSync(p),
         });
         const nextAccount = registeredAccount === undefined
-            ? { home, enabled: true }
+            ? process.platform === "linux"
+                ? {
+                    home: id === "a" ? DEFAULT_ACCOUNT_HOMES[provider] : `~/.${provider}-${id}`,
+                    hosts: { [hostname]: { home } },
+                    enabled: true,
+                }
+                : { home, enabled: true }
             : { ...registeredAccount, enabled: true };
         if (registeredAccount !== undefined && requestedHome !== undefined) {
-            if (home === registeredAccount.home) {
+            if (process.platform === "linux") {
+                nextAccount.hosts = {
+                    ...(registeredAccount.hosts ?? {}),
+                    [hostname]: { home },
+                };
+            }
+            else if (home === registeredAccount.home) {
                 if (nextAccount.hosts !== undefined) {
                     delete nextAccount.hosts[hostname];
                     if (Object.keys(nextAccount.hosts).length === 0)

package/dist/commands/lanes-message.js

@@ -9,7 +9,7 @@ import { dropboxInboxHasMessages, drainDropbox, formatDropboxMessages, formatMon
 import { isPidAlive, runWatcherLoop, WATCHER_OUT_MAX_BYTES, watcherOutLogPath, writeWatcherDecision } from "../lib/lanes/watcher.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
-import { keepAliveExclusion, keepAliveSupersededBy, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
+import { keepAliveExclusion, keepAliveSupersededBy, LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
 import { managerStatusGateEnabledForLane } from "../lib/lanes/manager-status-gate.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
@@ -90,20 +90,20 @@ export function createLaneMessageHandlers(deps) {
             company: companyForLane(lane),
             env: ctx.env,
         });
-        const currentLane = readLane(ctx.hqRoot(), lane.lane_id);
+        let currentLane = readLane(ctx.hqRoot(), lane.lane_id);
         if (currentLane.state === "killed" || currentLane.state === "cancelled") {
             return { lane: currentLane, exclusion: currentLane.state };
         }
         const localLanes = loadAllLanes(ctx.hqRoot());
         let lanes = localLanes;
-        const retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
+        let retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
         const dispatchedCallerId = grantContext?.superseded_message_caller_id;
         const dispatchedSessionId = grantContext?.superseded_message_session_id;
-        const dispatchedContextBound = grantContext !== undefined &&
+        let dispatchedContextBound = grantContext !== undefined &&
             ctx.isSsmOwnerDispatch() &&
             sameHireGrantSenior(grantContext.expected_senior, currentLane.senior);
-        const dispatchedSessionContext = dispatchedContextBound && currentLane.senior.kind === "session";
-        const dispatchedContextAuthorized = dispatchedContextBound && (dispatchedCallerId !== undefined ||
+        let dispatchedSessionContext = dispatchedContextBound && currentLane.senior.kind === "session";
+        let dispatchedContextAuthorized = dispatchedContextBound && (dispatchedCallerId !== undefined ||
             (dispatchedSessionId !== undefined && dispatchedSessionId === currentLane.senior.id));
         if (dispatchedContextBound && grantContext &&
             (dispatchedCallerId !== undefined || dispatchedSessionContext)) {
@@ -116,7 +116,61 @@ export function createLaneMessageHandlers(deps) {
             merged.set(currentLane.lane_id, currentLane);
             lanes = [...merged.values()];
         }
-        const exclusion = keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware, companyForLane);
+        let exclusion = keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware, companyForLane);
+        if (exclusion === "superseded" && currentLane.state !== "done" && currentLane.state !== "interrupted") {
+            const runningSupersededMessageDeliveryEnabled = await readLanesRegistryFlag(LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, { company: companyForLane(currentLane), env: ctx.env });
+            if (runningSupersededMessageDeliveryEnabled) {
+                const latestLane = readLane(ctx.hqRoot(), currentLane.lane_id);
+                if (latestLane.state === "killed" || latestLane.state === "cancelled") {
+                    return { lane: latestLane, exclusion: latestLane.state };
+                }
+                const latestLocalLanes = loadAllLanes(ctx.hqRoot());
+                currentLane = latestLane;
+                let latestLanes = latestLocalLanes;
+                dispatchedContextBound =
+                    grantContext !== undefined &&
+                        ctx.isSsmOwnerDispatch() &&
+                        sameHireGrantSenior(grantContext.expected_senior, currentLane.senior);
+                dispatchedSessionContext = dispatchedContextBound && currentLane.senior.kind === "session";
+                dispatchedContextAuthorized = dispatchedContextBound && (dispatchedCallerId !== undefined ||
+                    (dispatchedSessionId !== undefined && dispatchedSessionId === currentLane.senior.id));
+                if (dispatchedContextBound && grantContext &&
+                    (dispatchedCallerId !== undefined || dispatchedSessionContext)) {
+                    const merged = new Map(latestLocalLanes.map((record) => [record.lane_id, record]));
+                    for (const snapshot of grantContext.hierarchy) {
+                        const contextLane = keepAliveLaneFromSnapshot(snapshot);
+                        if (contextLane)
+                            merged.set(contextLane.lane_id, contextLane);
+                    }
+                    merged.set(currentLane.lane_id, currentLane);
+                    latestLanes = [...merged.values()];
+                }
+                lanes = latestLanes;
+                retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
+                exclusion = keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware, companyForLane);
+                if (exclusion === "superseded" && currentLane.state !== "done" && currentLane.state !== "interrupted") {
+                    const callerLaneId = dispatchedContextBound ? dispatchedCallerId : undefined;
+                    const callerSessionId = dispatchedContextBound
+                        ? (dispatchedSessionId === undefined ? null : dispatchedSessionId)
+                        : undefined;
+                    const callerMayMessage = callerMayMessageSupersededLane(ctx, currentLane, lanes, lineageAware, companyForLane, callerLaneId, callerSessionId);
+                    return {
+                        lane: currentLane,
+                        exclusion: undefined,
+                        ...(!dispatchedContextAuthorized && callerMayMessage && ctx.env.HQ_LANE_ID?.trim()
+                            ? { supersededMessageCallerId: ctx.env.HQ_LANE_ID.trim() }
+                            : {}),
+                        ...(callerMayMessage && !dispatchedContextBound && currentLane.senior.kind === "session" &&
+                            typeof currentLane.senior.id === "string" &&
+                            currentLane.senior.id.length > 0 &&
+                            callerMatchesSessionSenior(ctx, currentLane.senior.id)
+                            ? { supersededMessageSessionId: currentLane.senior.id }
+                            : {}),
+                        supersededMessageWarning: `A newer lead supersedes this ${currentLane.state} lane; message delivery is allowed while the lane remains active.`,
+                    };
+                }
+            }
+        }
         const callerLaneId = dispatchedContextBound ? dispatchedCallerId : undefined;
         const callerSessionId = dispatchedContextBound
             ? (dispatchedSessionId === undefined ? null : dispatchedSessionId)
@@ -552,11 +606,14 @@ export function createLaneMessageHandlers(deps) {
                     : mechanism === "dropbox"
                         ? "awaiting_next_tool_call"
                         : "worker_spawned";
-            const warning = mechanism === "dropbox" && drainHook !== null && !drainHook.registered
-                ? `The drain hook is not registered in ${drainHook.path}; the running worker will not receive this message. It stays in the inbox and is delivered on the lane's next start.`
-                : mechanism === "dropbox" && next.stalled === true
-                    ? `The worker has made no tool call since ${next.stalled_at ?? "an unknown time"} (${next.stalled_reason ?? "stalled"}); delivery waits on its next tool call.`
-                    : null;
+            const warning = [
+                eligibility.supersededMessageWarning,
+                mechanism === "dropbox" && drainHook !== null && !drainHook.registered
+                    ? `The drain hook is not registered in ${drainHook.path}; the running worker will not receive this message. It stays in the inbox and is delivered on the lane's next start.`
+                    : mechanism === "dropbox" && next.stalled === true
+                        ? `The worker has made no tool call since ${next.stalled_at ?? "an unknown time"} (${next.stalled_reason ?? "stalled"}); delivery waits on its next tool call.`
+                        : null,
+            ].filter((message) => message !== undefined && message !== null).join(" ") || null;
             if (!opts.silent)
                 printJson({
                     ok: true,

package/dist/commands/lanes-resume.js

@@ -223,6 +223,7 @@ export function createLaneResumeHandlers(deps) {
                 ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                 ...(profileRepin !== undefined ? { profileRepin } : {}),
                 ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
                 pending: {
                     trigger: "resume",
                     resumed_from: resumedFrom,
@@ -252,6 +253,7 @@ export function createLaneResumeHandlers(deps) {
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                    ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
                     pending: {
                         trigger: "resume",
                         resumed_from: resumedFrom,

package/dist/commands/lanes-shared.d.ts

@@ -245,9 +245,11 @@ export interface Ctx {
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
 }
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+export declare const CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG = "lanes.claude-account-balance-signals";
 export declare function defaultLanePlacementEnabled(company: LaneCompanyRef | undefined): Promise<boolean>;
 export declare function readLanePlacementEnabled(ctx: Ctx, company: LaneCompanyRef | undefined): Promise<boolean>;
 export declare function processLanePlacementCompany(ctx: Ctx): LaneCompanyRef | undefined;
+export declare function readClaudeAccountBalanceSignalsEnabled(ctx: Ctx, company?: LaneCompanyRef): Promise<boolean>;
 export declare function parsePlacementPolicy(raw: string): LanePlacementPolicy;
 export declare function assertPlacementEnabled(ctx: Ctx, company: LaneCompanyRef | undefined, readPlacementEnabled?: () => Promise<boolean>): Promise<void>;
 /** Match a direct session-senior caller while refusing lane-worker identities. */
@@ -349,6 +351,7 @@ export interface LaneAccountsHandlerDeps {
         to: string;
     }>;
     printJson(value: unknown): void;
+    readClaudeAccountBalanceSignalsEnabled(ctx: Ctx): Promise<boolean>;
     reconcileHostFromCtx(ctx: Ctx): ReconcileHost;
     resolveCallerPath(callerCwd: string, filePath: string): string;
 }

package/dist/commands/lanes-shared.js

@@ -72,9 +72,9 @@ export 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" || lane.model_source === "preserved"
+    const pinnedModel = lane.pending_settings?.model ?? (lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
-        : undefined;
+        : undefined);
     const model = resolveLaneModel({
         cliModel: input.model?.trim() || pinnedModel,
         profileModel: profileDefaultsApply ? input.profile?.profile.meta.model : undefined,
@@ -90,12 +90,16 @@ export function resolveResumeEffort(ctx, lane, input) {
     });
 }
 export function recordedResumeEffort(lane) {
+    if (lane.pending_settings?.effort !== undefined) {
+        return { effort: lane.pending_settings.effort, source: "cli" };
+    }
     return {
         ...(lane.effort !== undefined ? { effort: lane.effort } : {}),
         source: lane.effort_source ?? "none",
     };
 }
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+export const CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG = "lanes.claude-account-balance-signals";
 function lanePlacementFlagErrorCode(error) {
     if (error && typeof error === "object") {
         for (const key of ["code", "error", "name"]) {
@@ -135,6 +139,12 @@ export function processLanePlacementCompany(ctx) {
         return undefined;
     return { slug: context.companySlug, uid: context.companyUid ?? "" };
 }
+export function readClaudeAccountBalanceSignalsEnabled(ctx, company) {
+    return readLanesRegistryFlag(CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG, {
+        company: company ?? processLanePlacementCompany(ctx),
+        env: ctx.env,
+    });
+}
 export function parsePlacementPolicy(raw) {
     const value = raw.trim();
     if (value === "local")

package/dist/commands/lanes.d.ts

@@ -8,7 +8,7 @@
 import { Command } from "commander";
 import { type LanesMesh, type SpawnLoginResult } from "./lanes-shared.js";
 export type { LanesMesh, SpawnLoginResult } from "./lanes-shared.js";
-export { LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lanes-shared.js";
+export { CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG, LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lanes-shared.js";
 export { resolveAnswerChoice } from "./lanes-questions.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
@@ -139,5 +139,9 @@ export declare function pickupFailureUpdater(reasonRaw: string, details: Record<
 export declare function applyOutpostAccountPickup(hqRoot: string, laneId: string, modelDeps?: KnownModelsDeps): LaneRecord;
 export declare function cancelPendingQuestionsForLane(hqRoot: string, laneId: string, nowIso: string, operatorReason?: string): QuestionRecord[];
 export declare function stopCommittedState(state: LaneRecord["state"]): "cancelled" | "killed";
+/** Stderr notice that `stop` ends a lane for good, naming the resumable path. */
+export declare function stopTerminalWarning(laneId: string): string;
+/** Stderr notice when an interrupted lane has no session to resume from. */
+export declare function interruptNotResumableWarning(laneId: string): string;
 export declare function registerLanesCommand(parent: Command, deps?: LanesCommandDeps): Command;
 //# sourceMappingURL=lanes.d.ts.map