@indigoai-us/hq-cli 5.315.0 → 5.316.0

package/dist/commands/core-share-suggestion-state-native.js

@@ -0,0 +1,445 @@
+/** Native port of share-suggestion-state.sh; kept dependency-light for hooks. */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export const SHARE_SUGGESTION_STATE_ASSET = "core/scripts/share-suggestion-state.sh";
+const isObj = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const sortKeys = (value) => Array.isArray(value) ? value.map(sortKeys)
+    : (value && typeof value === "object")
+        ? Object.keys(value).sort().reduce((out, key) => { out[key] = sortKeys(value[key]); return out; }, {})
+        : value;
+const sanitizeValue = (value) => typeof value === "string" ? value.trim() : value;
+function stripComments(line) {
+    let single = false, double = false;
+    const chars = [];
+    for (const char of line) {
+        if (char === "'" && !double)
+            single = !single;
+        else if (char === '"' && !single)
+            double = !double;
+        else if (char === "#" && !single && !double)
+            break;
+        chars.push(char);
+    }
+    return chars.join("").replace(/\s+$/, "");
+}
+function parseScalar(raw) {
+    const value = raw.trim();
+    if (!value)
+        return "";
+    const lower = value.toLowerCase();
+    if (lower === "true")
+        return true;
+    if (lower === "false")
+        return false;
+    if (lower === "null" || lower === "~")
+        return null;
+    if (value === "{}")
+        return {};
+    if (value === "[]")
+        return [];
+    if (value.startsWith("[") && value.endsWith("]")) {
+        const inner = value.slice(1, -1).trim();
+        return inner ? inner.split(",").map((part) => parseScalar(part.trim())) : [];
+    }
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+        return value.slice(1, -1);
+    if (/^-?\d+$/.test(value))
+        return Number.parseInt(value, 10);
+    return value;
+}
+function parseYamlTokens(tokens, index = 0, indent = null) {
+    if (index >= tokens.length)
+        return [{}, index];
+    indent ??= tokens[index][0];
+    if (tokens[index][1].startsWith("- ")) {
+        const items = [];
+        while (index < tokens.length) {
+            const [current, content] = tokens[index];
+            if (current !== indent || !content.startsWith("- "))
+                break;
+            const value = content.slice(2).trim();
+            if (!value) {
+                const [child, next] = parseYamlTokens(tokens, index + 1);
+                items.push(child);
+                index = next;
+            }
+            else {
+                items.push(parseScalar(value));
+                index += 1;
+            }
+        }
+        return [items, index];
+    }
+    const result = {};
+    while (index < tokens.length) {
+        const [current, content] = tokens[index];
+        if (current !== indent || content.startsWith("- "))
+            break;
+        const sep = content.indexOf(":");
+        const key = (sep < 0 ? content : content.slice(0, sep)).trim();
+        const remainder = (sep < 0 ? "" : content.slice(sep + 1)).trim();
+        if (!remainder) {
+            if (index + 1 < tokens.length && tokens[index + 1][0] > current) {
+                const [child, next] = parseYamlTokens(tokens, index + 1, tokens[index + 1][0]);
+                result[key] = child;
+                index = next;
+            }
+            else {
+                result[key] = {};
+                index += 1;
+            }
+        }
+        else {
+            result[key] = parseScalar(remainder);
+            index += 1;
+        }
+    }
+    return [result, index];
+}
+function loadYaml(file, fileSystem) {
+    if (!file || !fileSystem.existsSync(file))
+        return {};
+    try {
+        const tokens = [];
+        for (const raw of fileSystem.readFileSync(file, "utf8").split(/\r?\n/)) {
+            const line = stripComments(raw);
+            if (!line.trim())
+                continue;
+            const content = line.replace(/^ +/, "");
+            tokens.push([line.length - content.length, content]);
+        }
+        if (!tokens.length)
+            return {};
+        const [value] = parseYamlTokens(tokens);
+        return isObj(value) ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+function lookupNested(data, dotted) {
+    let current = data;
+    for (const part of dotted.split(".")) {
+        if (!isObj(current) || !(part in current))
+            return null;
+        current = current[part];
+    }
+    return current;
+}
+function makeContext(deps) {
+    const fileSystem = deps.fs ?? fs;
+    const env = deps.env ?? process.env;
+    const now = deps.now ?? (() => new Date());
+    const isoNow = () => {
+        const d = now();
+        const pad = (n) => String(n).padStart(2, "0");
+        return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}Z`;
+    };
+    return { fileSystem, env, isoNow };
+}
+export function runShareSuggestionState(args, stdin, deps) {
+    const cmd = args[0] ?? "";
+    const rawSession = args[1] ?? "";
+    const argDecision = args[2] ?? "";
+    const failFromShellMain = (message) => ({ code: 0, stdout: "", stderr: `${message}share-suggestion-state: internal error\n` });
+    if (!cmd)
+        return failFromShellMain("share-suggestion-state: missing subcommand\n");
+    const root = deps.root;
+    if (!root)
+        return failFromShellMain("share-suggestion-state: unable to resolve HQ root\n");
+    const { fileSystem: f, env, isoNow } = makeContext(deps);
+    const stateHome = path.join(root, "workspace/orchestrator/share-suggestions");
+    const historyPath = path.join(stateHome, "history.jsonl");
+    const suppressionsPath = path.join(stateHome, "suppressions.jsonl");
+    try {
+        f.mkdirSync(stateHome, { recursive: true });
+    }
+    catch (error) {
+        const code = error.code;
+        let blockedPath = stateHome;
+        let current = root;
+        for (const piece of path.relative(root, stateHome).split(path.sep)) {
+            current = path.join(current, piece);
+            try {
+                if (!f.statSync(current).isDirectory()) {
+                    blockedPath = current;
+                    break;
+                }
+            }
+            catch { /* locate the first existing non-directory parent when present */ }
+        }
+        const reason = code === "ENOTDIR" ? "Not a directory" : code === "EACCES" || code === "EPERM" ? "Permission denied" : code === "EEXIST" ? "File exists" : (error instanceof Error ? error.message : String(error));
+        return failFromShellMain(`mkdir: cannot create directory ‘${blockedPath}’: ${reason}\nshare-suggestion-state: unable to create state directory\n`);
+    }
+    const sessionBytes = Buffer.from(rawSession, "utf8");
+    const sessionId = Array.from(sessionBytes, (byte) => byte === 45 || byte === 95 || (byte >= 48 && byte <= 57) || (byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122) ? String.fromCharCode(byte) : "_").join("") || "unknown";
+    const pendingPath = path.join(stateHome, `${sessionId}.json`);
+    // Bash command substitution removes every trailing LF before exporting the payload.
+    const payloadRaw = deps.stdinIsTty ? "" : stdin.replace(/\n+$/, "");
+    let payload = {};
+    if (payloadRaw) {
+        try {
+            const parsed = JSON.parse(payloadRaw);
+            if (isObj(parsed))
+                payload = parsed;
+        }
+        catch {
+            payload = {};
+        }
+    }
+    const readJson = (file, fallback) => {
+        if (!f.existsSync(file))
+            return fallback;
+        try {
+            return JSON.parse(f.readFileSync(file, "utf8"));
+        }
+        catch {
+            return fallback;
+        }
+    };
+    const writeJson = (file, value) => {
+        f.writeFileSync(`${file}.tmp`, `${JSON.stringify(sortKeys(value), null, 2)}\n`);
+        f.renameSync(`${file}.tmp`, file);
+    };
+    const appendJsonl = (file, value) => f.appendFileSync(file, `${JSON.stringify(sortKeys(value))}\n`);
+    const uniquePeople = (items) => {
+        const seen = new Set(), result = [];
+        for (const item of items || []) {
+            if (!isObj(item))
+                continue;
+            const personId = sanitizeValue(item.id || item.slug || ""), name = sanitizeValue(item.name || ""), role = sanitizeValue(item.role || "");
+            const cleaned = {};
+            if (personId)
+                cleaned.id = personId;
+            if (name)
+                cleaned.name = name;
+            if (role)
+                cleaned.role = role;
+            if (!Object.keys(cleaned).length)
+                continue;
+            const key = `${cleaned.id || ""}|${cleaned.name || ""}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(cleaned);
+            }
+        }
+        return result;
+    };
+    const sanitizeSources = (items) => {
+        const seen = new Set(), result = [];
+        for (const item of items || []) {
+            if (typeof item !== "string")
+                continue;
+            const value = item.trim();
+            if (value && !seen.has(value)) {
+                seen.add(value);
+                result.push(value);
+            }
+        }
+        return result;
+    };
+    const sanitizeArtifact = (body) => {
+        if (!isObj(body))
+            body = {};
+        let artifact = body.artifact;
+        if (!isObj(artifact))
+            artifact = body;
+        const cleaned = {};
+        for (const key of ["path", "fingerprint", "class", "surface", "permission", "app_id", "label"]) {
+            const value = sanitizeValue(artifact[key]);
+            if (typeof value === "string" && value)
+                cleaned[key] = value;
+        }
+        if (!("permission" in cleaned))
+            cleaned.permission = "read";
+        return cleaned;
+    };
+    const sanitizeCandidateHints = (body) => {
+        let hints = body.candidate_hints;
+        if (!isObj(hints))
+            hints = {};
+        const cleaned = {
+            sources: sanitizeSources(hints.sources || body.candidate_sources || []),
+            local_people: uniquePeople(hints.local_people || body.local_people || []),
+            needs_assistant_resolution: Boolean("needs_assistant_resolution" in hints ? hints.needs_assistant_resolution : body.needs_assistant_resolution),
+        };
+        const projects = sanitizeSources(hints.project_recipient_hints || body.project_recipient_hints || []);
+        if (projects.length)
+            cleaned.project_recipient_hints = projects;
+        return cleaned;
+    };
+    const sanitizeSuggestion = (body) => {
+        const artifact = sanitizeArtifact(body), fingerprint = artifact.fingerprint || "";
+        const company = sanitizeValue(body.company || ""), project = sanitizeValue(body.project || "");
+        const suggestion = {
+            session_id: sessionId, company, project, artifact,
+            trigger: sanitizeValue(body.trigger || ""), action_kind: sanitizeValue(body.action_kind || "share-suggestion"),
+            suggested_permission: sanitizeValue(body.suggested_permission || artifact.permission || "read"),
+            recommended_surface: sanitizeValue(body.recommended_surface || artifact.surface || ""),
+            recipients: uniquePeople(body.recipients || []), candidate_hints: sanitizeCandidateHints(body),
+            created_at: body.created_at || isoNow(), updated_at: isoNow(), shown_at: body.shown_at === undefined ? null : body.shown_at,
+        };
+        return !company || !fingerprint ? null : suggestion;
+    };
+    const sanitizeHistory = (body) => {
+        const artifact = sanitizeArtifact(body);
+        const entry = {
+            session_id: sessionId, company: sanitizeValue(body.company || ""), project: sanitizeValue(body.project || ""),
+            trigger: sanitizeValue(body.trigger || ""), action_kind: sanitizeValue(body.action_kind || "share-suggestion"),
+            decision: sanitizeValue(body.decision || ""), event: sanitizeValue(body.event || ""), artifact,
+            recipients: uniquePeople(body.recipients || []), recorded_at: isoNow(),
+        };
+        return artifact.fingerprint ? entry : null;
+    };
+    const sanitizeSuppression = (body) => {
+        const artifact = sanitizeArtifact(body), scope = sanitizeValue(body.scope || "");
+        const record = {
+            kind: scope ? "scope" : "artifact", scope,
+            company: sanitizeValue(body.company || ""), project: sanitizeValue(body.project || ""),
+            artifact_class: sanitizeValue(body.artifact_class || artifact.class || ""), artifact: {},
+            reason: sanitizeValue(body.reason || "suppressed"), created_at: isoNow(),
+        };
+        if (artifact.fingerprint)
+            record.artifact.fingerprint = artifact.fingerprint;
+        if (artifact.path)
+            record.artifact.path = artifact.path;
+        if (scope) {
+            if (!["global", "company", "project"].includes(scope))
+                return null;
+            return record;
+        }
+        return record.artifact.fingerprint ? record : null;
+    };
+    const configPaths = (company, project) => ({
+        global: path.join(root, "personal/settings/auto-share-preferences.yaml"),
+        company: company ? path.join(root, "companies", company, "settings/auto-share.yaml") : null,
+        project: company && project ? path.join(root, "companies", company, "projects", project, "share-policy.yaml") : null,
+    });
+    const isSuppressedByConfig = (company, project, artifactClass) => {
+        const paths = configPaths(company, project), projectCfg = loadYaml(paths.project, f), companyCfg = loadYaml(paths.company, f), globalCfg = loadYaml(paths.global, f);
+        const has = (v) => Object.keys(v).length > 0;
+        let enabled = has(projectCfg) ? (typeof lookupNested(projectCfg, "enabled") === "boolean" ? lookupNested(projectCfg, "enabled") : null) : null;
+        if (enabled === null)
+            enabled = has(companyCfg) && typeof lookupNested(companyCfg, "defaults.enabled") === "boolean" ? lookupNested(companyCfg, "defaults.enabled") : null;
+        if (enabled === null)
+            enabled = typeof lookupNested(globalCfg, "defaults.enabled") === "boolean" ? lookupNested(globalCfg, "defaults.enabled") : null;
+        if (enabled === false)
+            return true;
+        const key = `artifact_classes.${artifactClass}`;
+        let cls = has(projectCfg) && typeof lookupNested(projectCfg, key) === "boolean" ? lookupNested(projectCfg, key) : null;
+        if (cls === null)
+            cls = has(companyCfg) && typeof lookupNested(companyCfg, key) === "boolean" ? lookupNested(companyCfg, key) : null;
+        if (cls === null)
+            cls = typeof lookupNested(globalCfg, key) === "boolean" ? lookupNested(globalCfg, key) : null;
+        return cls === false;
+    };
+    const suppressionMatch = (record, company, project, cls, fingerprint) => {
+        if (!isObj(record))
+            return false;
+        const artifact = isObj(record.artifact) ? record.artifact : {};
+        if (fingerprint && artifact.fingerprint === fingerprint)
+            return true;
+        if (record.kind !== "scope")
+            return false;
+        if (record.artifact_class && cls && record.artifact_class !== cls)
+            return false;
+        if (record.scope === "global")
+            return true;
+        if (record.scope === "company")
+            return Boolean(company) && record.company === company;
+        if (record.scope === "project")
+            return Boolean(company && project) && record.company === company && record.project === project;
+        return false;
+    };
+    try {
+        if (cmd === "enqueue") {
+            const suggestion = sanitizeSuggestion(payload);
+            if (!suggestion)
+                return { code: 0, stdout: "", stderr: "" };
+            const existing = readJson(pendingPath, {});
+            if (isObj(existing) && Object.keys(existing).length && !existing.resolved_at)
+                return { code: 0, stdout: "", stderr: "" };
+            writeJson(pendingPath, suggestion);
+            const entry = sanitizeHistory(Object.assign({}, suggestion, { event: "enqueued" }));
+            if (entry)
+                appendJsonl(historyPath, entry);
+        }
+        else if (cmd === "peek") {
+            const pending = readJson(pendingPath, {});
+            if (isObj(pending) && Object.keys(pending).length && !pending.resolved_at)
+                return { code: 0, stdout: JSON.stringify(sortKeys(pending)), stderr: "" };
+        }
+        else if (cmd === "mark-shown") {
+            const pending = readJson(pendingPath, {});
+            if (isObj(pending) && Object.keys(pending).length && !pending.resolved_at && !pending.shown_at) {
+                pending.shown_at = isoNow();
+                pending.updated_at = isoNow();
+                writeJson(pendingPath, pending);
+                const entry = sanitizeHistory(Object.assign({}, pending, { event: "shown" }));
+                if (entry)
+                    appendJsonl(historyPath, entry);
+            }
+        }
+        else if (cmd === "record-decision") {
+            const pending = readJson(pendingPath, {}), decision = argDecision || env.SHARE_SUGGESTION_DECISION || sanitizeValue(payload.decision || "");
+            if (!isObj(pending) || !Object.keys(pending).length || pending.resolved_at || !decision)
+                return { code: 0, stdout: "", stderr: "" };
+            pending.decision = decision;
+            pending.decision_at = isoNow();
+            pending.resolved_at = isoNow();
+            pending.updated_at = isoNow();
+            if (payload.recipients)
+                pending.recipients = uniquePeople(payload.recipients);
+            const entry = sanitizeHistory(Object.assign({}, pending, { event: "decision", decision }));
+            if (entry)
+                appendJsonl(historyPath, entry);
+            if (["never", "never-again", "never_again"].includes(decision)) {
+                const suppression = sanitizeSuppression({ company: pending.company, project: pending.project, artifact_class: (pending.artifact || {}).class, artifact: pending.artifact, reason: "never-again" });
+                if (suppression)
+                    appendJsonl(suppressionsPath, suppression);
+            }
+            try {
+                f.unlinkSync(pendingPath);
+            }
+            catch { /* shell ignores a missing pending file */ }
+        }
+        else if (cmd === "append-history") {
+            const entry = sanitizeHistory(payload);
+            if (entry)
+                appendJsonl(historyPath, entry);
+        }
+        else if (cmd === "suppress") {
+            const record = sanitizeSuppression(payload);
+            if (record)
+                appendJsonl(suppressionsPath, record);
+        }
+        else if (cmd === "is-suppressed") {
+            const artifact = sanitizeArtifact(payload), company = sanitizeValue(payload.company || ""), project = sanitizeValue(payload.project || "");
+            const cls = sanitizeValue(payload.artifact_class || artifact.class || ""), fingerprint = sanitizeValue(artifact.fingerprint || "");
+            if (isSuppressedByConfig(company, project, cls))
+                return { code: 0, stdout: "true", stderr: "" };
+            if (f.existsSync(suppressionsPath)) {
+                for (let raw of f.readFileSync(suppressionsPath, "utf8").split(/\r?\n/)) {
+                    raw = raw.trim();
+                    if (!raw)
+                        continue;
+                    let record;
+                    try {
+                        record = JSON.parse(raw);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (suppressionMatch(record, company, project, cls, fingerprint))
+                        return { code: 0, stdout: "true", stderr: "" };
+                }
+            }
+        }
+        return { code: 0, stdout: "", stderr: "" };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+        return { code: 0, stdout: "", stderr: `share-suggestion-state: internal error\n${detail}\n` };
+    }
+}
+//# sourceMappingURL=core-share-suggestion-state-native.js.map

