@indigoai-us/hq-cli 5.292.0 → 5.294.0

package/dist/commands/lanes-autopilot.js

@@ -0,0 +1,336 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { laneRunsHere } from "../lib/lanes/reconcile.js";
+import { listLaneReviews } from "../lib/lanes/reviews.js";
+import { readAllLanes } from "../lib/lanes/store.js";
+import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
+import { normalizeIsoTimestamp } from "../lib/lanes/timestamp.js";
+import { buildAutopilotMetricsReport, } from "../lib/lanes/autopilot-metrics.js";
+import { LanesError } from "../lib/lanes/errors.js";
+const OPERATOR_NUDGE_DEFECTS_REL = path.join("workspace", "lane-briefs", "operator-nudge-defects.jsonl");
+const JUNIORS_REL = path.join("workspace", "lane-briefs", "juniors.json");
+const DROPBOX_NAME = "dropbox";
+const RESUME_SUFFIX = ".resume.jsonl";
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function safeReadText(root, file, missingOk = false) {
+    let stat;
+    try {
+        stat = fs.lstatSync(file);
+    }
+    catch (err) {
+        if (missingOk && err.code === "ENOENT")
+            return null;
+        return fail("autopilot_metrics_input_unreadable", `Could not inspect report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        return fail("autopilot_metrics_input_invalid", "Report input must be a regular file", { path: file });
+    }
+    let realRoot;
+    let realFile;
+    try {
+        realRoot = fs.realpathSync(root);
+        realFile = fs.realpathSync(file);
+    }
+    catch (err) {
+        return fail("autopilot_metrics_input_unreadable", `Could not resolve report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+    if (!realFile.startsWith(`${realRoot}${path.sep}`)) {
+        return fail("autopilot_metrics_input_invalid", "Report input must stay under the HQ root", { path: file });
+    }
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        return fail("autopilot_metrics_input_unreadable", `Could not read report input: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+}
+function parseJsonObject(root, file) {
+    const raw = safeReadText(root, file);
+    try {
+        const parsed = JSON.parse(raw ?? "");
+        if (isObject(parsed))
+            return parsed;
+    }
+    catch (err) {
+        return fail("autopilot_metrics_input_invalid", `Report input is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, { path: file });
+    }
+    return fail("autopilot_metrics_input_invalid", "Report input must be a JSON object", { path: file });
+}
+function isCurrentHostLabel(label, host) {
+    return label === "local" ? host.outpostId === null : label === host.outpostId || label === host.hostname;
+}
+function loadJuniors(root, host) {
+    const file = path.join(root, JUNIORS_REL);
+    const parsed = parseJsonObject(root, file);
+    if (!Array.isArray(parsed.juniors))
+        return fail("autopilot_metrics_input_invalid", "Team registry must contain a juniors array", { path: file });
+    const seen = new Set();
+    return parsed.juniors.flatMap((value, index) => {
+        if (!isObject(value) || typeof value.host !== "string" || !value.host.trim()) {
+            return fail("autopilot_metrics_input_invalid", "Team registry row must identify its host", { path: file, index });
+        }
+        if (!isCurrentHostLabel(value.host, host))
+            return [];
+        if (["team", "lane", "status", "prd"].some((field) => typeof value[field] !== "string" || !value[field].trim())) {
+            return fail("autopilot_metrics_input_invalid", "Selected team registry row must contain team, lane, status, and prd strings", { path: file, index });
+        }
+        const entry = value;
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(entry.team) || entry.lane.includes("/") || entry.lane.includes("\\")) {
+            return fail("autopilot_metrics_input_invalid", "Team registry row contains an unsafe team or lane id", { path: file, index });
+        }
+        if (seen.has(entry.lane))
+            return fail("autopilot_metrics_mapping_ambiguous", "A lead lane appears more than once in the selected host registry", { path: file, lane_id: entry.lane });
+        seen.add(entry.lane);
+        return [entry];
+    });
+}
+function projectPath(root, raw, registryPath) {
+    if (path.isAbsolute(raw))
+        return fail("autopilot_metrics_mapping_invalid", "Project path must be relative to the HQ root", { path: registryPath, project_path: raw });
+    const absolute = path.resolve(root, raw);
+    if (!absolute.startsWith(`${path.resolve(root)}${path.sep}`)) {
+        return fail("autopilot_metrics_mapping_invalid", "Project path must stay under the HQ root", { path: registryPath, project_path: raw });
+    }
+    return absolute;
+}
+function loadProject(root, projectId, rawPrd) {
+    const registryPath = path.join(root, JUNIORS_REL);
+    const file = projectPath(root, rawPrd, registryPath);
+    const parsed = parseJsonObject(root, file);
+    const storiesValue = parsed.userStories === undefined ? parsed.stories : parsed.userStories;
+    if (!Array.isArray(storiesValue))
+        return fail("autopilot_metrics_input_invalid", "Project must contain a userStories or stories array", { path: file });
+    const stories = storiesValue.map((value, index) => {
+        if (!isObject(value) || typeof value.id !== "string" || !value.id.trim()) {
+            return fail("autopilot_metrics_input_invalid", "Project story must have a non-empty id", { path: file, index });
+        }
+        return value;
+    });
+    return { project_id: projectId, stories };
+}
+function parseIso(value, field, file) {
+    const normalized = normalizeIsoTimestamp(value);
+    if (normalized !== null)
+        return normalized;
+    if (typeof value === "string") {
+        const minutePrecision = /^(\d{4}-\d\d-\d\dT\d\d:\d\d)(Z|[+-]\d\d:\d\d)$/.exec(value);
+        if (minutePrecision) {
+            const withSeconds = normalizeIsoTimestamp(`${minutePrecision[1]}:00${minutePrecision[2]}`);
+            if (withSeconds !== null)
+                return withSeconds;
+        }
+    }
+    return fail("autopilot_metrics_input_invalid", `${field} must be an ISO timestamp`, { path: file, field });
+}
+function readJsonl(root, file, missingOk = false) {
+    const text = safeReadText(root, file, missingOk);
+    if (text === null)
+        return [];
+    const records = [];
+    for (const [index, line] of text.split("\n").entries()) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (err) {
+            return fail("autopilot_metrics_input_invalid", `Report JSONL contains malformed JSON: ${err instanceof Error ? err.message : String(err)}`, { path: file, line: index + 1 });
+        }
+        if (!isObject(parsed))
+            return fail("autopilot_metrics_input_invalid", "Report JSONL rows must be objects", { path: file, line: index + 1 });
+        records.push(parsed);
+    }
+    return records;
+}
+function listRegularFiles(root, directory, output, depth = 0) {
+    let names;
+    try {
+        const stat = fs.lstatSync(directory);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            return fail("autopilot_metrics_input_invalid", "Report path must be a regular directory", { path: directory });
+        const realRoot = fs.realpathSync(root);
+        const realDirectory = fs.realpathSync(directory);
+        if (!realDirectory.startsWith(`${realRoot}${path.sep}`))
+            return fail("autopilot_metrics_input_invalid", "Report directory must stay under the HQ root", { path: directory });
+        names = fs.readdirSync(directory);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        if (err instanceof LanesError)
+            throw err;
+        return fail("autopilot_metrics_input_unreadable", `Could not list report directory: ${err instanceof Error ? err.message : String(err)}`, { path: directory });
+    }
+    for (const name of names) {
+        if (!name || name.startsWith("."))
+            continue;
+        const candidate = path.join(directory, name);
+        let stat;
+        try {
+            stat = fs.lstatSync(candidate);
+        }
+        catch (err) {
+            return fail("autopilot_metrics_input_unreadable", `Could not inspect report file: ${err instanceof Error ? err.message : String(err)}`, { path: candidate });
+        }
+        if (stat.isSymbolicLink())
+            return fail("autopilot_metrics_input_invalid", "Report directory may not contain symbolic links", { path: candidate });
+        if (stat.isFile() && name.endsWith(".jsonl"))
+            output.push(candidate);
+        else if (stat.isDirectory() && depth < 2)
+            listRegularFiles(root, candidate, output, depth + 1);
+    }
+}
+function readLeadMessages(root, laneId) {
+    const dropbox = path.join(root, LANES_RUNS_REL, laneId, DROPBOX_NAME);
+    const allFiles = [];
+    for (const name of ["draining", "inflight", "delivered", "undeliverable"])
+        listRegularFiles(root, path.join(dropbox, name), allFiles);
+    const inbox = path.join(dropbox, "inbox.jsonl");
+    try {
+        const stat = fs.lstatSync(inbox);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            return fail("autopilot_metrics_input_invalid", "Lead inbox must be a regular file", { path: inbox });
+        allFiles.push(inbox);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    const seen = new Set();
+    const nudges = [];
+    const resumes = [];
+    for (const file of new Set(allFiles)) {
+        const resumeFile = file.endsWith(RESUME_SUFFIX);
+        for (const row of readJsonl(root, file)) {
+            // Undated records cannot be assigned to a report day, regardless of their file.
+            if (typeof row.at !== "string")
+                continue;
+            const at = parseIso(row.at, "at", file);
+            const text = typeof row.text === "string" ? row.text : "";
+            const messageId = typeof row.message_id === "string" ? row.message_id : `${at}\u0000${text}`;
+            if (!seen.has(messageId)) {
+                seen.add(messageId);
+                if (resumeFile || row.kind !== "monitor_event")
+                    nudges.push({ team: "", at });
+            }
+            if (resumeFile)
+                resumes.push({ lane_id: laneId, at });
+        }
+    }
+    return { nudges, resumes };
+}
+function loadNudgeDefects(root, selectedTeams) {
+    const file = path.join(root, OPERATOR_NUDGE_DEFECTS_REL);
+    return readJsonl(root, file, true).flatMap((row, index) => {
+        if (typeof row.team === "string" && !selectedTeams.has(row.team))
+            return [];
+        const defect = typeof row.defect === "string" && row.defect.trim() ? row.defect : row.why;
+        if (typeof row.team !== "string" || !row.team.trim() || typeof defect !== "string" || !defect.trim()) {
+            return fail("autopilot_metrics_input_invalid", "Nudge-defect row must contain at, team, and defect (or legacy why)", { path: file, line: index + 1 });
+        }
+        return [{ at: parseIso(row.at, "at", file), team: row.team, defect }];
+    });
+}
+function loadReviews(root) {
+    const listing = listLaneReviews(root);
+    if (listing.skipped > 0)
+        return fail("autopilot_metrics_review_record_invalid", "One or more lane review records could not be read", { skipped: listing.skipped });
+    return listing.reviews.flatMap((review) => review.history.map((entry) => ({
+        repo: entry.repo,
+        pr: entry.pr,
+        recorded_at: entry.recorded_at,
+        worker_lane: entry.worker_lane,
+    })));
+}
+function selectLeads(root, host) {
+    const juniors = loadJuniors(root, host);
+    const lanes = readAllLanes(root);
+    const leads = [];
+    const projects = [];
+    const laneIds = new Set();
+    const projectIds = new Set();
+    for (const entry of juniors) {
+        const matchingLanes = lanes.filter((candidate) => candidate.lane_id === entry.lane || candidate.lane_id.startsWith(`${entry.lane}_`));
+        const lane = matchingLanes.find((candidate) => laneRunsHere(candidate, host));
+        if (!lane) {
+            return fail("autopilot_metrics_lead_missing", "Registered lead lane could not be read on this host", { team: entry.team, lane_id: entry.lane });
+        }
+        if (laneIds.has(lane.lane_id))
+            return fail("autopilot_metrics_mapping_ambiguous", "A lead lane appears more than once in the host report", { lane_id: lane.lane_id });
+        const projectKey = JSON.stringify([lane.project_id, projectPath(root, entry.prd, path.join(root, JUNIORS_REL))]);
+        const lead = { team: entry.team, lane_id: lane.lane_id, project_id: projectKey };
+        leads.push(lead);
+        laneIds.add(lane.lane_id);
+        if (!projectIds.has(projectKey)) {
+            projects.push(loadProject(root, projectKey, entry.prd));
+            projectIds.add(projectKey);
+        }
+    }
+    return { leads, projects, laneIds };
+}
+function windowFromOptions(now, options) {
+    const until = normalizeIsoTimestamp(now.toISOString());
+    if (until === null)
+        return fail("autopilot_metrics_window_invalid", "Current time is invalid");
+    if (options.since !== undefined && options.days !== undefined)
+        return fail("autopilot_metrics_window_invalid", "Use either --since or --days, not both");
+    if (options.since !== undefined) {
+        const since = normalizeIsoTimestamp(options.since);
+        if (since === null || Date.parse(since) >= Date.parse(until))
+            return fail("autopilot_metrics_window_invalid", "--since must be an ISO timestamp before now", { since: options.since });
+        return { since, until };
+    }
+    const days = options.days === undefined ? 3 : Number(options.days);
+    if (!Number.isSafeInteger(days) || days < 1 || days > 366)
+        return fail("autopilot_metrics_window_invalid", "--days must be an integer from 1 to 366", { days: options.days });
+    return { since: new Date(Date.parse(until) - days * 24 * 60 * 60 * 1000).toISOString(), until };
+}
+function printJson(value) {
+    console.log(JSON.stringify(value));
+}
+export function registerLaneAutopilotReportCommand(parent, deps, wrap) {
+    const autopilot = parent.command("autopilot").description("Measure automated lead-lane follow-through");
+    autopilot.command("report")
+        .description("Report operator nudges, review latency, and idle slots with ready work")
+        .option("--since <iso>", "Include activity since this ISO timestamp")
+        .option("--days <n>", "Include the most recent number of days")
+        .option("--json", "Print JSON")
+        .action(wrap(async (options) => {
+        const root = deps.hqRoot();
+        const window = windowFromOptions(deps.now(), options);
+        const host = deps.currentHost();
+        const selected = selectLeads(root, host);
+        const lanes = readAllLanes(root);
+        const nudges = [];
+        const resumes = [];
+        for (const lead of selected.leads) {
+            const events = readLeadMessages(root, lead.lane_id);
+            nudges.push(...events.nudges.map((event) => ({ ...event, team: lead.team })));
+            resumes.push(...events.resumes);
+            const record = lanes.find((lane) => lane.lane_id === lead.lane_id);
+            const lastResume = record?.last_resume?.at;
+            if (lastResume && !resumes.some((resume) => resume.lane_id === lead.lane_id && resume.at === lastResume))
+                resumes.push({ lane_id: lead.lane_id, at: lastResume });
+        }
+        const reviewListing = loadReviews(root);
+        const defects = loadNudgeDefects(root, new Set(selected.leads.map((lead) => lead.team)));
+        const result = buildAutopilotMetricsReport({
+            ...window,
+            leads: selected.leads,
+            lanes: lanes,
+            projects: selected.projects,
+            reviews: reviewListing,
+            nudges,
+            nudgeDefects: defects,
+            seniorResumes: resumes,
+        });
+        printJson(result);
+    }));
+}
+//# sourceMappingURL=lanes-autopilot.js.map

package/dist/commands/lanes-move.js

@@ -19,6 +19,38 @@ export function createLaneMoveHandlers(deps) {
             lane.last_host_report_at === undefined &&
             lane.pending_resume === undefined;
     }
+    function sameHost(a, b) {
+        return a.kind === b.kind && a.id === b.id;
+    }
+    function reportAlreadyOnTarget(lane) {
+        printJson({
+            ok: true,
+            action: "move",
+            lane_id: lane.lane_id,
+            state: lane.state,
+            host: lane.host,
+            account: lane.account ?? null,
+            moved: false,
+            reason: "already_on_target",
+            lane,
+        });
+    }
+    async function reportAlreadyOnTargetIfCurrent(hqRoot, laneId, provider, target, callerHost, runtimeHost, ctx) {
+        const current = await withLaneAdmissionLock(hqRoot, provider, async () => {
+            const lane = readLane(hqRoot, laneId);
+            if (!laneCanMoveBeforeStart(lane)) {
+                throw new LanesError(lane.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${lane.state}`, { lane_id: laneId, state: lane.state });
+            }
+            return sameHost(lane.host, target) ||
+                (laneRunsHere(lane, runtimeHost) && sameHost(callerHost, target))
+                ? lane
+                : undefined;
+        }, ctx.sleep);
+        if (current === undefined)
+            return false;
+        reportAlreadyOnTarget(current);
+        return true;
+    }
     function readLaneTimeout(hqRoot, laneId) {
         const raw = readJsonFile(timeoutPath(hqRoot, laneId));
         if (raw === null)
@@ -51,6 +83,22 @@ export function createLaneMoveHandlers(deps) {
             throw new LanesError(source.state === "queued" ? "lane_move_started" : "lane_not_queued", `Lane ${laneId} cannot move after it has started; current state is ${source.state}`, { lane_id: laneId, state: source.state });
         }
         const sourceHost = source.host;
+        const runtimeHost = reconcileHostFromCtx(ctx);
+        const runningHere = laneRunsHere(source, runtimeHost);
+        const callerHost = runtimeHost.outpostId
+            ? { kind: "outpost", id: runtimeHost.outpostId }
+            : { kind: "local", id: runtimeHost.hostname };
+        const explicitTarget = policy.kind === "local"
+            ? callerHost
+            : policy.kind === "outpost"
+                ? { kind: "outpost", id: policy.id }
+                : undefined;
+        if (explicitTarget !== undefined &&
+            (sameHost(sourceHost, explicitTarget) ||
+                (runningHere && sameHost(callerHost, explicitTarget)))) {
+            if (await reportAlreadyOnTargetIfCurrent(hqRoot, laneId, source.provider, explicitTarget, callerHost, runtimeHost, ctx))
+                return;
+        }
         const config = loadLanesConfig(hqRoot);
         const capacity = await loadHostCapacitySnapshots(ctx, hqRoot, config);
         let targetSnapshots = capacity.snapshots.filter((snapshot) => snapshot.host.kind !== sourceHost.kind || snapshot.host.id !== sourceHost.id);
@@ -69,8 +117,13 @@ export function createLaneMoveHandlers(deps) {
             ...(source.account !== undefined ? { account: source.account } : {}),
             ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
         });
+        if (sameHost(sourceHost, choice.host) ||
+            (runningHere && sameHost(callerHost, choice.host))) {
+            if (await reportAlreadyOnTargetIfCurrent(hqRoot, laneId, source.provider, choice.host, callerHost, runtimeHost, ctx))
+                return;
+        }
         let moved;
-        if (laneRunsHere(source, reconcileHostFromCtx(ctx))) {
+        if (runningHere) {
             moved = await commitLaneMove(ctx, laneId, choice.host, choice.account, placementEnabled);
         }
         else if (source.host.kind === "outpost") {

package/dist/commands/lanes-questions.js

@@ -20,7 +20,7 @@ export function resolveAnswerChoice(choice, options, freeform) {
     throw new LanesError("off_menu_choice", `Choice ${JSON.stringify(choice)} is not on the menu. Pass --freeform to allow it.`, { choice, options });
 }
 export function createLaneQuestionsHandlers(deps) {
-    const { CAPACITY_PROBE_TIMEOUT_MS, MAX_PLACEMENT_OUTPOSTS, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, assertLaneRunsHereForOperatorMutation, assertQuestionCompanyMatchesLane, casUpdateQuestion, effectiveLaneQuestionCompany, emitLaneMeshEvent, groupQuestionLanesByCompany, isQuestionAnswer, laneIsHostedHere, livenessDepsFromCtx, loadAllLanes, loadAllQuestions, mapWithConcurrency, mintMessageId, parseOutpostQuestionAudience, parseOutpostQuestionBody, parseRemoteJson, parseSeniorRef, questionCompanyForLane, questionCompanyRefMatches, questionListCompanyArg, readOutpostQuestionRecords, readQuestionBody, printJson, readSessionMeta, reconcileHostFromCtx, resolveActiveQuestionCompany, resolveAudience, sameQuestionAnswer, sameQuestionCompany, seniorOfSession, writeAnswerDeliveryFailed } = deps;
+    const { CAPACITY_PROBE_TIMEOUT_MS, MAX_PLACEMENT_OUTPOSTS, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, assertLaneRunsHereForOperatorMutation, assertQuestionAnswerAuthorized, assertQuestionCompanyMatchesLane, casUpdateQuestion, effectiveLaneQuestionCompany, emitLaneMeshEvent, groupQuestionLanesByCompany, isQuestionAnswer, laneIsHostedHere, livenessDepsFromCtx, loadAllLanes, loadAllQuestions, mapWithConcurrency, mintMessageId, parseOutpostQuestionAudience, parseOutpostQuestionBody, parseRemoteJson, parseSeniorRef, questionCompanyForLane, questionCompanyRefMatches, questionListCompanyArg, readOutpostQuestionRecords, readQuestionBody, printJson, readSessionMeta, reconcileHostFromCtx, resolveActiveQuestionCompany, resolveAudience, sameQuestionAnswer, sameQuestionCompany, seniorOfSession, writeAnswerDeliveryFailed } = deps;
     function requireQuestionBody(hqRoot, question) {
         const body = readQuestionBody(hqRoot, question);
         if (!body) {
@@ -73,10 +73,11 @@ export function createLaneQuestionsHandlers(deps) {
             return;
         throw new LanesError("question_not_pending", `Question ${current.question_id} is ${current.status}`, { question_id: current.question_id, status: current.status });
     }
-    async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
+    async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options, lookupErrors = []) {
         if (lane.host.kind !== "outpost") {
             throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to answer its question`, { lane_id: lane.lane_id, question_id: questionId });
         }
+        assertQuestionAnswerAuthorized(ctx, lane);
         const outpostId = lane.host.id;
         let dispatched;
         try {
@@ -224,6 +225,7 @@ export function createLaneQuestionsHandlers(deps) {
             outpost_id: outpostId,
             outpost_command_id: dispatched.commandId,
             outpost_transport: "outposts_exec",
+            ...(lookupErrors.length > 0 ? { lookup_errors: lookupErrors } : {}),
         });
     }
     async function readOutpostQuestionDetail(ctx, owner) {
@@ -280,6 +282,7 @@ export function createLaneQuestionsHandlers(deps) {
     }
     async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
         const hostedLanes = loadAllLanes(hqRoot).filter((lane) => lane.host.kind === "outpost" &&
+            !laneIsHostedHere(ctx, lane) &&
             (!companyFilter ||
                 effectiveLaneQuestionCompany(lane, hqRoot) === null ||
                 questionCompanyRefMatches(effectiveLaneQuestionCompany(lane, hqRoot), companyFilter)));
@@ -475,6 +478,8 @@ export function createLaneQuestionsHandlers(deps) {
                 .map((q) => {
                 const row = {
                     ...q,
+                    priority: q.priority ?? null,
+                    priority_display: q.priority ?? "-",
                     audience: resolveAudience(hqRoot, q, ctx),
                     ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
                 };
@@ -503,6 +508,8 @@ export function createLaneQuestionsHandlers(deps) {
             })
                 .map(({ question: q, host, audience }) => ({
                 ...q,
+                priority: q.priority ?? null,
+                priority_display: q.priority ?? "-",
                 host,
                 audience,
                 ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
@@ -580,13 +587,13 @@ export function createLaneQuestionsHandlers(deps) {
                 throw err;
             const company = explicitCompany ?? await resolveActiveQuestionCompany(ctx, "Cannot look up this lane question because the active HQ company could not be resolved; re-run with --company <slug>");
             const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company);
-            if (lookup.errors.length > 0) {
+            const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
+            if (matches.length === 0 && lookup.errors.length > 0) {
                 throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
                     question_id: questionId,
                     hosts: lookup.errors.map(({ host, error }) => ({ host, error })),
                 });
             }
-            const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
             if (matches.length === 0) {
                 const allCompanyLookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
                 const otherCompanyMatch = allCompanyLookup.questions.find((entry) => entry.question.question_id === questionId);
@@ -616,7 +623,7 @@ export function createLaneQuestionsHandlers(deps) {
             await dispatchOutpostQuestionAnswer(ctx, owner.lane, questionId, {
                 ...opts,
                 company: questionListCompanyArg(ownerCompany),
-            });
+            }, lookup.errors);
             return;
         }
         await yieldEventLoop();

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

@@ -376,6 +376,7 @@ export interface LaneQuestionsHandlerDeps {
     MAX_PLACEMENT_OUTPOSTS: number;
     OUTPOST_QUESTION_LOOKUP_CONCURRENCY: number;
     assertLaneRunsHereForOperatorMutation(ctx: Ctx, lane: LaneRecord, action: string): void;
+    assertQuestionAnswerAuthorized(ctx: Ctx, lane: LaneRecord): void;
     assertQuestionCompanyMatchesLane(question: QuestionRecord, lane: Pick<LaneRecord, "lane_id" | "company" | "mesh_company" | "project_id">, code: string, hqRoot?: string): void;
     casUpdateQuestion(hqRoot: string, questionId: string, updater: (current: QuestionRecord) => QuestionRecord): QuestionRecord;
     effectiveLaneQuestionCompany(lane: Pick<LaneRecord, "company" | "mesh_company" | "project_id" | "lane_id">, hqRoot?: string): LaneCompanyRef | null;
@@ -407,4 +408,20 @@ export interface LaneQuestionsHandlerDeps {
     seniorOfSession(hqRoot: string, sessionId: string, ctx: Ctx): SeniorRef;
     writeAnswerDeliveryFailed(hqRoot: string, laneId: string, questionId: string, err: unknown, at: string): void;
 }
+export interface LaneStoryHandlerDeps {
+    assertLaneRunsHereForOperatorMutation(ctx: Ctx, lane: LaneRecord, action: string): void;
+    casUpdateLane(hqRoot: string, laneId: string, updater: (current: LaneRecord) => LaneRecord): LaneRecord;
+    combinedStoryWarning(lane: LaneRecord, additional?: readonly string[]): string | null;
+    emitLaneMeshEvent(ctx: Ctx, company: LaneCompanyRef | null | undefined, threadId: string | undefined, event: LaneMeshEvent, payload: Record<string, unknown>): Promise<void>;
+    ensureLaneThreadRecord(ctx: Ctx, lane: LaneRecord, projectId?: string, storyId?: string, laneStatus?: string): Promise<LaneRecord>;
+    printJson(value: unknown): void;
+    readLane(hqRoot: string, laneId: string): LaneRecord;
+    storyBoardCheck(ctx: Ctx, company: LaneCompanyRef, projectId: string, storyIds: readonly string[]): Promise<{
+        warning?: string;
+        absentStoryIds: ReadonlySet<string>;
+    }>;
+    storyNotOnBoardWarning(err: unknown): string | undefined;
+    updateLane(hqRoot: string, laneId: string, expectedVersion: number, source: "command", updater: (current: LaneRecord) => LaneRecord): LaneRecord;
+    validateProjectStories(hqRoot: string, projectId: string, storyIds: string[], companySlug?: string): void;
+}
 //# sourceMappingURL=lanes-shared.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { Ctx, LaneStoryHandlerDeps } from "./lanes-shared.js";
+export interface StoryCommandOptions {
+    project?: string;
+    reason?: string;
+    verified?: boolean;
+}
+export declare function createLaneStoryHandlers(deps: LaneStoryHandlerDeps): {
+    runStoryList: (ctx: Ctx, laneId: string) => Promise<void>;
+    runStoryAdd: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
+    runStoryStart: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
+    runStoryBlock: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
+    runStoryDone: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
+};
+//# sourceMappingURL=lanes-stories.d.ts.map