@indigoai-us/hq-cli 5.345.57 → 5.345.59

package/dist/lib/agent-kit/inbox-poll-backoff-flag.js

@@ -0,0 +1,70 @@
+import { createFlagClient, } from "@indigoai-us/hq-flags-client";
+import { resolveFlagGate } from "../flag-registry.js";
+import { resolveFlagRegistryEndpoint } from "../flag-registry-endpoint.js";
+export const AGENT_KIT_INBOX_BACKOFF_FLAG = "agents.inbox-poll-backoff-agent-kit";
+export const AGENT_KIT_INBOX_BACKOFF_DEFAULT = true;
+export const AGENT_KIT_INBOX_BACKOFF_CACHE_MS = 3 * 60_000;
+export const AGENT_KIT_INBOX_BACKOFF_TIMEOUT_MS = 2_000;
+/** Read the default-on kill switch; registry outages preserve idle backoff. */
+export function createAgentKitInboxBackoffFlagReader(dependencies) {
+    const createClient = dependencies.createClient ?? createFlagClient;
+    const now = dependencies.now ?? Date.now;
+    const report = dependencies.reportFailure ?? ((error) => {
+        const name = error instanceof Error ? error.name : "UnknownError";
+        process.stderr.write(`HQ agent-kit inbox backoff flag lookup failed (${name}); keeping the default-on behavior.\n`);
+    });
+    let cachedValue = AGENT_KIT_INBOX_BACKOFF_DEFAULT;
+    let lastReadAt = Number.NEGATIVE_INFINITY;
+    let pending = null;
+    const read = async () => {
+        let client;
+        let failed = false;
+        const reportOnce = (error) => {
+            if (failed)
+                return;
+            failed = true;
+            report(error);
+        };
+        try {
+            client = createClient({
+                endpoint: resolveFlagRegistryEndpoint(dependencies.endpoint),
+                ...(dependencies.companySlug ? { companyIdentifiers: [dependencies.companySlug] } : {}),
+                env: {},
+                getToken: dependencies.getToken,
+                ...(dependencies.fetch ? { fetch: dependencies.fetch } : {}),
+                refreshIntervalMs: 0,
+                requestTimeoutMs: AGENT_KIT_INBOX_BACKOFF_TIMEOUT_MS,
+                onError: reportOnce,
+            });
+            await client.ready();
+            cachedValue = failed
+                ? AGENT_KIT_INBOX_BACKOFF_DEFAULT
+                : resolveFlagGate(client, AGENT_KIT_INBOX_BACKOFF_FLAG, { fallback: AGENT_KIT_INBOX_BACKOFF_DEFAULT }, () => AGENT_KIT_INBOX_BACKOFF_DEFAULT);
+        }
+        catch (error) {
+            reportOnce(error);
+            cachedValue = AGENT_KIT_INBOX_BACKOFF_DEFAULT;
+        }
+        finally {
+            try {
+                client?.close();
+            }
+            catch (error) {
+                reportOnce(error);
+                cachedValue = AGENT_KIT_INBOX_BACKOFF_DEFAULT;
+            }
+        }
+        return cachedValue;
+    };
+    return () => {
+        const currentTime = now();
+        if (pending)
+            return pending;
+        if (currentTime - lastReadAt < AGENT_KIT_INBOX_BACKOFF_CACHE_MS)
+            return Promise.resolve(cachedValue);
+        lastReadAt = currentTime;
+        pending = read().finally(() => { pending = null; });
+        return pending;
+    };
+}
+//# sourceMappingURL=inbox-poll-backoff-flag.js.map

package/dist/lib/agent-kit/run/inbox.d.ts

@@ -21,6 +21,7 @@ import { type WakeConfig, type WakeDeps, type WakeNotice, type WakeResult } from
 export declare const SEEN_IDS_NAME = "seen-ids.json";
 export declare const INBOX_JSONL_NAME = "inbox.jsonl";
 export declare const MAX_SEEN_IDS = 5000;
