@indigoai-us/hq-cli 5.293.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-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)));
@@ -584,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);
@@ -620,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