@indigoai-us/hq-cli 5.345.57 → 5.345.59

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [5.345.59] — 2026-10-09
+- Keep conduct-mode SessionStart injection out of unattended sessions unless `HQ_AUTO_CONDUCT` explicitly forces it on.
+- Back off the external agent-kit inbox poller from 15 seconds to 30 seconds after repeated empty polls, reset to 15 seconds when a message is mirrored, and stop promptly on SIGTERM or SIGINT with a 10-second deadline for stalled shutdowns. The default-on `agents.inbox-poll-backoff-agent-kit` hq-flags kill switch preserves the regular cadence when disabled; installed services retain a configured `HQ_FLAGS_API_URL`.
+
+- Fix loop-lane recovery: retries receive the fixed per-attempt phase budget; withdrawn and stalled IDs can be reused; `interrupt --story/--phase` targets matching work; and stall answers resume through the controller.
+- `hq db usage --app` says when a deleted app's database was removed, how long its data is kept, and that it is not billed, instead of showing usage and an estimate.
+- `hq db sql --app` and `hq db dump --app` say a deleted app's database was removed, or that the app has no database, instead of "not available yet".
+- `hq billing status` lists database apps: how many are active, the $10 monthly price, overage per app this month, whether the company is exempt, and which subscription carries the charge.
+- Installed Claude and Codex provider wrappers now bypass HQ when the daemon's refreshed runtime flag or person setting is revoked, using a per-user marker under the HQ registry directory.
+- Lane updates preserve completed stories and lead-set states while applying lane progress in order.
+- `hq lanes resume --story` can clear a prior unacknowledged story-switch note.
+
+## [5.345.58] — 2026-10-09
+- hq access now accepts `--as <member>` to view another member's access, read-only.
+
 ## [5.345.57] — 2026-10-09
 - Add `hq lanes create --loop` and `hq lanes enqueue` for persistent worker lanes that process FIFO phase envelopes, return generic results or section 8 handoffs, reuse sessions per story, retry one stall, and park a second stall for the senior. Loop behavior uses the default-on `lanes.conduct-loop` hq-flags kill switch. See `docs/lanes.md` for command output and exit codes.
 

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