package/dist/commands/core.js

@@ -46,6 +46,7 @@ import { registerCorePinNative } from "./core-pin-native.js";
 import { registerCoreRefreshVaultAccessNative } from "./core-refresh-vault-access-native.js";
 import { registerCoreWorkMeshBindTrustedNative } from "./core-work-mesh-bind-trusted-native.js";
 import { registerCoreHookHelperNativeCommands } from "./core-native-hook-helper-commands.js";
+import { registerCoreHookStateHelpers } from "./core-hook-state-helpers-native.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { interpreterFor, runBundledScript } from "../utils/run-bundled-script.js";
 import { CompanyIndexUserError, renderIndexTarget } from "../lib/index-render/index.js";
@@ -233,6 +234,9 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/hq-job-remediate.sh", root: "live", summary: "Scheduled jobs bounded remediation helper" },
     { asset: "core/scripts/hq-dm-bind.sh", root: "live", summary: "Rollback shell for native dm-bind" },
     { asset: "core/scripts/work-mesh-live-bind-trusted.sh", root: "live", summary: "Rollback shell for native work-mesh-bind-trusted" },
+    { asset: "core/scripts/share-suggestion-state.sh", root: "live", summary: "Rollback shell for native share-suggestion-state" },
+    { asset: "core/scripts/repo-run-registry.sh", root: "live", summary: "Rollback shell for native repo-run-registry" },
+    { asset: "core/scripts/detect-stale-review-base.sh", root: "live", summary: "Rollback shell for native detect-stale-review-base" },
     // Shared shell libs sourced by the two relocated scripts (and hooks). Never
     // dispatched on their own (so no `hq core` command), but they MUST ship in the
     // tarball, or the bundled hq-session / checkpoint-stop-gate die at `source`
