@indigoai-us/hq-cli 5.311.4 → 5.312.1

package/dist/commands/daemon.js

@@ -474,6 +474,18 @@ async function runDaemonSyncNow(d, opts) {
     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 runDaemonSyncInstantSyncSet(d, enabled, opts) {
+    const host = currentHost(d);
+    const config = readDaemonConfig(host.paths.configPath);
+    const changed = config.instantSyncEnabled !== enabled;
+    if (changed)
+        writeDaemonConfig(host.paths.configPath, { ...config, instantSyncEnabled: enabled });
+    const daemonRunning = runningDaemonPid(host.paths.lockPath, d.daemonAlive) !== null;
+    if (changed && daemonRunning)
+        queueDaemonSyncControl(d, { action: "restart-daemon" });
+    const result = { instantSyncEnabled: enabled, persisted: true, daemonRestartRequested: changed && daemonRunning };
+    d.out(opts.json ? JSON.stringify(result, null, 2) : `Instant Sync ${enabled ? "enabled" : "disabled"}${daemonRunning ? "; asked the daemon to restart" : "; saved for the next daemon start"}.`);
+}
 async function runDaemonSyncPause(d, paused, opts) {
     const host = currentHost(d);
     const config = readDaemonConfig(host.paths.configPath);
@@ -772,6 +784,16 @@ export function registerDaemonCommand(program, over = {}) {
         .description("Start a fresh sync pass immediately")
         .option("--json", "Print machine-readable JSON")
         .action(wrap((d, opts) => runDaemonSyncNow(d, opts)));
+    const instantSync = sync.command("instant-sync").description("Control daemon Instant Sync");
+    instantSync
+        .command("set <state>")
+        .description("Set whether daemon sync uses Instant Sync")
+        .option("--json", "Print machine-readable JSON")
+        .action(wrap((d, state, opts) => {
+        if (state !== "on" && state !== "off")
+            throw new DaemonCommandError("Use on or off for Instant Sync.");
+        return runDaemonSyncInstantSyncSet(d, state === "on", opts);
+    }));
     sync
         .command("pause")
         .description("Pause daemon sync until resumed")

package/dist/commands/dm.js

@@ -872,7 +872,12 @@ export function formatChannelMessage(m, nowMs, opts = {}) {
     const id = opts.showEventId ? (m.eventId ?? m.messageId) : undefined;
     const idPart = id ? `  ${chalk.dim(id)}` : "";
     const bodyIndent = `${indent}    `;
-    return `${indent}${who} ${when}${idPart}\n${bodyIndent}${firstLine(m.body)}${formatAttachments(m, bodyIndent)}`;
+    const body = firstLine(m.body);
+    const readableBody = body ||
+        (senderLabel(m).toLowerCase() === "hq"
+            ? "System notification (no text provided)."
+            : "(no message text)");
+    return `${indent}${who} ${when}${idPart}\n${bodyIndent}${readableBody}${formatAttachments(m, bodyIndent)}`;
 }
 /**
  * Read the caller's person/agent uid and email from a JWT we already hold.
@@ -1227,26 +1232,27 @@ async function runDmThread(identifier, opts) {
  * `hq channels`). Throws a user-facing message when nothing matches or a name is
  * ambiguous.
  */
-async function resolveChannelId(token, target) {
+async function resolveChannel(token, target) {
     const raw = target.trim().replace(/^#/, "");
     if (!raw)
         throw new Error("A channel name or id is required.");
     const channels = await fetchChannels(token);
     const named = matchChannelsByName(channels, raw);
     if (named.length === 1)
-        return named[0].channelId;
+        return named[0];
     if (named.length > 1) {
         throw new Error(`'${raw}' matches ${named.length} channels — pass the channel id instead (see \`hq channels\`).`);
     }
     const byId = channels.find((c) => c.channelId === raw);
     if (byId)
-        return byId.channelId;
+        return byId;
     throw new Error(`No channel named or with id '${raw}' — run \`hq channels\` to see yours.`);
 }
 async function runDmChannel(target, opts) {
     try {
         const token = await ensureCognitoToken();
-        const channelId = await resolveChannelId(token, target);
+        const channel = await resolveChannel(token, target);
+        const channelId = channel.channelId;
         const query = {};
         if (opts.limit)
             query.limit = opts.limit;
@@ -1268,7 +1274,17 @@ async function runDmChannel(target, opts) {
             console.log(JSON.stringify(ordered, null, 2));
         }
         else if (ordered.length === 0) {
-            console.log(chalk.dim("No messages in this channel yet."));
+            const channelType = channel.scope === "personal"
+                ? "personal"
+                : channel.scope === "group"
+                    ? "group"
+                    : "shared";
+            const channelName = channel.name?.trim() || channel.slug?.trim() || channelId;
+            const requestedTarget = target.trim().replace(/^#/, "");
+            const sendTarget = requestedTarget === channelId
+                ? channelId
+                : channel.slug?.trim() || requestedTarget;
+            console.log(chalk.dim(`No messages in ${channelType} channel "${channelName}" yet.\nSend a message with: hq dm ${sendTarget} "Hello"`));
         }
         else {
             console.log(chalk.green(`${ordered.length} message${ordered.length === 1 ? "" : "s"}:`));

package/dist/commands/files-browse.js

@@ -63,6 +63,11 @@ export function parseCompanySlugFromPath(prefix) {
     }
     return parts[1];
 }
+// Normalize personal paths before using them as S3 list prefixes.
+function normalizePersonalBrowsePrefix(pathPrefix) {
+    const normalized = pathPrefix.replace(/^\/+/, "");
+    return /^[/.]+$/.test(normalized) ? "" : normalized;
+}
 /**
  * Translate a CLI `companies/<slug>/…` path into the company-relative S3 key
  * the vault bucket actually stores. Company vault buckets are already
@@ -277,10 +282,17 @@ export async function runBrowse(input) {
     }
     // Company vault keys are company-relative (no `companies/<slug>/` prefix), so
     // translate the CLI's anchored prefix into the bucket-relative form before
-    // listing. Personal-mode paths are already bucket-relative.
-    const listPrefix = personalMode || slug === undefined
-        ? pathPrefix
-        : toBucketRelative(pathPrefix, slug);
+    // listing. Personal-mode paths are normalized in bucket-relative form.
+    const bucketPrefix = personalMode
+        ? normalizePersonalBrowsePrefix(pathPrefix)
+        : slug === undefined
+            ? pathPrefix
+            : toBucketRelative(pathPrefix, slug);
+    // Company callers can spell the bucket root as `/` or `.`. S3's empty
+    // Prefix is the root; passing either literal would list under that key.
+    const listPrefix = !personalMode && (bucketPrefix === "/" || bucketPrefix === ".")
+        ? ""
+        : bucketPrefix;
     // Pull the caller's explicit-grant graph once so per-key classification is
     // O(grants) without N round-trips. Retain the raw pattern after stripping
     // only the redundant company anchor: `foo/` and `foo/*` have different

package/dist/commands/lanes-message.js

@@ -220,9 +220,23 @@ export function createLaneMessageHandlers(deps) {
             storySwitchDeliveryStarted = true;
             opts.onAccepted?.();
         };
+        if (opts.text !== undefined && opts.textFile !== undefined) {
+            throw new LanesError("message_text_source_conflict", "Pass either --text or --text-file, not both", { lane_id: laneId });
+        }
         let text = opts.text;
-        if (!text) {
-            throw new LanesError("missing_text", "--text is required", {});
+        if (opts.textFile !== undefined) {
+            const textPath = path.isAbsolute(opts.textFile)
+                ? opts.textFile
+                : path.resolve(ctx.callerCwd(), opts.textFile);
+            try {
+                text = ctx.readFileSync(textPath, "utf8");
+            }
+            catch (err) {
+                throw new LanesError("message_text_file_unreadable", `Could not read message text file ${opts.textFile}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: laneId, path: textPath });
+            }
+        }
+        if (text === undefined || text.length === 0) {
+            throw new LanesError("missing_text", "Pass non-empty message text with --text or --text-file", { lane_id: laneId });
         }
         let resolution;
         try {
@@ -261,6 +275,7 @@ export function createLaneMessageHandlers(deps) {
                 : undefined;
             await dispatchOutpostLaneCommand(ctx, lane, "message", {
                 ...opts,
+                text,
                 ...(supersededMessageCallerId === undefined ? {} : { supersededMessageCallerId }),
                 ...(supersededMessageSessionId === undefined ? {} : { supersededMessageSessionId }),
             }, {

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

@@ -35,6 +35,7 @@ export interface ResumeProfileRepinAuthorization {
 }
 export interface LaneMessageOptions {
     text?: string;
+    textFile?: string;
     project?: string;
     story?: string;
     compact?: boolean;

package/dist/commands/lanes.js

@@ -33,6 +33,7 @@ import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
+import { LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG } from "../lib/lanes/flag-keys.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
 import { syncOutpostLeadRegistries } from "../lib/lanes/autopilot-registry.js";
@@ -1197,14 +1198,20 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
         throw new LanesError("outpost_lane_list_unavailable", `Could not read lanes from Outpost ${outpostId}: ${message}`, { outpost_id: outpostId });
     }
     if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
-        throw new LanesError("outpost_lane_list_unavailable", `Outpost ${outpostId} did not return a successful lane list`, { outpost_id: outpostId, status: result.status, done: result.done ?? false, exit_code: result.exitCode });
+        throw new LanesError("outpost_lane_list_unavailable", `Outpost ${outpostId} did not return a successful lane list`, {
+            outpost_id: outpostId,
+            command_id: result.commandId,
+            status: result.status,
+            done: result.done ?? false,
+            exit_code: result.exitCode,
+        });
     }
     let body;
     try {
         body = JSON.parse(result.stdout);
     }
     catch (err) {
-        throw new LanesError("outpost_lane_list_invalid", `Outpost ${outpostId} returned invalid lane-list JSON: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId });
+        throw new LanesError("outpost_lane_list_invalid", `Outpost ${outpostId} returned invalid lane-list JSON: ${dispatchErrorMessage(err)}`, { outpost_id: outpostId, command_id: result.commandId });
     }
     if (body === null || typeof body !== "object" || Array.isArray(body) ||
         body.ok !== true ||
@@ -1212,6 +1219,7 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
         !Array.isArray(body.lanes)) {
         throw new LanesError("outpost_lane_list_invalid", `Outpost ${outpostId} returned a malformed lane list`, {
             outpost_id: outpostId,
+            command_id: result.commandId,
         });
     }
     const listed = body.lanes;
@@ -1499,7 +1507,12 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     }
     const separator = laneId.lastIndexOf("_");
     const hostSuffix = separator < 0 ? "" : laneId.slice(separator + 1);
-    if (!hostSuffix || sanitizeHostComponent(hostSuffix) !== hostSuffix) {
+    const ownerCompany = !hostSuffix && requestedUlid !== undefined && options.allowHostlessOwnerLookup
+        ? await options.allowHostlessOwnerLookup()
+        : undefined;
+    const hostlessUlidLookup = ownerCompany !== undefined;
+    if ((!hostSuffix && !hostlessUlidLookup) ||
+        (hostSuffix && sanitizeHostComponent(hostSuffix) !== hostSuffix)) {
         throw commandLaneNotFound(laneId, options.outpostHint === true);
     }
     let rawOutpostRoutes;
@@ -1542,7 +1555,9 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     if (requestedOutpostId !== undefined && !outpostIds.includes(requestedOutpostId)) {
         throw new LanesError("outpost_not_registered", `Outpost ${requestedOutpostId} is not registered`, { lane_id: laneId, outpost_id: requestedOutpostId });
     }
-    const hostRoutes = outpostRoutes.filter((route) => outpostRouteMatchesHost(route, hostSuffix));
+    const hostRoutes = hostlessUlidLookup
+        ? []
+        : outpostRoutes.filter((route) => outpostRouteMatchesHost(route, hostSuffix));
     const identity = ctx.readOutpostIdentity();
     const localHostRoutes = outpostRoutes.filter((route) => outpostRouteMatchesHost(route, ctx.hostname()));
     if (localHostRoutes.length > 1 || (identity.kind === "id" && localHostRoutes.some((route) => route.outpostId !== identity.id))) {
@@ -1553,20 +1568,22 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
     const hostOutpostIdSet = new Set(hostOutpostIds);
     const matches = [];
     const failedOutpostIds = [];
+    const failedOutpostCommands = [];
     const probedOutpostIds = [];
     const lookupOutpostIds = requestedOutpostId !== undefined
         ? [requestedOutpostId]
-        : [
-            ...hostOutpostIds.filter((id) => id !== localOutpostId),
-            ...outpostIds.filter((id) => id !== localOutpostId && !hostOutpostIdSet.has(id)),
-        ];
+        : hostlessUlidLookup
+            ? outpostIds.filter((id) => id !== localOutpostId)
+            : [
+                ...hostOutpostIds.filter((id) => id !== localOutpostId),
+                ...outpostIds.filter((id) => id !== localOutpostId && !hostOutpostIdSet.has(id)),
+            ];
     for (const outpostId of lookupOutpostIds) {
         let ownerLanes;
         try {
-            ownerLanes = await readOutpostLaneRecords(ctx, outpostId, {
-                hierarchy: [laneId],
-                snapshot: true,
-            });
+            ownerLanes = await readOutpostLaneRecords(ctx, outpostId, hostlessUlidLookup
+                ? { snapshot: true }
+                : { hierarchy: [laneId], snapshot: true });
             probedOutpostIds.push(outpostId);
         }
         catch (err) {
@@ -1575,16 +1592,38 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
             if (isLanesError(err) && err.error === "outpost_wait_invalid")
                 throw err;
             failedOutpostIds.push(outpostId);
+            failedOutpostCommands.push({
+                outpost_id: outpostId,
+                ...(isLanesError(err) && typeof err.details.command_id === "string"
+                    ? { command_id: err.details.command_id }
+                    : {}),
+            });
             continue;
         }
         for (const lane of ownerLanes) {
-            if (lane.lane_id === laneId &&
-                lane.host.kind === "local" &&
-                sanitizeHostComponent(lane.host.id) === hostSuffix) {
+            const recordedSuffix = lane.lane_id.slice(lane.lane_id.lastIndexOf("_") + 1);
+            const laneCompany = hostlessUlidLookup
+                ? resolveLaneCompany(ctx.hqRoot(), lane).company
+                : undefined;
+            const companyMatches = !hostlessUlidLookup || (ownerCompany !== undefined &&
+                laneCompany?.uid === ownerCompany.uid &&
+                laneCompany.slug === ownerCompany.slug);
+            if (lane.host.kind === "local" && ((!hostlessUlidLookup && lane.lane_id === laneId &&
+                sanitizeHostComponent(lane.host.id) === hostSuffix) ||
+                (hostlessUlidLookup && laneUlidPart(lane.lane_id) === requestedUlid &&
+                    sanitizeHostComponent(lane.host.id) === recordedSuffix &&
+                    companyMatches))) {
                 matches.push({ outpostId, lane });
             }
         }
     }
+    if (hostlessUlidLookup && failedOutpostIds.length > 0) {
+        throw new LanesError("lane_owner_lookup_unavailable", `Could not verify whether lane ${laneId} is registered on every Outpost`, {
+            lane_id: laneId,
+            failed_outpost_ids: failedOutpostIds,
+            remote_commands: failedOutpostCommands,
+        });
+    }
     if (matches.length === 0) {
         throw commandLaneNotFound(laneId, options.outpostHint === true, {
             ...(failedOutpostIds.length > 0 ? { failed_outpost_ids: failedOutpostIds } : {}),
@@ -1604,9 +1643,9 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
 }
 function laneUlidPart(laneId) {
     const separator = laneId.indexOf("_");
-    if (separator !== 26)
+    if (separator !== -1 && separator !== 26)
         return undefined;
-    const ulid = laneId.slice(0, separator);
+    const ulid = separator === -1 ? laneId : laneId.slice(0, separator);
     return /^[0-9A-HJKMNP-TV-Z]{26}$/i.test(ulid) ? ulid.toUpperCase() : undefined;
 }
 function commandLaneNotFound(laneId, outpostHint, details = {}) {
@@ -7660,7 +7699,7 @@ function writeAnswerDeliveryFailed(hqRoot, laneId, questionId, err, at) {
 async function runReconcile(ctx, opts, recoverQueuedMessages) {
     const fromEnv = ctx.env.HQ_ROOT?.trim();
     const hqRoot = fromEnv && ctx.existsSync(fromEnv) ? fromEnv : ctx.hqRoot();
-    const mirrorRefresh = opts.dryRun
+    const mirrorRefresh = opts.dryRun || opts.terminalKeepAliveCandidate
         ? {
             updated: new Map(),
             unverifiedRemote: new Map(),
@@ -7724,6 +7763,9 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
         recoverQueuedMessages,
         mesh: ctx.mesh,
         env: ctx.env,
+        ...(opts.terminalKeepAliveCandidate !== undefined
+            ? { terminalKeepAliveCandidate: opts.terminalKeepAliveCandidate }
+            : {}),
         prepareKeepAliveClaudeResume: async (lane) => {
             const recoveredLane = laneWithRecoveredProviderSession(hqRoot, lane);
             const pendingModel = recoveredLane.pending_settings?.model;
@@ -8041,7 +8083,16 @@ export function registerLanesCommand(parent, deps = {}) {
         persistClaudeAccountSelection,
         printJson,
         recordResumeSetup,
-        resolveCommandLane: (commandCtx, laneId) => resolveCommandLaneTarget(commandCtx, laneId),
+        resolveCommandLane: (commandCtx, laneId) => resolveCommandLaneTarget(commandCtx, laneId, {
+            allowHostlessOwnerLookup: async () => {
+                const company = await commandCtx.resolveCompany();
+                const enabled = await readLanesRegistryFlag(LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, {
+                    company,
+                    env: commandCtx.env,
+                });
+                return enabled ? company : undefined;
+            },
+        }),
         resolveActiveQuestionCompany,
         hasPendingQuestionForLane: questionHandlers.hasPendingQuestionForLane,
         cancelFallbackQuestionsForLane: questionHandlers.cancelFallbackQuestionsForLane,
@@ -8406,7 +8457,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .command("message")
         .description("Send a follow-up message to a lane")
         .argument("<lane-id>", "Lane id")
-        .requiredOption("--text <msg>", "Message text")
+        .option("--text <msg>", "Message text")
+        .option("--text-file <path>", "Read message text from a file")
         .option("--project <slug>", "Re-point project attribution; a changed story is named in the resumed prompt")
         .option("--story <id>", "Re-point story attribution; a changed story is named in the resumed prompt")
         .option("--account <id>", "Move the lane's session to this account of its provider before the message resumes it")
@@ -8745,6 +8797,30 @@ export function registerLanesCommand(parent, deps = {}) {
             await messageHandlers.recoverQueuedMessages(ctx, lane.lane_id);
         });
     }));
+    lanes
+        .command("_keep-alive-terminal-trigger <laneId> <version> <dueAt>", { hidden: true })
+        .action(wrap(async (laneId, versionText, dueAt) => {
+        const version = Number.parseInt(versionText, 10);
+        if (!Number.isSafeInteger(version) || version < 1 || String(version) !== versionText) {
+            throw new LanesError("invalid_lane_version", "Terminal keep-alive trigger requires a positive lane version", {
+                lane_id: laneId,
+                version: versionText,
+            });
+        }
+        const dueAtMs = Date.parse(dueAt);
+        if (!Number.isFinite(dueAtMs)) {
+            throw new LanesError("invalid_terminal_trigger_time", "Terminal keep-alive trigger requires a valid due time", {
+                lane_id: laneId,
+                due_at: dueAt,
+            });
+        }
+        const delayMs = dueAtMs - Date.now();
+        if (delayMs > 0)
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        await runReconcile(ctx, { terminalKeepAliveCandidate: { laneId, version } }, async (lane) => {
+            await messageHandlers.recoverQueuedMessages(ctx, lane.lane_id);
+        });
+    }));
     reconcile
         .command("install")
         .description("Write systemd user unit and timer files (idempotent)")

package/dist/commands/vault-retention-flag.d.ts

@@ -0,0 +1,3 @@
+export declare const VAULT_RETENTION_SETTINGS_FLAG = "cli.vault-retention-settings";
+export declare function vaultRetentionSettingsEnabled(companyUid?: string, idToken?: string): boolean | Promise<boolean>;
+//# sourceMappingURL=vault-retention-flag.d.ts.map

package/dist/commands/vault-retention-flag.js

@@ -0,0 +1,9 @@
+import { resolveCompanyFlagGate, resolveProcessFlagGate } from "../lib/flag-registry.js";
+export const VAULT_RETENTION_SETTINGS_FLAG = "cli.vault-retention-settings";
+export function vaultRetentionSettingsEnabled(companyUid, idToken) {
+    if (companyUid && idToken) {
+        return resolveCompanyFlagGate(companyUid, idToken, VAULT_RETENTION_SETTINGS_FLAG, { fallback: false }, () => false);
+    }
+    return resolveProcessFlagGate(VAULT_RETENTION_SETTINGS_FLAG, { fallback: false }, () => false);
+}
+//# sourceMappingURL=vault-retention-flag.js.map

package/dist/commands/vault-retention.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+import { vaultApiFetch } from "../utils/vault-api.js";
+type Dependencies = {
+    enabled: (companyUid?: string, token?: string) => boolean | Promise<boolean>;
+    token: () => Promise<string>;
+    companyUid: (token: string, slug: string | undefined) => Promise<string>;
+    request: typeof vaultApiFetch;
+};
+export declare function registerVaultRetentionCommand(program: Command, deps?: Dependencies): void;
+export {};
+//# sourceMappingURL=vault-retention.d.ts.map

package/dist/commands/vault-retention.js

@@ -0,0 +1,69 @@
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { markExpectedUserError } from "../utils/expected-cli-error.js";
+import { getCompanyUid, vaultApiFetch } from "../utils/vault-api.js";
+import { vaultRetentionSettingsEnabled } from "./vault-retention-flag.js";
+const defaultDependencies = {
+    enabled: vaultRetentionSettingsEnabled,
+    token: ensureCognitoToken,
+    companyUid: getCompanyUid,
+    request: vaultApiFetch,
+};
+export function registerVaultRetentionCommand(program, deps = defaultDependencies) {
+    const vault = program.command("vault").description("Manage HQ vault settings");
+    const retention = vault
+        .command("retention")
+        .description("Get or set the default retention for future vault object versions")
+        .option("--company <slug>", "Company vault slug (omit for your personal vault)");
+    const companyOf = (command) => command.opts().company ??
+        retention.opts().company;
+    retention
+        .command("get")
+        .description("Show the vault's default retention in days")
+        .action(async function () {
+        await execute(this, "GET");
+    });
+    retention
+        .command("set")
+        .description("Set the vault's default retention in days (1-30)")
+        .argument("<days>")
+        .action(async function (rawDays) {
+        const days = Number(rawDays);
+        if (!Number.isInteger(days) || days < 1 || days > 30) {
+            throw new Error("days must be an integer from 1 through 30");
+        }
+        await execute(this, "PUT", days);
+    });
+    async function execute(command, method, days) {
+        const slug = companyOf(command);
+        let token;
+        let companyUid;
+        if (slug) {
+            token = await deps.token();
+            companyUid = await deps.companyUid(token, slug);
+            if (!(await deps.enabled(companyUid, token))) {
+                throw markExpectedUserError(new Error("Vault retention settings are not enabled for this company."));
+            }
+        }
+        else {
+            if (!(await deps.enabled())) {
+                throw markExpectedUserError(new Error("Vault retention settings are not enabled for this company."));
+            }
+            token = await deps.token();
+        }
+        const query = companyUid ? { companyUid } : undefined;
+        const response = await deps.request({
+            token,
+            path: "/vault/retention",
+            method,
+            ...(query ? { query } : {}),
+            ...(days === undefined ? {} : { body: { days } }),
+        });
+        if (!response.ok) {
+            const body = (await response.json().catch(() => ({})));
+            throw new Error(body.error ?? body.message ?? response.statusText);
+        }
+        const body = (await response.json());
+        process.stdout.write(`${body.days} days\n`);
+    }
+}
+//# sourceMappingURL=vault-retention.js.map

package/dist/fast-core.js

@@ -59,12 +59,13 @@ export async function runFastCore(argv) {
         if (typeof handler !== "function") {
             throw new Error(`Native fast handler ${entry.exportName} was not exported`);
         }
+        const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
         const chunks = [];
-        if (entry.readsStdin) {
+        if (readsStdin) {
             for await (const chunk of process.stdin)
                 chunks.push(chunk);
         }
-        const code = await handler(parsed.args, entry.readsStdin ? Buffer.concat(chunks).toString("utf8") : "", process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
+        const code = await handler(parsed.args, readsStdin ? Buffer.concat(chunks).toString("utf8") : "", process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
         // Let Node drain handler output before terminating. The timeout guard's
         // stderr message must survive the native route's process boundary.
         process.exitCode = code;
@@ -80,12 +81,18 @@ export async function runFastCore(argv) {
         : process.cwd();
     const injectRoot = entry.kind === "shell" || entry.kind === "native" &&
         (entry.shellHqRoot === "live" || entry.shellHqRoot === "reconcile-default" && shouldInjectRoot);
+    const childEnv = {
+        ...(entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : {}),
+        ...(entry.name === "migrate-policy-triggers"
+            ? { CLAUDE_PROJECT_DIR: process.env.CLAUDE_PROJECT_DIR || process.cwd() }
+            : {}),
+    };
     const { code } = runBundledScript({
         asset,
         args: parsed.args,
         cwd,
         ...(injectRoot ? { hqRoot } : {}),
-        env: entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : undefined,
+        ...(Object.keys(childEnv).length ? { env: childEnv } : {}),
     });
     // Propagate verbatim: these scripts use their exit code as their interface.
     process.exit(code);

package/dist/fast-scaffold.d.ts

@@ -40,6 +40,8 @@ export type FastScaffoldScript = {
     shellHqRoot?: "none" | "live" | "reconcile-default";
     /** Whether this handler consumes stdin. Shell companions inherit stdin directly. */
     readsStdin?: boolean;
+    /** Per-invocation stdin policy for handlers whose shell reads conditionally. */
+    readsStdinFor?: (args: readonly string[]) => boolean;
     /** Whether the bundled fast-route module closure needs Node's network timeout patch. */
     requiresNodeNetworkCompatibility?: boolean;
 };

package/dist/fast-scaffold.js

@@ -184,6 +184,17 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellCwd: "live",
         shellHqRoot: "live",
     },
+    ...[
+        { name: "eval-trigger", modulePath: "./commands/core-eval-trigger-native.js", exportName: "runEvalTriggerFast", asset: "core/scripts/eval-trigger.sh", root: "cwd", shellCwd: "caller", shellHqRoot: "none", readsStdinFor: (args) => args[0] === "--check" },
+        { name: "migrate-policy-triggers", modulePath: "./commands/core-migrate-policy-triggers-native.js", exportName: "runMigratePolicyTriggersFast", asset: "core/scripts/migrate-policy-triggers.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+        { name: "register-project", modulePath: "./commands/core-register-project-native.js", exportName: "runRegisterProjectFast", asset: "core/scripts/register-project.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+        { name: "work-mesh-live-rebind", modulePath: "./commands/core-work-mesh-live-rebind-native.js", exportName: "runWorkMeshLiveRebindFast", asset: "core/scripts/work-mesh-live-rebind.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },
+    ].map((entry) => ({
+        ...entry,
+        kind: "native",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-hook-helpers",
+    })),
     ...["resolve", "pickup", "repo", "secrets", "transfer"].map((name) => ({
         name: `delegate ${name}`,
         kind: "native",

package/dist/lib/agents/model-catalog.d.ts

@@ -1,6 +1,6 @@
 export declare const AGENT_MODEL_PROVIDERS: readonly ["codex", "grok", "claude"];
 export type AgentModelProvider = (typeof AGENT_MODEL_PROVIDERS)[number];
-export interface AgentCatalogModel {
+interface AgentCatalogModel {
     id: string;
     label: string;
     visibility: string;
@@ -10,7 +10,7 @@ export interface AgentCatalogModel {
     selectable: boolean;
     unavailableReason?: string | null;
 }
-export interface AgentCatalogProvider {
+interface AgentCatalogProvider {
     models: AgentCatalogModel[];
     defaultModel: string;
 }
@@ -58,4 +58,5 @@ export declare function validateAgentModelSelection(catalog: AgentModelCatalog,
 export declare function modelSelectionErrorMessage(modelId: string, result: Extract<ModelSelectionResult, {
     ok: false;
 }>): string;
+export {};
 //# sourceMappingURL=model-catalog.d.ts.map

package/dist/lib/company-skill-wrapper.d.ts

@@ -1,12 +1,4 @@
 import * as fs from "node:fs";
-export interface CompanySkillWrapperOwnershipDiagnostics {
-    kind: "directory" | "symlink" | "file" | "other";
-    bridgeState: "all_live" | "partial" | "none" | "empty" | "not_applicable";
-    markerState: "bound" | "missing" | "invalid" | "unbound" | "unavailable" | "not_applicable";
-    linkTarget: "company_skills" | "outside_company_skills" | "unavailable" | "not_applicable";
-    platform: "win32" | "darwin" | "linux" | "other";
-    nameEncoding: "percent_encoded" | "literal";
-}
 export declare function companySkillWrapperSentryTagsFor(error: unknown): Record<string, string> | undefined;
 export interface SurfaceCompanySkillInput {
     hqRoot: string;

package/dist/lib/core-utils/codex-skill-bridge.d.ts

@@ -1,4 +1,4 @@
-export type BridgeCommand = "status" | "install" | "doctor";
+type BridgeCommand = "status" | "install" | "doctor";
 export type BridgeOptions = {
     command: BridgeCommand;
     hqRoot: string;
@@ -28,4 +28,5 @@ export declare function isHqRootLike(candidate: string): boolean;
 export declare function outputStyleSlug(name: string): string;
 /** Runs one bridge command; returns the process exit code. */
 export declare function runCodexSkillBridge(options: BridgeOptions, io: BridgeIo): number;
+export {};
 //# sourceMappingURL=codex-skill-bridge.d.ts.map