+export declare const INBOX_POLL_BACKOFF_MAX_MS = 30000;
 export interface InboxItem {
     id: string;
     raw: Record<string, unknown>;
@@ -38,10 +39,13 @@ export interface InboxDeps {
     ack: boolean;
     getToken: () => Promise<string>;
     log: KitLogger;
-    fetchInbox?: (token: string) => Promise<InboxFetchResult>;
+    fetchInbox?: (token: string, signal?: AbortSignal) => Promise<InboxFetchResult>;
     ackItem?: (token: string, id: string) => Promise<number>;
     warmCache?: (token: string, agentUid: string) => Promise<unknown>;
-    sleep?: (ms: number) => Promise<void>;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    readInboxBackoffEnabled?: () => Promise<boolean>;
+    signal?: AbortSignal;
+    companySlug?: string;
     maxPolls?: number;
     /** Override wake config lookup (tests). `null` disables the wake. */
     wakeConfig?: WakeConfig | null;
@@ -66,7 +70,7 @@ export interface InboxFetchResult {
 export declare function agentApiUrl(apiBaseUrl: string, route: string): string;
 export declare function agentInboxUrl(apiBaseUrl: string, agentUid: string): string;
 export declare function truncateBody(text: string, max?: number): string;
-export declare function defaultFetchInbox(agentUid: string, apiBaseUrl: string): (token: string) => Promise<InboxFetchResult>;
+export declare function defaultFetchInbox(agentUid: string, apiBaseUrl: string): (token: string, signal?: AbortSignal) => Promise<InboxFetchResult>;
 export declare function defaultAckItem(agentUid: string, apiBaseUrl: string): (token: string, id: string) => Promise<number>;
 export declare function pollInboxOnce(deps: InboxDeps): Promise<{
     ok: boolean;

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

@@ -21,10 +21,12 @@ import { vaultApiFetch } from "../../../utils/vault-api.js";
 import { writeComponentStatus } from "../creds.js";
 import { pendingInbox } from "../inbox-state.js";
 import { writePrivateFile } from "./../private-file.js";
+import { createAgentKitInboxBackoffFlagReader } from "../inbox-poll-backoff-flag.js";
 import { buildWakeNotice, currentWakeState, fireWake, readWakeConfig, shouldWake, } from "../wake.js";
 export const SEEN_IDS_NAME = "seen-ids.json";
 export const INBOX_JSONL_NAME = "inbox.jsonl";
 export const MAX_SEEN_IDS = 5000;
+export const INBOX_POLL_BACKOFF_MAX_MS = 30_000;
 /** Pull `{id}` out of each server item; items without a string id are dropped. */
 export function extractInboxItems(body) {
     const rec = body && typeof body === "object" ? body : {};
@@ -107,12 +109,13 @@ export function truncateBody(text, max = INBOX_ERROR_BODY_MAX) {
     return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
 }
 export function defaultFetchInbox(agentUid, apiBaseUrl) {
-    return async (token) => {
+    return async (token, signal) => {
         const url = new URL(agentInboxUrl(apiBaseUrl, agentUid));
         const res = await vaultApiFetch({
             token,
             baseUrl: url.origin,
             path: url.pathname,
+            ...(signal ? { signal } : {}),
         });
         const text = await res.text().catch(() => "");
         let body;
@@ -137,6 +140,8 @@ export function defaultAckItem(agentUid, apiBaseUrl) {
     };
 }
 export async function pollInboxOnce(deps) {
+    if (deps.signal?.aborted)
+        return { ok: false, mirrored: 0 };
     const fetchInbox = deps.fetchInbox ?? defaultFetchInbox(deps.agentUid, deps.apiBaseUrl);
     const ackItem = deps.ackItem ?? defaultAckItem(deps.agentUid, deps.apiBaseUrl);
     // No default cache warm: the human conversation routes 403 for agent callers.
@@ -152,9 +157,11 @@ export async function pollInboxOnce(deps) {
     }
     let res;
     try {
-        res = await fetchInbox(token);
+        res = await fetchInbox(token, deps.signal);
     }
     catch (err) {
+        if (deps.signal?.aborted)
+            return { ok: false, mirrored: 0 };
         writeComponentStatus(deps.paths, "inbox", "error");
         deps.log("error", `inbox fetch failed: GET ${agentInboxUrl(deps.apiBaseUrl, deps.agentUid)}: ${err instanceof Error ? err.message : String(err)}`);
         return { ok: false, mirrored: 0 };
@@ -218,14 +225,46 @@ async function maybeWake(deps, freshCount) {
     }
 }
 export async function runInboxLoop(deps) {
-    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const sleep = deps.sleep ?? ((ms, signal) => new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve();
+        const timer = setTimeout(done, ms);
+        const abort = () => {
+            clearTimeout(timer);
+            done();
+        };
+        function done() {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }
+        signal?.addEventListener("abort", abort, { once: true });
+    }));
+    const readBackoffEnabled = deps.readInboxBackoffEnabled ?? createAgentKitInboxBackoffFlagReader({
+        companySlug: deps.companySlug,
+        getToken: deps.getToken,
+    });
     let polls = 0;
-    for (;;) {
-        await pollInboxOnce(deps);
+    let consecutiveEmptyPolls = 0;
+    while (!deps.signal?.aborted) {
+        const result = await pollInboxOnce(deps);
         polls += 1;
         if (deps.maxPolls !== undefined && polls >= deps.maxPolls)
             return;
-        await sleep(deps.pollMs);
+        if (deps.signal?.aborted)
+            return;
+        if (!result.ok || result.mirrored > 0)
+            consecutiveEmptyPolls = 0;
+        const enabled = await readBackoffEnabled();
+        const delay = enabled && result.ok && result.mirrored === 0 && consecutiveEmptyPolls > 0
+            ? Math.min(deps.pollMs * 2 ** consecutiveEmptyPolls, Math.max(deps.pollMs, INBOX_POLL_BACKOFF_MAX_MS))
+            : deps.pollMs;
+        if (enabled && result.ok && result.mirrored === 0)
+            consecutiveEmptyPolls += 1;
+        else
+            consecutiveEmptyPolls = 0;
+        if (deps.signal?.aborted)
+            return;
+        await sleep(delay, deps.signal);
     }
 }
 //# sourceMappingURL=inbox.js.map

package/dist/lib/agent-kit/run/stop-signals.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from "node:events";
+export declare const KIT_STOP_GRACE_MS = 10000;
+interface KitStopControllerOptions {
+    emitter?: Pick<EventEmitter, "once" | "removeListener">;
+    forceExit?: (code: number) => void;
+    timeoutMs?: number;
+}
+/** Abort service work on stop, with a deadline if an awaited operation stalls. */
+export declare function createKitStopController(options?: KitStopControllerOptions): {
+    signal: AbortSignal;
+    dispose(): void;
+};
+export {};
+//# sourceMappingURL=stop-signals.d.ts.map

package/dist/lib/agent-kit/run/stop-signals.js

@@ -0,0 +1,26 @@
+export const KIT_STOP_GRACE_MS = 10_000;
+/** Abort service work on stop, with a deadline if an awaited operation stalls. */
+export function createKitStopController(options = {}) {
+    const emitter = options.emitter ?? process;
+    const forceExit = options.forceExit ?? ((code) => process.exit(code));
+    const controller = new AbortController();
+    let deadline;
+    const stop = () => {
+        if (controller.signal.aborted)
+            return;
+        controller.abort();
+        deadline = setTimeout(() => forceExit(0), options.timeoutMs ?? KIT_STOP_GRACE_MS);
+    };
+    emitter.once("SIGTERM", stop);
+    emitter.once("SIGINT", stop);
+    return {
+        signal: controller.signal,
+        dispose() {
+            if (deadline)
+                clearTimeout(deadline);
+            emitter.removeListener("SIGTERM", stop);
+            emitter.removeListener("SIGINT", stop);
+        },
+    };
+}
+//# sourceMappingURL=stop-signals.js.map

package/dist/lib/agent-kit/services.d.ts

@@ -14,8 +14,8 @@ export declare function isKitService(value: string): value is KitService;
  * file a loud error instead of a browser-login hang; HQ_AGENT_DIR keeps a
  * relocated kit consistent across restarts.
  */
-export declare function kitServiceEnv(paths: AgentKitPaths): Record<string, string>;
-export declare function kitServiceSpec(service: KitService, paths: AgentKitPaths): ServiceSpec;
+export declare function kitServiceEnv(paths: AgentKitPaths, env?: NodeJS.ProcessEnv): Record<string, string>;
+export declare function kitServiceSpec(service: KitService, paths: AgentKitPaths, env?: NodeJS.ProcessEnv): ServiceSpec;
 /**
  * Services to install. `sync` is included only when the kit is configured to
  * mirror the vault to disk; by default a bot reads files on demand through the

package/dist/lib/agent-kit/services.js

@@ -20,14 +20,16 @@ const DESCRIPTIONS = {
  * file a loud error instead of a browser-login hang; HQ_AGENT_DIR keeps a
  * relocated kit consistent across restarts.
  */
-export function kitServiceEnv(paths) {
+export function kitServiceEnv(paths, env = process.env) {
+    const flagsApiUrl = env.HQ_FLAGS_API_URL;
     return {
         HQ_AGENT_DIR: paths.agentDir,
         HQ_MACHINE_CREDS_FILE: paths.machineCredsPath,
         HQ_REQUIRE_MACHINE_IDENTITY: "1",
+        ...(flagsApiUrl?.trim() ? { HQ_FLAGS_API_URL: flagsApiUrl } : {}),
     };
 }
-export function kitServiceSpec(service, paths) {
+export function kitServiceSpec(service, paths, env = process.env) {
     return {
         name: service,
         label: `${KIT_LABEL_PREFIX}.${service}`,
@@ -35,7 +37,7 @@ export function kitServiceSpec(service, paths) {
         args: ["agent", "kit", "run", service],
         logPath: serviceLogPath(paths, service),
         workingDir: paths.agentDir,
-        env: kitServiceEnv(paths),
+        env: kitServiceEnv(paths, env),
         restartSec: 10,
     };
 }

package/dist/lib/anywhere-runtime-flag-key.d.ts

@@ -1,5 +1,6 @@
 /** hq-flags key for the staged HQ Anywhere runtime. The registry default is on. */
 export declare const HQ_ANYWHERE_RUNTIME_FLAG = "hq-anywhere-runtime";
+export declare const HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER = "hq-anywhere-runtime.revoked";
 /** The HQ Anywhere environment kill switch stays compatible with managed provider wrappers. */
 export declare function hqAnywhereRuntimeLocallyDisabled(env?: NodeJS.ProcessEnv): boolean;
 //# sourceMappingURL=anywhere-runtime-flag-key.d.ts.map

package/dist/lib/anywhere-runtime-flag-key.js

@@ -1,5 +1,6 @@
 /** hq-flags key for the staged HQ Anywhere runtime. The registry default is on. */
 export const HQ_ANYWHERE_RUNTIME_FLAG = "hq-anywhere-runtime";
+export const HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER = "hq-anywhere-runtime.revoked";
 /** The HQ Anywhere environment kill switch stays compatible with managed provider wrappers. */
 export function hqAnywhereRuntimeLocallyDisabled(env = process.env) {
     const value = env.HQ_FLAG_HQ_ANYWHERE_RUNTIME;

package/dist/lib/anywhere-runtime-revocation-marker.d.ts

@@ -0,0 +1,4 @@
+export declare function anywhereRuntimeRevocationMarkerPath(home?: string, env?: NodeJS.ProcessEnv): string;
+/** Keep installed wrappers aligned with the daemon's refreshed access decision. */
+export declare function updateAnywhereRuntimeRevocationMarker(enabled: boolean, home?: string, env?: NodeJS.ProcessEnv): void;
+//# sourceMappingURL=anywhere-runtime-revocation-marker.d.ts.map

package/dist/lib/anywhere-runtime-revocation-marker.js

@@ -0,0 +1,26 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER } from "./anywhere-runtime-flag-key.js";
+import { registryDir } from "./registry/registry.js";
+export function anywhereRuntimeRevocationMarkerPath(home = os.homedir(), env = process.env) {
+    return path.join(registryDir(home, env), HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER);
+}
+/** Keep installed wrappers aligned with the daemon's refreshed access decision. */
+export function updateAnywhereRuntimeRevocationMarker(enabled, home = os.homedir(), env = process.env) {
+    const marker = anywhereRuntimeRevocationMarkerPath(home, env);
+    if (!enabled) {
+        fs.mkdirSync(path.dirname(marker), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(marker, "revoked\n", { mode: 0o600 });
+        fs.chmodSync(marker, 0o600);
+        return;
+    }
+    try {
+        fs.unlinkSync(marker);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+//# sourceMappingURL=anywhere-runtime-revocation-marker.js.map

package/dist/lib/daemon/run.d.ts

@@ -29,6 +29,8 @@ export interface DaemonLockConflictOutcome {
 export declare function daemonLockConflictOutcome(lock: DaemonLockResult, anywhereEnabled: boolean): DaemonLockConflictOutcome | null;
 /** hqd is available on every platform while Anywhere is enabled; its listener fails closed if setup is unsafe. */
 export declare function shouldStartHqd(anywhereEnabled: boolean): boolean;
+/** Resolve the supervisor's runtime-access decision and reflect it in the local wrapper marker. */
+export declare function refreshHqdRuntimeDecision(readDecision: () => Promise<boolean>, home: string, env: NodeJS.ProcessEnv, onMarkerError?: (error: unknown) => void): Promise<boolean>;
 /** Route an updater request through the daemon's existing graceful handoff. */
 export declare function handoffForPackageUpdateRequest(requested: boolean, restartDaemon: () => void): void;
 export interface RunDaemonOptions {

package/dist/lib/daemon/run.js

@@ -30,6 +30,7 @@ import { retireLegacyMeshUnits } from "./migrate.js";
 import { daemonDir as meshDaemonDir, daemonPidPath as meshDaemonPidPath } from "../mesh/live/daemon/paths.js";
 import { readPidLock } from "../mesh/live/daemon/pid-lock.js";
 import { registryDir, registryFile } from "../registry/registry.js";
+import { updateAnywhereRuntimeRevocationMarker } from "../anywhere-runtime-revocation-marker.js";
 import { daemonRootRefusal } from "./install.js";
 import { detectMachineType } from "./machine-type.js";
 import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from "./paths.js";
@@ -93,6 +94,17 @@ export function daemonLockConflictOutcome(lock, anywhereEnabled) {
 export function shouldStartHqd(anywhereEnabled) {
     return anywhereEnabled;
 }
+/** Resolve the supervisor's runtime-access decision and reflect it in the local wrapper marker. */
+export async function refreshHqdRuntimeDecision(readDecision, home, env, onMarkerError = () => { }) {
+    const enabled = await readDecision();
+    try {
+        updateAnywhereRuntimeRevocationMarker(enabled, home, env);
+    }
+    catch (error) {
+        onMarkerError(error);
+    }
+    return enabled;
+}
 /** Route an updater request through the daemon's existing graceful handoff. */
 export function handoffForPackageUpdateRequest(requested, restartDaemon) {
     if (requested)
@@ -897,13 +909,13 @@ export async function runDaemon(opts) {
         onError: (name) => log("warn", `hqd person setting read failed (${name}); keeping the last read value for up to ${HQD_PERSON_SETTING_GRACE_MS / 60_000} minutes`),
     }), { graceMs: HQD_PERSON_SETTING_GRACE_MS });
     const hqdListener = await startHqdRuntimeListener({
-        isEnabled: async () => shouldStartHqd(await anywhereRuntimeAllowed(env, {
+        isEnabled: async () => refreshHqdRuntimeDecision(async () => shouldStartHqd(await anywhereRuntimeAllowed(env, {
             refreshFlag: async () => {
                 const { refreshFlagRegistrySnapshot } = await import("../flag-registry.js");
                 await refreshFlagRegistrySnapshot(5_000);
             },
             readSetting: readPersonSetting,
-        })),
+        })), home, env, () => log("warn", "hqd runtime revocation marker update failed")),
         startServer: async () => {
             const startConfig = readDaemonConfig(paths.configPath);
             return startHqdServer({
@@ -959,8 +971,9 @@ export async function runDaemon(opts) {
                 releaseDaemonLock(paths.lockPath);
                 resolve(exitCode);
                 // Pipes, sockets and unrelated timers can outlive a clean shutdown.
-                // Keep restart and signal exits bounded just like the handoff path.
-                setTimeout(() => process.exit(exitCode), 5_000).unref();
+                // Services and the lock are already stopped; unrelated handles should
+                // not hold a restart or signal exit open for another service interval.
+                setTimeout(() => process.exit(exitCode), 1_000).unref();
             });
         };
         /** Exit for a restart but leave the services running for the next daemon to adopt. */

package/dist/lib/daemon/server.js

@@ -23,6 +23,7 @@ import { defaultMcpToken, HqMcpBridge, jsonResult, McpOpError, runWorker } from
 import { authenticateMachineCredentials, machineTokenExpiresAt, MachineLoginError, parseStdinMachineCredentials } from "./machine-login.js";
 import { HQ_MCP_TOOL_NAMES, HQD_NATIVE_TOOL_NAMES } from "../mcp/tools.js";
 import { HQ_ANYWHERE_RUNTIME_FLAG } from "../../commands/anywhere-runtime-flag.js";
+import { updateAnywhereRuntimeRevocationMarker } from "../anywhere-runtime-revocation-marker.js";
 import { readHqAnywherePersonSetting } from "../anywhere-person-setting.js";
 import { createBoundedDaemonFlagMonitor } from "./flag-monitor.js";
 import { readDaemonFlag } from "./flag.js";
@@ -416,6 +417,12 @@ export async function startHqdServer(opts) {
             return personSetting === true;
         },
         onChange: (enabled) => {
+            try {
+                updateAnywhereRuntimeRevocationMarker(enabled, env.HOME?.trim() || undefined, env);
+            }
+            catch (error) {
+                log("warn", `hqd runtime revocation marker update failed (${error instanceof Error ? error.name : "UnknownError"})`);
+            }
             if (!enabled) {
                 flagRevocationGeneration += 1;
                 ephemeralMachineToken = undefined;

package/dist/lib/db/control-plane.d.ts

@@ -71,7 +71,18 @@ export interface RemoteUsageResponse {
     apps?: RemoteAppUsage[];
 }
 /** Answer for one app: its own numbers, or the company numbers when it shares the company cluster. */
-export type RemoteAppUsageResponse = (RemoteAppUsage & {
+export interface RemoteRemovedAppUsage {
+    companyUid: string;
+    appId: string;
+    mode: "app-cluster" | "company-cluster";
+    status: "detached" | "purged";
+    removedAt: string;
+    retainUntil: string | null;
+    purgedAt: string | null;
+    billed: false;
+    exempt: boolean;
+}
+export type RemoteAppUsageResponse = RemoteRemovedAppUsage | (RemoteAppUsage & {
     companyUid: string;
     mode: "app-cluster";
     status?: string;

package/dist/lib/db/usage-format.d.ts

@@ -1,7 +1,8 @@
-import type { RemoteAppUsage, RemoteAppUsageResponse, RemoteUsageResponse } from "./control-plane.js";
+import type { RemoteAppUsage, RemoteAppUsageResponse, RemoteRemovedAppUsage, RemoteUsageResponse } from "./control-plane.js";
 export declare function formatBytes(bytes: number): string;
 export declare function formatUsage(usage: RemoteUsageResponse): string;
 export declare function formatAppUsage(usage: RemoteAppUsage): string;
+export declare function formatRemovedAppUsage(usage: RemoteRemovedAppUsage): string;
 export declare function formatAppUsageResponse(response: RemoteAppUsageResponse): string;
 export declare function formatCompanyApps(apps: RemoteAppUsage[]): string;
 //# sourceMappingURL=usage-format.d.ts.map

package/dist/lib/db/usage-format.js

@@ -80,7 +80,26 @@ export function formatAppUsage(usage) {
         : `Last measured ${usage.measuredAt}. Numbers can lag by a few minutes.`);
     return lines.join("\n");
 }
+function day(iso) {
+    return iso.slice(0, 10);
+}
+export function formatRemovedAppUsage(usage) {
+    const lines = [`The database for app ${usage.appId} was removed on ${day(usage.removedAt)}.`];
+    if (usage.purgedAt) {
+        lines.push(`Its data was deleted for good on ${day(usage.purgedAt)}.`);
+    }
+    else if (usage.retainUntil) {
+        lines.push(`Its data is kept until ${day(usage.retainUntil)}, then deleted for good.`);
+    }
+    lines.push("It is not billed.");
+    return lines.join("\n");
+}
+function isRemoved(response) {
+    return "status" in response && (response.status === "detached" || response.status === "purged");
+}
 export function formatAppUsageResponse(response) {
+    if (isRemoved(response))
+        return formatRemovedAppUsage(response);
     if (response.mode === "company-cluster") {
         return [
             `App ${response.appId} uses the shared company database, so these are the company numbers.`,

package/dist/lib/install/provider-wrappers.js

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER } from '../anywhere-runtime-flag-key.js';
 const marker = '# hq-anywhere provider sign-in wrapper';
 const PROVIDER_PATH_RC_FILES = ['.bashrc', '.bash_profile', '.zshrc', '.zprofile', '.profile'];
 const wrapperHeader = (provider) => `#!/bin/sh\n${marker}: ${provider}\n`;
@@ -76,6 +77,18 @@ function wrapperSource(provider) {
         `  ${provider === 'claude' ? '/login|auth' : 'login'}) exec "$real" "$@" ;;`,
         'esac',
         '',
+        '# The local marker mirrors registryDir: trim the override and use ~/.hq when empty.',
+        'registry_dir=${HQ_REGISTRY_DIR:-}',
+        "registry_dir=$(printf '%s' \"$registry_dir\" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')",
+        'if [ -z "$registry_dir" ]; then',
+        '  registry_dir=${HOME:-}',
+        '  [ -n "$registry_dir" ] && registry_dir="$registry_dir/.hq"',
+        'fi',
+        'if [ -n "$registry_dir" ]; then',
+        '  case "$registry_dir" in /*) ;; *) registry_dir="$PWD/$registry_dir" ;; esac',
+        `  if [ -e "$registry_dir/${HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER}" ]; then exec "$real" "$@"; fi`,
+        'fi',
+        '',
         'log_dir="$HOME/.hq/logs"',
         'mkdir -p "$log_dir" 2>/dev/null || :',
         'log_file="$log_dir/provider-auth.log"',

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

@@ -60,6 +60,13 @@ export interface LoopResult {
     session_id?: string;
     resumed?: boolean;
     fresh_fallback?: boolean;
+    question_id?: string;
+    decision?: {
+        question_id: string;
+        choice: string;
+        notes?: string;
+        at: string;
+    };
 }
 export interface Section8Handoff {
     schema: typeof PHASE_HANDOFF_SCHEMA;
@@ -103,6 +110,7 @@ export interface LoopRunnerOptions {
         envelopeId: string;
         attempt: number;
         error: string;
+        questionId: string;
     }): Promise<void> | void;
     defaultDeadlineSeconds?: number;
     now?: () => Date;
@@ -120,7 +128,6 @@ interface StoredEnvelope {
     envelope_id: string;
     queued_at: string;
     deadline_budget_seconds?: number;
-    deadline_at_ms?: number;
     envelope: LoopEnvelope;
 }
 /** Validate both hq-cli phase envelopes and the conduct protocol §8 shape. */
@@ -148,6 +155,21 @@ export declare function interruptLoopQueue(runDir: string): {
     withdrawn: string[];
     already_picked_up: string[];
 };
+export declare function interruptLoopQueueForStory(runDir: string, storyId: string, phase?: string): {
+    withdrawn: string[];
+    already_picked_up: string[];
+};
+export declare function applyLoopStallAnswer(input: {
+    runDir: string;
+    questionId: string;
+    choice: string;
+    notes?: string;
+    at: string;
+}): {
+    lane_id: string;
+    envelope_id: string;
+    action: "requeued" | "parked";
+} | undefined;
 export declare function loopStatus(runDir: string, laneId: string): LoopStatus;
 export declare function setLoopControllerPid(runDir: string, laneId: string, pid: number | undefined): void;
 export declare function clearLoopControllerPid(runDir: string, laneId: string, pid: number): void;