@@ -387,6 +391,7 @@ export function registerCoreCommands(program) {
     registerCoreDmBindNative(core);
     registerCoreWorkMeshBindTrustedNative(core);
     registerCoreHookHelperNativeCommands(core);
+    registerCoreHookStateHelpers(core);
     // Wave 2 handoff/worktree commands retain their byte-identical shell assets
     // as a default-off rollback path for one release. Keep the gate helper small
     // so sibling Wave 2 work can reuse it without editing this command table.

package/dist/commands/lanes.js

@@ -45,7 +45,7 @@ import { createOutpostProfileRepinContext, parseOutpostProfileRepinContext, } fr
 import { createOutpostRegistryWorkerApprovalContext, parseOutpostRegistryWorkerApprovalContext, } from "../lib/lanes/outpost-registry-worker-approval.js";
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
-import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostQuestionListCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, REMOTE_LANE_READ_ENV, outpostRejectedEffortOption, parseOutpostPickupPayload, PICKUP_WAIT_MS, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostQuestionListCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, buildOutpostLegacyLaneUlidListCommand, REMOTE_LANE_READ_ENV, outpostRejectedEffortOption, parseOutpostPickupPayload, PICKUP_WAIT_MS, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { outpostHireSummaryCacheKey, OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS, readOutpostHireSummaryCache, readOutpostHireSummaryCacheIncludingStale, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { BALANCE_MOVABLE_STATES, selectClaudeAccount, } from "../lib/lanes/claude-balance.js";
@@ -781,6 +781,7 @@ function validateOwnerLaneHireSummary(input) {
 function laneListQueryFlags(query) {
     return [
         ...(query.laneIds?.length ? ["--lane"] : []),
+        ...(query.laneUlids?.length ? ["--lane-ulid"] : []),
         ...(query.active ? ["--active"] : []),
         ...(query.hierarchy?.length ? ["--hierarchy"] : []),
         ...(query.snapshot ? ["--snapshot"] : []),
@@ -804,6 +805,14 @@ async function dispatchOutpostLaneList(ctx, outpostId, query, timeoutSeconds, wa
     });
     if (query.strictSnapshot || !rejectedLaneListFlag(filtered, query))
         return filtered;
+    if (rejectedLaneListFlag(filtered, query) === "--lane-ulid" && query.laneUlids?.length === 1) {
+        return ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostLegacyLaneUlidListCommand({ hqBinary, ulid: query.laneUlids[0] }),
+            timeoutSeconds,
+            waitMs,
+        });
+    }
     return ctx.dispatchOutpostExec({
         outpostId,
         command: buildOutpostLaneListCommand({ hqBinary }),
@@ -1206,15 +1215,20 @@ async function loadHostCapacitySnapshots(ctx, hqRoot, config = loadLanesConfig(h
     };
 }
 const outpostLaneListMemo = new WeakMap();
+const MAX_OUTPOST_LANE_LIST_BYTES = 480 * 1024;
 function normalizedLaneListQuery(query) {
     const laneIds = query.laneIds === undefined
         ? undefined
         : [...new Set(query.laneIds)].sort((a, b) => a.localeCompare(b));
+    const laneUlids = query.laneUlids === undefined
+        ? undefined
+        : [...new Set(query.laneUlids.map((ulid) => ulid.toUpperCase()))].sort((a, b) => a.localeCompare(b));
     const hierarchy = query.hierarchy === undefined
         ? undefined
         : [...new Set(query.hierarchy)].sort((a, b) => a.localeCompare(b));
     return {
         ...(laneIds === undefined ? {} : { laneIds }),
+        ...(laneUlids === undefined ? {} : { laneUlids }),
         ...(query.active ? { active: true } : {}),
         ...(hierarchy === undefined ? {} : { hierarchy }),
         ...(query.snapshot ? { snapshot: true } : {}),
@@ -1223,7 +1237,7 @@ function normalizedLaneListQuery(query) {
     };
 }
 async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions = {}) {
-    const targetedLookup = query.hierarchy !== undefined || query.laneIds !== undefined;
+    const targetedLookup = query.hierarchy !== undefined || query.laneIds !== undefined || query.laneUlids !== undefined;
     const waitMs = targetedLookup ? outpostSingleLaneWaitMs(ctx.env) : CAPACITY_PROBE_TIMEOUT_MS;
     const dispatchWaitMs = dispatchOptions.waitMs ?? waitMs;
     const dispatchTimeoutSeconds = dispatchOptions.timeoutSeconds ?? Math.ceil(dispatchWaitMs / 1000);
@@ -1249,6 +1263,10 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
             exit_code: result.exitCode,
         });
     }
+    const stdoutBytes = Buffer.byteLength(result.stdout, "utf8");
+    if (stdoutBytes >= MAX_OUTPOST_LANE_LIST_BYTES) {
+        throw new LanesError("outpost_lane_list_too_large", `Outpost ${outpostId} lane-list response reached the ${Math.floor(MAX_OUTPOST_LANE_LIST_BYTES / 1024)} KiB Outpost exec output limit`, { outpost_id: outpostId, command_id: result.commandId, stdout_bytes: stdoutBytes });
+    }
     let body;
     try {
         body = JSON.parse(result.stdout);
@@ -1625,7 +1643,7 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
         let ownerLanes;
         try {
             ownerLanes = await readOutpostLaneRecords(ctx, outpostId, hostlessUlidLookup
-                ? { snapshot: true }
+                ? { laneUlids: [requestedUlid], snapshot: true }
                 : { hierarchy: [laneId], snapshot: true });
             probedOutpostIds.push(outpostId);
         }
@@ -4849,6 +4867,12 @@ async function runList(ctx, opts) {
         new Set(requestedLaneIds).size !== requestedLaneIds.length) {
         throw new LanesError("lane_list_filter_invalid", "--lane must be repeated with distinct, non-empty lane ids", { lane_ids: requestedLaneIds });
     }
+    const requestedLaneUlids = opts.laneUlid ?? [];
+    if (!Array.isArray(requestedLaneUlids) ||
+        requestedLaneUlids.some((ulid) => typeof ulid !== "string" || laneUlidPart(ulid) !== ulid.toUpperCase()) ||
+        new Set(requestedLaneUlids.map((ulid) => ulid.toUpperCase())).size !== requestedLaneUlids.length) {
+        throw new LanesError("lane_list_ulid_filter_invalid", "--lane-ulid must be repeated with distinct 26-character ULIDs", { lane_ulids: requestedLaneUlids });
+    }
     if (opts.hierarchy !== undefined &&
         (!Array.isArray(opts.hierarchy) || opts.hierarchy.length === 0 ||
             opts.hierarchy.some((laneId) => typeof laneId !== "string" || !laneId.trim() || laneId.trim() !== laneId) ||
@@ -4869,11 +4893,13 @@ async function runList(ctx, opts) {
         company = await ctx.resolveCompany(opts.company);
     }
     const requestedIds = new Set(requestedLaneIds);
-    const canReadOnlyRequestedIds = opts.snapshot && requestedLaneIds.length > 0 &&
+    const requestedUlidSet = new Set(requestedLaneUlids.map((ulid) => ulid.toUpperCase()));
+    const canReadOnlyRequestedIds = opts.snapshot && (requestedLaneIds.length > 0 || requestedLaneUlids.length > 0) &&
         !opts.active && opts.hierarchy === undefined;
     const laneSource = canReadOnlyRequestedIds
         ? listLaneIds(hqRoot)
-            .filter((laneId) => requestedIds.has(laneId))
+            .filter((laneId) => requestedIds.has(laneId) ||
+            (laneUlidPart(laneId) !== undefined && requestedUlidSet.has(laneUlidPart(laneId))))
             .map((laneId) => readLane(hqRoot, laneId))
         : loadAllLanes(hqRoot);
     const hierarchyIds = opts.hierarchy === undefined
@@ -4882,6 +4908,8 @@ async function runList(ctx, opts) {
     const matchesLaneFilters = (lane, includeState) => {
         if (requestedLaneIds.length > 0 && !requestedIds.has(lane.lane_id))
             return false;
+        if (requestedUlidSet.size > 0 && !requestedUlidSet.has(laneUlidPart(lane.lane_id) ?? ""))
+            return false;
         if (includeState && opts.active && isTerminalLaneState(lane.state))
             return false;
         if (hierarchyIds && !hierarchyIds.has(lane.lane_id))
@@ -8424,6 +8452,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--state <state>", `Filter by state (${LANE_STATES.join("|")})`)
         .option("--senior <ref>", "Filter by senior ref")
         .option("--lane <id>", "Filter by lane id (repeatable)", (value, previous = []) => [...previous, value], [])
+        .addOption(new Option("--lane-ulid <ulid>", "Filter by lane ULID for internal owner lookup").hideHelp()
+        .argParser((value, previous = []) => [...previous, value]))
         .option("--active", "Include only lanes that are not terminal")
         .addOption(new Option("--hierarchy <lane-id>").hideHelp()
         .argParser((value, previous = []) => [...previous, value]))

package/dist/fast-core.d.ts

@@ -6,6 +6,7 @@
  * entries use the bundled-script runner; native entries import their one handler
  * module. The registration in `core.ts` remains the complete fallback path.
  */
+export declare function readStdinIfPiped(stream: NodeJS.ReadStream): Promise<string>;
 /**
  * Run the fast-path core command named in `argv` and exit with its code.
  * Only call when {@link isFastCoreRequest} is true; a non-match returns without

package/dist/fast-core.js

@@ -9,6 +9,14 @@
 import { resolveLiveRoot } from "./utils/hq-roots.js";
 import { runBundledScript } from "./utils/run-bundled-script.js";
 import { parseFastCore } from "./fast-scaffold.js";
+export async function readStdinIfPiped(stream) {
+    if (stream.isTTY)
+        return "";
+    const chunks = [];
+    for await (const chunk of stream)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
 /**
  * Run the fast-path core command named in `argv` and exit with its code.
  * Only call when {@link isFastCoreRequest} is true; a non-match returns without
@@ -60,12 +68,8 @@ export async function runFastCore(argv) {
             throw new Error(`Native fast handler ${entry.exportName} was not exported`);
         }
         const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
-        const chunks = [];
-        if (readsStdin) {
-            for await (const chunk of process.stdin)
-                chunks.push(chunk);
-        }
-        const code = await handler(parsed.args, readsStdin ? Buffer.concat(chunks).toString("utf8") : "", process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
+        const stdin = readsStdin ? await readStdinIfPiped(process.stdin) : "";
+        const code = await handler(parsed.args, stdin, 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;

package/dist/fast-scaffold.js

@@ -172,6 +172,23 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellCwd: "caller",
         shellHqRoot: name === "reconcile" ? "reconcile-default" : "none",
     })),
+    ...["share-suggestion-state", "repo-run-registry", "detect-stale-review-base"].map((name) => ({
+        name,
+        kind: "native",
+        modulePath: "./commands/core-hook-state-helpers-native.js",
+        exportName: name === "share-suggestion-state"
+            ? "runShareSuggestionStateFast"
+            : name === "repo-run-registry"
+                ? "runRepoRunRegistryFast"
+                : "runDetectStaleReviewBaseFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-hook-helpers",
+        asset: `core/scripts/${name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+        ...(name === "share-suggestion-state" ? { readsStdin: true } : {}),
+    })),
     {
         name: "resolve-company",
         kind: "native",

package/dist/lib/bot/job-quiet-flag.d.ts

@@ -0,0 +1,4 @@
+/** Default-off rollout gate for per-job quiet success delivery. */
+export declare const BOT_JOB_QUIET_OPTION_FLAG = "cli.bot-job-quiet-option";
+export declare function botJobQuietOptionEnabled(): Promise<boolean>;
+//# sourceMappingURL=job-quiet-flag.d.ts.map