@@ -2871,6 +2871,10 @@ export declare const COMMAND_CATALOG: readonly [{
         readonly flags: "--company <slug>";
         readonly description: "Company slug";
         readonly hidden: false;
+    }, {
+        readonly flags: "--as <person-uid>";
+        readonly description: "Check a person's access (exact prs_ or agt_ UID; self or owner/admin)";
+        readonly hidden: false;
     }, {
         readonly flags: "--json";
         readonly description: "Print a single JSON object";
@@ -12931,6 +12935,14 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly flags: "--reason <text>";
             readonly description: "Record the reason in the lane's stop history";
             readonly hidden: false;
+        }, {
+            readonly flags: "--story <id>";
+            readonly description: "Withdraw only this story's queued phases (loop lanes only)";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--phase <name>";
+            readonly description: "Limit --story interruption to one phase";
+            readonly hidden: false;
         }, {
             readonly flags: "--json";
             readonly description: "JSON on stdout (always)";

package/dist/command-catalog.generated.js

@@ -3462,6 +3462,11 @@ export const COMMAND_CATALOG = [
                 "description": "Company slug",
                 "hidden": false
             },
+            {
+                "flags": "--as <person-uid>",
+                "description": "Check a person's access (exact prs_ or agt_ UID; self or owner/admin)",
+                "hidden": false
+            },
             {
                 "flags": "--json",
                 "description": "Print a single JSON object",
@@ -15736,6 +15741,16 @@ export const COMMAND_CATALOG = [
                         "description": "Record the reason in the lane's stop history",
                         "hidden": false
                     },
+                    {
+                        "flags": "--story <id>",
+                        "description": "Withdraw only this story's queued phases (loop lanes only)",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--phase <name>",
+                        "description": "Limit --story interruption to one phase",
+                        "hidden": false
+                    },
                     {
                         "flags": "--json",
                         "description": "JSON on stdout (always)",

package/dist/commands/access.d.ts

@@ -135,6 +135,15 @@ export interface RunAccessResult {
     alreadyAskedAt?: string;
     requestNote?: string;
 }
+export interface AccessAsResult {
+    personUid: string;
+    company: string;
+    path: string;
+    permission: "read" | "write" | "admin" | null;
+    canRead: boolean;
+    roleBypass: boolean;
+    exitCode: 0 | 3;
+}
 export declare function outcomeExitCode(outcome: AccessOutcome): 0 | 2 | 3 | 4;
 export declare function formatAccessOutcome(result: RunAccessResult): string;
 export declare function resolveGrantor(tree: AccessAclTree | null, members: AccessMember[]): AccessGrantor | null;
@@ -149,6 +158,11 @@ export declare function resolveAccessCompany(target: string, opts?: {
     company?: string;
     hqRoot?: string;
 }): string | undefined;
+export declare function runAccessForPerson(rawPath: string, personUid: string, opts?: {
+    company?: string;
+    hqRoot?: string;
+}): Promise<AccessAsResult>;
+export declare function formatAccessForPerson(result: AccessAsResult): string;
 export declare function runAccessForPath(path: string, opts?: {
     company?: string;
     hqRoot?: string;

package/dist/commands/access.js

@@ -20,7 +20,7 @@ import * as readline from "node:readline";
 import { ListObjectsV2Command, } from "@aws-sdk/client-s3";
 import { DEFAULT_HQ_ROOT } from "../utils/cognito-session.js";
 import { getCompanyUid, vaultApiFetch, resolveCallerUid } from "../utils/vault-api.js";
-import { parseCompanySlugFromPath, resolveBrowseSession, makeCompanyPresignFactory, runGet, } from "./files-browse.js";
+import { parseCompanySlugFromPath, classifyAclSource, resolveBrowseSession, makeCompanyPresignFactory, runGet, toBucketRelative, } from "./files-browse.js";
 import { listJournals, syncDoctor, } from "@indigoai-us/hq-cloud";
 import { listActiveMembers } from "./members.js";
 import { buildDmBody } from "./dm.js";
@@ -87,6 +87,10 @@ function normalizeTarget(raw, slug) {
         t = t.slice(anchor.length);
     return t;
 }
+function fileGrantCoversPath(grantPath, targetPath) {
+    return classifyAclSource(targetPath, [grantPath]) !== "role-bypass";
+}
+const FILE_PERMISSION_RANK = { read: 1, write: 2, admin: 3 };
 function httpStatusOf(err) {
     if (!err || typeof err !== "object")
         return undefined;
@@ -637,6 +641,7 @@ export function registerAccessCommand(program) {
         .command("access <path-or-query>")
         .description("Tell whether a vault file exists and whether you can read it. Never a bare not-found. Exit codes: 0 local/not-synced, 2 never-existed, 3 no-access, 4 ambiguous.")
         .option("--company <slug>", "Company slug")
+        .option("--as <person-uid>", "Check a person's access (exact prs_ or agt_ UID; self or owner/admin)")
         .option("--json", "Print a single JSON object")
         .option("--no-fix", "Diagnose only: do not fetch, pin, or repair sync")
         .option("--yes", "Answer the one send-confirmation yes (hosts must pass this explicitly)")
@@ -650,6 +655,12 @@ Exit codes:
 `)
         .action(async (target, opts) => {
         try {
+            if (opts.as) {
+                const result = await runAccessForPerson(target, opts.as, opts);
+                console.log(opts.json ? JSON.stringify(result) : formatAccessForPerson(result));
+                process.exitCode = result.exitCode;
+                return;
+            }
             const result = await runAccessForPath(target, opts);
             process.exitCode = result.exitCode;
         }
@@ -669,6 +680,63 @@ export function resolveAccessCompany(target, opts) {
     const hqRoot = opts?.hqRoot ?? DEFAULT_HQ_ROOT;
     return opts?.company ?? slugFromTarget(target) ?? readActiveCompany(hqRoot);
 }
+export async function runAccessForPerson(rawPath, personUid, opts) {
+    const uid = personUid.trim();
+    if (!/^(?:prs|agt)_[A-Za-z0-9_-]+$/.test(uid)) {
+        throw new Error("Pass the person's exact prs_ or agt_ UID to --as.");
+    }
+    const pathSlug = slugFromTarget(rawPath);
+    if (opts?.company && pathSlug && opts.company !== pathSlug) {
+        throw new Error("The --company value does not match the company in the path.");
+    }
+    const company = resolveAccessCompany(rawPath, opts);
+    if (!company)
+        throw new Error("Pass --company <slug> or an anchored company path.");
+    const relativePath = normalizeTarget(rawPath, company);
+    if (!relativePath || relativePath.split(/[\\/]/).includes("..")) {
+        throw new Error("Pass a company-relative path without parent-directory segments.");
+    }
+    const { token } = await resolveBrowseSession();
+    const companyUid = await getCompanyUid(token, company);
+    const response = await vaultApiFetch({
+        token,
+        path: `/files/${encodeURIComponent(companyUid)}/members/${encodeURIComponent(uid)}/access`,
+        method: "GET",
+    });
+    if (!response.ok) {
+        if (response.status === 403) {
+            throw new Error("Only the person themself or a company owner/admin can check this access.");
+        }
+        if (response.status === 404) {
+            throw new Error("That person is not an active member of this company.");
+        }
+        throw new Error(`Member access check failed (${response.status}).`);
+    }
+    const projection = (await response.json());
+    if (projection.personUid !== uid || !projection.files) {
+        throw new Error("The member access response did not match the requested person.");
+    }
+    const roleBypass = projection.files.roleBypass === true;
+    const grants = Array.isArray(projection.files.grants) ? projection.files.grants : [];
+    const matchingPermissions = grants
+        .filter((grant) => typeof grant.path === "string" && typeof grant.permission === "string" &&
+        grant.permission in FILE_PERMISSION_RANK &&
+        fileGrantCoversPath(toBucketRelative(grant.path, company), relativePath))
+        .map((grant) => grant.permission);
+    const permission = roleBypass ? "admin" : matchingPermissions.reduce((best, candidate) => best === null || FILE_PERMISSION_RANK[candidate] > FILE_PERMISSION_RANK[best] ? candidate : best, null);
+    return {
+        personUid: uid,
+        company,
+        path: `companies/${company}/${relativePath}`,
+        permission,
+        canRead: permission !== null,
+        roleBypass,
+        exitCode: permission === null ? 3 : 0,
+    };
+}
+export function formatAccessForPerson(result) {
+    return `${result.personUid} has ${result.permission ?? "no access"} access to ${result.path}.`;
+}
 export async function runAccessForPath(path, opts) {
     const target = path;
     const hqRoot = opts?.hqRoot ?? DEFAULT_HQ_ROOT;

package/dist/commands/agent-kit.js

@@ -30,6 +30,7 @@ import { isKitService, KIT_SERVICES, enabledKitServices, kitServiceSpec, kitServ
 import { writeKitSkills } from "../lib/agent-kit/skills.js";
 import { runHeartbeatLoop } from "../lib/agent-kit/run/heartbeat.js";
 import { runInboxLoop } from "../lib/agent-kit/run/inbox.js";
+import { createKitStopController } from "../lib/agent-kit/run/stop-signals.js";
 import { superviseKitServices } from "../lib/agent-kit/run/supervisor.js";
 import { fallbackStatus, rebootCrontabLine, ensureRebootCrontab, shouldUseFallback, startFallback, stopFallback, } from "../lib/agent-kit/fallback.js";
 import { serviceLogPath } from "../lib/agent-kit/paths.js";
@@ -182,17 +183,26 @@ export async function runKitService(service, rt) {
                 credsSource: rt.credsSource ?? "default",
             });
             return;
-        case "inbox":
-            await runInboxLoop({
-                paths: rt.paths,
-                agentUid: rt.creds.entityUid,
-                apiBaseUrl: rt.creds.apiBaseUrl,
-                pollMs: rt.config.inboxPollMs,
-                ack: rt.config.inboxAck,
-                getToken: rt.getToken,
-                log: rt.log,
-            });
+        case "inbox": {
+            const stop = createKitStopController();
+            try {
+                await runInboxLoop({
+                    paths: rt.paths,
+                    agentUid: rt.creds.entityUid,
+                    apiBaseUrl: rt.creds.apiBaseUrl,
+                    pollMs: rt.config.inboxPollMs,
+                    ack: rt.config.inboxAck,
+                    getToken: rt.getToken,
+                    log: rt.log,
+                    companySlug: rt.creds.companySlug,
+                    signal: stop.signal,
+                });
+            }
+            finally {
+                stop.dispose();
+            }
             return;
+        }
     }
 }
 /** `kit run all`: supervise the kit services as child processes with restart backoff. */

package/dist/commands/billing.d.ts

@@ -16,5 +16,18 @@
  *                                                         answer such a request
  */
 import { Command } from "commander";
+interface DatabaseBilling {
+    period: string;
+    activeApps: number;
+    pricePerAppCents: number;
+    exempt: boolean;
+    chargedOn: "team" | "dedicated" | "existing" | null;
+    apps: Array<{
+        appId: string;
+        overageCents: number;
+    }>;
+}
+export declare function formatDatabaseBilling(db: DatabaseBilling | null | undefined): string[];
 export declare function registerBillingCommand(program: Command): void;
+export {};
 //# sourceMappingURL=billing.d.ts.map

package/dist/commands/billing.js

@@ -21,6 +21,35 @@ import { vaultApiFetch, getCompanyUid } from "../utils/vault-api.js";
 import { mintPaymentLink } from "../utils/billing-gate.js";
 import { upgradeToTeam } from "../utils/team-upgrade.js";
 import { registerBillingSponsorCommands } from "./billing-sponsor.js";
+const CHARGED_ON = {
+    team: "the Team subscription",
+    dedicated: "the separate HQ database apps subscription",
+    existing: "the company's existing subscription",
+};
+function dollars(cents) {
+    return `$${(cents / 100).toFixed(2)}`;
+}
+export function formatDatabaseBilling(db) {
+    if (db === undefined)
+        return [];
+    if (db === null)
+        return [`${chalk.bold("Database apps")}: could not be read right now`];
+    const lines = [
+        `${chalk.bold("Database apps")}: ${db.activeApps} active, ${dollars(db.pricePerAppCents)} a month each`,
+    ];
+    if (db.exempt) {
+        lines.push("  Not billed: this company is exempt from database app charges.");
+    }
+    else if (db.activeApps > 0) {
+        lines.push(db.chargedOn
+            ? `  Charged on ${CHARGED_ON[db.chargedOn]}.`
+            : "  Not on a subscription yet. The charge is added on the next billing sync.");
+    }
+    for (const app of db.apps) {
+        lines.push(`  ${app.appId}: ${dollars(app.overageCents)} overage so far in ${db.period}`);
+    }
+    return lines;
+}
 function fail(err) {
     console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
     process.exit(1);
@@ -69,6 +98,8 @@ export function registerBillingCommand(program) {
                 console.log(`${chalk.bold("Card")}: ${chalk.yellow("no card on file")} — ` +
                     `run \`hq billing checkout\` to add one before provisioning paid resources.`);
             }
+            for (const line of formatDatabaseBilling(summary.databases))
+                console.log(line);
         }
         catch (err) {
             fail(err);

package/dist/commands/db-dump.js

@@ -8,8 +8,8 @@ import { dumpRemoteSchema, openRemoteAppConnection } from "../lib/db/remote-engi
 import { isPlanGateError } from "../utils/plan-gate-error.js";
 import { defaultRemoteDeps, describeRemoteError, remoteEngineDeps, resolveAppId, } from "./db-remote-deps.js";
 export function describeSessionGap(error) {
-    const status = error.status;
-    if (status === 404 || status === 405) {
+    const { status, code } = error;
+    if ((status === 404 || status === 405) && !code) {
         return "Remote database access for apps is not available yet. The HQ API has no database session route.";
     }
     return null;

package/dist/commands/db-remote-deps.js

@@ -71,6 +71,12 @@ export function describeRemoteError(error) {
     if (status === 404 && code === "DB_USAGE_NOT_PROVISIONED") {
         return "This company has no remote database yet. Run hq db provision first.";
     }
+    if (status === 404 && code === "DB_APP_REMOVED") {
+        return "This app's database was removed, so it can't be opened. Run hq db usage --app <app> to see how long its data is kept.";
+    }
+    if (status === 404 && code === "DB_APP_NOT_FOUND") {
+        return "This app has no database in this company. Check the app name, or deploy it with database enabled.";
+    }
     if (status === 404 && code === "DB_USAGE_APP_NOT_FOUND") {
         return "No database found for that app in this company. Check the app name, or deploy it with database enabled.";
     }

package/dist/commands/lanes-loop.js

@@ -176,12 +176,13 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                     signal.removeEventListener("abort", abortPhase);
                 }
             },
-            raiseQuestion: ({ envelope, envelopeId, attempt, error }) => {
+            raiseQuestion: ({ envelope, envelopeId, attempt, error, questionId }) => {
                 const current = readLane(hqRoot, laneId);
                 const data = envelope;
                 raiseLaneQuestion({
                     hqRoot,
                     lane: current,
+                    questionId,
                     raisedVia: "cli",
                     at: ctx.now().toISOString(),
                     body: {
@@ -189,6 +190,7 @@ export async function runLaneLoopController(ctx, laneId, deps) {
                         context: `${error}\nThe phase is parked; later envelopes remain queued. Stall attempt: ${attempt}.`,
                         options: ["Retry with a longer deadline", "Reroute to another worker", "Drop this phase and block the story"],
                         recommended: "Retry with a longer deadline",
+                        loop_stall: { lane_id: laneId, envelope_id: envelopeId, attempt },
                     },
                 });
             },

package/dist/commands/lanes-questions.js

@@ -1,9 +1,11 @@
+import * as path from "node:path";
 import { buildOutpostQuestionAnswerCommand, buildOutpostQuestionCancelCommand, buildOutpostQuestionShowCommand, dispatchErrorMessage } from "../lib/lanes/outpost-dispatch.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { appendCappedHistory, createQuestion, isLanesError, listSessionLiveness, parseLivenessState, parseQuestionRecord, parseQuestionStatus, readDaemonPresenceConnected, readLane, readQuestion, wakeAnsweredLaneNow, sessionLiveness, appendDropboxMessage, answerDropboxMessage, laneAcceptsDropboxDelivery, laneIdForAnswerDelivery, writeQuestionBody } from "../lib/lanes/index.js";
 import { resolveQuestionCompanyWithFallback } from "../lib/lanes/questions.js";
 import { LanesError } from "../lib/lanes/errors.js";
+import { applyLoopStallAnswer } from "../lib/lanes/loop.js";
 export function resolveAnswerChoice(choice, options, freeform) {
     const trimmed = choice.trim();
     if (/^[0-9]+$/.test(trimmed)) {
@@ -854,6 +856,20 @@ export function createLaneQuestionsHandlers(deps) {
                 },
             };
         });
+        if (body.loop_stall?.lane_id === askingLane.lane_id && askingLane.loop_mode === true) {
+            const resolved = applyLoopStallAnswer({
+                runDir: path.join(hqRoot, "workspace", "lanes-runs", askingLane.lane_id),
+                questionId,
+                choice,
+                ...(opts.notes ? { notes: opts.notes } : {}),
+                at,
+            });
+            if (!resolved)
+                throw new LanesError("loop_stall_result_missing", `Loop stall result for question ${questionId} is missing`, { question_id: questionId, lane_id: askingLane.lane_id });
+            const controllerPid = await deps.restartLoopController(ctx, askingLane.lane_id);
+            printJson({ ok: true, action: "questions.answer", lane_id: askingLane.lane_id, question: updated, loop_action: resolved.action, controller_pid: controllerPid });
+            return;
+        }
         const latestAskingLane = readLane(hqRoot, askingLane.lane_id);
         if (latestAskingLane.state === "awaiting_input") {
             let wake;

package/dist/commands/lanes-session-start.js

@@ -16,6 +16,18 @@ function enabledFromSettings(root) {
     const value = /^\s+default_enabled:\s*["']?(true|false|yes|no|on|off|1|0)["']?\s*(?:#.*)?$/mi.exec(block)?.[1]?.toLowerCase();
     return value === "true" || value === "yes" || value === "on" || value === "1";
 }
+function isUnattended(env) {
+    const flags = `${env.HQ_UNATTENDED ?? ""}${env.HQ_SESSION_UNATTENDED ?? ""}${env.CLAUDE_HEADLESS ?? ""}`;
+    if (["1", "true", "TRUE", "yes", "YES", "on", "ON"].some((marker) => flags.includes(marker)))
+        return true;
+    return [
+        env.HQ_BOT_AGENT_UID,
+        env.HQ_MACHINE_CREDS_FILE,
+        env.HQ_AGENT_CLAUDE_TASKFILE,
+        env.HQ_AGENT_COMPANY_DIR,
+        env.HQ_AGENT_STATUS_FILE,
+    ].some((marker) => Boolean(marker));
+}
 function sessionWasDisabled(root, env, payloadSessionId) {
     const sessionId = payloadSessionId || env.HQ_SESSION_ID;
     if (!sessionId || !/^[A-Za-z0-9_-]+$/.test(sessionId))
@@ -169,11 +181,15 @@ export async function runLaneSessionStart(options = {}) {
         (options.startSweep ?? ((r, e) => startSessionStartOrphanSweep(r, e, spawn)))(root, env);
         if (sessionWasDisabled(root, env, payloadSessionId))
             return;
+        const autoConduct = env.HQ_AUTO_CONDUCT ?? "";
+        const forceOn = /^(1|true|on|yes)$/i.test(autoConduct);
+        if (/^(0|false|off|no)$/i.test(autoConduct))
+            return;
+        if (!forceOn && isUnattended(env))
+            return;
         let enabled = enabledFromSettings(root);
-        if (/^(1|true|on|yes)$/i.test(env.HQ_AUTO_CONDUCT ?? ""))
+        if (forceOn)
             enabled = true;
-        else if (/^(0|false|off|no)$/i.test(env.HQ_AUTO_CONDUCT ?? ""))
-            enabled = false;
         if (!enabled)
             return;
         const core = path.join(root, ".claude", "skills", "conduct", "conductor-core.md");

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

@@ -474,6 +474,7 @@ export interface LaneQuestionsHandlerDeps {
     printJson(value: unknown): void;
     readSessionMeta(hqRoot: string, sessionId: string, ctx: Ctx): Record<string, unknown> | null;
     reconcileHostFromCtx(ctx: Ctx): ReconcileHost;
+    restartLoopController(ctx: Ctx, laneId: string): Promise<number>;
     resolveActiveQuestionCompany(ctx: Ctx, message?: string): Promise<LaneCompanyRef>;
     resolveAudience(hqRoot: string, question: QuestionRecord, ctx: Ctx): SeniorRef;
     sameQuestionAnswer(left: QuestionAnswer | undefined, right: QuestionAnswer): boolean;

package/dist/commands/lanes.d.ts

@@ -7,7 +7,7 @@
  */
 import { Command } from "commander";
 import type { MonitorLaneMessagePayload, MonitorLaneMessageResult } from "./lanes-message.js";
-import { type LanesMesh, type OutpostRouteIdentity, type SpawnLoginResult } from "./lanes-shared.js";
+import { type Ctx, type LanesMesh, type OutpostRouteIdentity, type SpawnLoginResult } from "./lanes-shared.js";
 export type { LanesMesh, SpawnLoginResult } 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";
@@ -36,6 +36,8 @@ export interface LanesCommandDeps {
     onLaneWorkerStarted?: (laneId: string, command: "message" | "resume") => void;
     /** Test seam for failures after a message is durably queued. */
     onLaneMessageQueued?: (laneId: string, path: "admission" | "account_move" | "quota_hold") => void;
+    /** Test seam for routing loop stall answers back through their controller. */
+    restartLoopController?: (ctx: Ctx, laneId: string) => Promise<number>;
     hqRoot?: () => string;
     /** Start HQ-root walk here instead of process.cwd(). Tests only. */
     cwd?: () => string;

package/dist/commands/lanes.js

@@ -43,7 +43,7 @@ import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFoc
 import { appendLaneFocusOverride, assertFocusGuardAllows, makeFocusOverride } from "../lib/lanes/focus-guard.js";
 import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_STATUS_ROW_FIELDS_FLAG, LANE_REAP_STOP_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, LANE_WORKER_CONTINUITY_FLAG, LANE_CONDUCT_LOOP_FLAG, } from "../lib/lanes/flag-keys.js";
 import { findWorkerContinuityLane, sameLaneHost, workerContinuityPrompt } from "../lib/lanes/worker-continuity.js";
-import { enqueueLoopEnvelope, interruptLoopQueue, loopControllerIsAlive, loopStatus, validateLoopEnvelope } from "../lib/lanes/loop.js";
+import { enqueueLoopEnvelope, interruptLoopQueue, interruptLoopQueueForStory, loopControllerIsAlive, loopStatus, validateLoopEnvelope } from "../lib/lanes/loop.js";
 import { runLaneLoopController, startLaneLoopController } from "./lanes-loop.js";
 import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
@@ -580,6 +580,13 @@ export function parseQuestionBody(raw) {
         return null;
     if (obj.notes !== undefined && typeof obj.notes !== "string")
         return null;
+    if (obj.loop_stall !== undefined && (typeof obj.loop_stall !== "object" || obj.loop_stall === null || Array.isArray(obj.loop_stall) ||
+        typeof obj.loop_stall.lane_id !== "string" ||
+        typeof obj.loop_stall.envelope_id !== "string" ||
+        typeof obj.loop_stall.attempt !== "number" ||
+        !Number.isSafeInteger(obj.loop_stall.attempt) ||
+        obj.loop_stall.attempt < 1))
+        return null;
     const options = obj.options.filter((item) => typeof item === "string");
     const body = {
         question: obj.question,
@@ -590,6 +597,8 @@ export function parseQuestionBody(raw) {
         body.recommended = obj.recommended;
     if (typeof obj.notes === "string")
         body.notes = obj.notes;
+    if (obj.loop_stall !== undefined)
+        body.loop_stall = obj.loop_stall;
     return body;
 }
 function readQuestionBodyFile(hqRoot, question) {
@@ -8614,6 +8623,29 @@ async function runInterrupt(ctx, laneId, reason, options = {}) {
         throw new LanesError("interrupt_remote_unsupported", `Lane ${laneId} runs on Outpost ${lane.host.id}; run hq lanes interrupt on that Outpost`, { lane_id: laneId, outpost_id: lane.host.id });
     }
     assertLaneRunsHereForOperatorMutation(ctx, lane, "interrupt");
+    if (options.story !== undefined && lane.loop_mode !== true) {
+        throw new LanesError("usage_error", "--story is only supported for loop lanes", { lane_id: laneId });
+    }
+    if (options.phase !== undefined && options.story === undefined) {
+        throw new LanesError("usage_error", "--phase requires --story", { lane_id: laneId });
+    }
+    if (lane.loop_mode === true && options.story !== undefined) {
+        const scoped = interruptLoopQueueForStory(runDir(hqRoot, lane.lane_id), options.story, options.phase);
+        if (scoped.already_picked_up.length === 0 || lane.state !== "running") {
+            if (!options.quiet)
+                printJson({ ok: true, action: "interrupt", lane_id: lane.lane_id, terminal: false, resumable: true, ...scoped });
+            return;
+        }
+        options = { ...options, preserveLoopQueue: true };
+        // The matching active phase uses the same provider interruption path as a deadline abort.
+        if (!reason)
+            reason = "story-scoped loop phase interrupt";
+        const remaining = scoped;
+        await runInterrupt(ctx, laneId, reason, { preserveLoopQueue: true, quiet: true });
+        if (!options.quiet)
+            printJson({ ok: true, action: "interrupt", lane_id: lane.lane_id, terminal: false, resumable: true, ...remaining });
+        return;
+    }
     const queueInterrupt = lane.loop_mode === true && options.preserveLoopQueue !== true
         ? interruptLoopQueue(runDir(hqRoot, lane.lane_id))
         : undefined;
@@ -9390,6 +9422,22 @@ export function registerLanesCommand(parent, deps = {}) {
         printJson,
         readSessionMeta,
         reconcileHostFromCtx,
+        restartLoopController: async (handlerCtx, laneId) => {
+            if (deps.restartLoopController)
+                return deps.restartLoopController(handlerCtx, laneId);
+            const current = readLane(handlerCtx.hqRoot(), laneId);
+            if (current.state === "running") {
+                await runInterrupt(handlerCtx, laneId, "loop stall question answered; restarting controller", { preserveLoopQueue: true, quiet: true });
+            }
+            const runDirPath = runDir(handlerCtx.hqRoot(), laneId);
+            if (loopControllerIsAlive(runDirPath)) {
+                const pid = loopStatus(runDirPath, laneId).pid;
+                if (pid === undefined)
+                    throw new LanesError("loop_controller_pid_missing", `Loop controller for ${laneId} is alive without a recorded pid`, { lane_id: laneId });
+                return pid;
+            }
+            return startLaneLoopController(handlerCtx, laneId);
+        },
         resolveActiveQuestionCompany,
         resolveAudience,
         sameQuestionAnswer,
@@ -10034,8 +10082,10 @@ export function registerLanesCommand(parent, deps = {}) {
         .description("Stop a running lane's turn and keep it resumable with hq lanes resume")
         .argument("<lane-id>", "Lane id")
         .option("--reason <text>", "Record the reason in the lane's stop history")
+        .option("--story <id>", "Withdraw only this story's queued phases (loop lanes only)")
+        .option("--phase <name>", "Limit --story interruption to one phase")
         .action(wrap(async (laneId, options) => {
-        await runInterrupt(ctx, laneId, options.reason);
+        await runInterrupt(ctx, laneId, options.reason, options);
     }));
     lanes
         .command("approve")

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

@@ -0,0 +1,19 @@
+import { type FlagClient, type FlagClientOptions } from "@indigoai-us/hq-flags-client";
+export declare const AGENT_KIT_INBOX_BACKOFF_FLAG = "agents.inbox-poll-backoff-agent-kit";
+export declare const AGENT_KIT_INBOX_BACKOFF_DEFAULT = true;
+export declare const AGENT_KIT_INBOX_BACKOFF_CACHE_MS: number;
+export declare const AGENT_KIT_INBOX_BACKOFF_TIMEOUT_MS = 2000;
+type InboxBackoffFlagClient = Pick<FlagClient, "ready" | "isEnabled" | "close">;
+export interface AgentKitInboxBackoffFlagDependencies {
+    companySlug?: string;
+    getToken: FlagClientOptions["getToken"];
+    createClient?: (options: FlagClientOptions) => InboxBackoffFlagClient;
+    endpoint?: string;
+    fetch?: typeof fetch;
+    now?: () => number;
+    reportFailure?: (error: unknown) => void;
+}
+/** Read the default-on kill switch; registry outages preserve idle backoff. */
+export declare function createAgentKitInboxBackoffFlagReader(dependencies: AgentKitInboxBackoffFlagDependencies): () => Promise<boolean>;
+export {};
+//# sourceMappingURL=inbox-poll-backoff-flag.d.ts.map