@indigoai-us/hq-cli 5.292.0 → 5.294.0

package/dist/fast-core.js

@@ -18,43 +18,71 @@ export async function runFastCore(argv) {
     const parsed = parseFastCore(argv);
     if (!parsed)
         return;
-    // `root: "live"` — resolve the live HQ root and run the script in it, exactly
-    // as core.ts's runEntry does. Fail soft: if no root can be resolved, run the
-    // script anyway with the inherited environment (the hook already carries
-    // CLAUDE_PROJECT_DIR, and each script has its own root fallback) rather than
-    // crashing a Stop hook on a resolution error.
+    const entry = parsed.entry;
+    // The full graph's process gate accepts textual true/false overrides. It ignores
+    // numeric env values, so preserve that behavior for family flags here too.
+    const familyEnabled = entry.kind !== "native" || !entry.familyFlagKey ||
+        await (await import("./native-fast-route.js")).fastFlagEnabled(entry.familyFlagKey, process.env, { numericEnvironmentOverride: false });
+    const useShell = entry.kind === "native" && Boolean(entry.familyFlagKey) && !familyEnabled;
+    const shouldInjectRoot = useShell
+        ? entry.shellHqRoot === "live" || (entry.shellHqRoot === "reconcile-default" &&
+            !parsed.args.includes("--hq-root") && !parsed.args.includes("--help") && !parsed.args.includes("-h"))
+        : entry.kind === "shell"
+            ? true
+            : entry.root === "live";
+    // `root: "live"` — resolve the live HQ root using the same resolver as the
+    // full command graph. Existing shell fast entries keep their historical
+    // fail-soft behavior; newly routed commands fall back to the full graph so
+    // its expected-user-error formatting remains authoritative.
     let hqRoot;
-    try {
-        hqRoot = resolveLiveRoot(parsed.hqRootArg ? { hqRoot: parsed.hqRootArg } : {});
-    }
-    catch {
-        hqRoot = undefined;
+    if (shouldInjectRoot) {
+        try {
+            hqRoot = resolveLiveRoot(parsed.hqRootArg ? { hqRoot: parsed.hqRootArg } : {});
+        }
+        catch {
+            if (entry.kind === "native") {
+                const { runCli } = await import("./main.js");
+                await runCli();
+                return;
+            }
+            hqRoot = undefined;
+        }
     }
-    if (parsed.entry.kind === "native") {
-        const handlerModule = await import(parsed.entry.modulePath);
-        const handler = handlerModule[parsed.entry.exportName];
+    if (entry.kind === "native" && !useShell) {
+        const { installFastPathStreamErrorHandlers } = await import("./utils/fast-stream-errors.js");
+        installFastPathStreamErrorHandlers();
+        const handlerModule = await import(entry.modulePath);
+        const handler = handlerModule[entry.exportName];
         if (typeof handler !== "function") {
-            throw new Error(`Native fast handler ${parsed.entry.exportName} was not exported`);
+            throw new Error(`Native fast handler ${entry.exportName} was not exported`);
         }
         const chunks = [];
-        for await (const chunk of process.stdin)
-            chunks.push(chunk);
-        const code = await handler(argv, Buffer.concat(chunks).toString("utf8"), process.cwd(), hqRoot);
+        if (entry.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);
         // Let Node drain handler output before terminating. The timeout guard's
         // stderr message must survive the native route's process boundary.
         process.exitCode = code;
         return;
     }
-    // Keep the CHILD in the caller's cwd, unlike the generic "live" dispatch. The
-    // relocated scripts read their data tree from the injected root, not cwd, and
-    // hq-session's Work Mesh registration serializes $PWD — so changing directory
-    // to the HQ root would mislabel a bind made from inside a project/worktree.
+    const asset = entry.asset;
+    if (!asset)
+        throw new Error(`Fast route ${entry.name} has no shell companion`);
+    // Some historical registrations run from the live root, others preserve the
+    // caller cwd and only inject HQ_ROOT. Keep those choices explicit per entry.
+    const cwd = entry.kind === "native" && entry.shellCwd === "live"
+        ? hqRoot ?? process.cwd()
+        : process.cwd();
+    const injectRoot = entry.kind === "shell" || entry.kind === "native" &&
+        (entry.shellHqRoot === "live" || entry.shellHqRoot === "reconcile-default" && shouldInjectRoot);
     const { code } = runBundledScript({
-        asset: parsed.entry.asset,
+        asset,
         args: parsed.args,
-        cwd: process.cwd(),
-        hqRoot,
-        env: parsed.entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : undefined,
+        cwd,
+        ...(injectRoot ? { hqRoot } : {}),
+        env: entry.name === "hq-session" ? { HQ_HQ_SESSION_NO_CLI: "1" } : undefined,
     });
     // Propagate verbatim: these scripts use their exit code as their interface.
     process.exit(code);

package/dist/fast-scaffold.d.ts

@@ -15,16 +15,29 @@ export type FastScaffoldScript = {
     kind: "shell";
     /** Path under `assets/scaffold/`, e.g. `core/scripts/foo.sh`. */
     asset: string;
+    root?: "live";
 } | {
-    /** Direct subcommand name — `hq core <name>`. */
+    /** Command path, joined with spaces, e.g. `policy frontmatter`. */
     name: string;
     kind: "native";
     /** Relative ESM module specifier, resolved from fast-core.js. */
     modulePath: string;
     /** Named export which accepts the native fast-handler contract. */
     exportName: string;
-    /** Default-off registry flag for this native route. */
+    /** Existing default-off gate for the whole fast route. */
     flagKey: string;
+    /** Existing family gate that chooses this native handler or its shell companion. */
+    familyFlagKey?: string;
+    /** Shell rollback companion used while the family gate is off. */
+    asset?: string;
+    /** Root context used by the native handler. */
+    root?: "live" | "cwd" | "passthrough";
+    /** Cwd used for a shell rollback companion. Defaults to the caller cwd. */
+    shellCwd?: "caller" | "live";
+    /** Root injection behavior for a shell rollback companion. */
+    shellHqRoot?: "none" | "live" | "reconcile-default";
+    /** Whether this handler consumes stdin. Shell companions inherit stdin directly. */
+    readsStdin?: boolean;
 };
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export declare const FAST_SCAFFOLD_SCRIPTS: readonly FastScaffoldScript[];

package/dist/fast-scaffold.js

@@ -11,15 +11,175 @@
  */
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export const FAST_SCAFFOLD_SCRIPTS = [
-    { name: "checkpoint-stop-gate", kind: "shell", asset: "core/scripts/checkpoint-stop-gate.sh" },
-    { name: "hq-session", kind: "shell", asset: "core/scripts/hq-session.sh" },
+    { name: "checkpoint-stop-gate", kind: "shell", asset: "core/scripts/checkpoint-stop-gate.sh", root: "live" },
+    { name: "hq-session", kind: "shell", asset: "core/scripts/hq-session.sh", root: "live" },
     {
         name: "timeout-guard",
         kind: "native",
         modulePath: "./lib/core-utils/timeout-guard-native.js",
         exportName: "runTimeoutGuardFast",
         flagKey: "hq-core-native-fast-route",
+        root: "cwd",
+        readsStdin: true,
     },
+    {
+        name: "policy frontmatter",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/read-policy-frontmatter.sh",
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
+    {
+        name: "policy age-report",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/policy-age-report.sh",
+        root: "live",
+        shellCwd: "caller",
+        shellHqRoot: "live",
+    },
+    {
+        name: "policy retire",
+        kind: "native",
+        modulePath: "./commands/core-policy.js",
+        exportName: "runPolicyFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/policy-retire.sh",
+        root: "live",
+        shellCwd: "caller",
+        shellHqRoot: "live",
+    },
+    {
+        name: "knowledge-prefs",
+        kind: "native",
+        modulePath: "./commands/core-knowledge-prefs.js",
+        exportName: "runKnowledgePrefsFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-policy",
+        asset: "core/scripts/knowledge-prefs.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    ...["finalize", "post", "open-steps"].map((name) => ({
+        name: `handoff ${name}`,
+        kind: "native",
+        modulePath: name === "open-steps"
+            ? "./commands/core-handoff-open-steps.js"
+            : "./commands/core-handoff-fast.js",
+        exportName: name === "open-steps" ? "runHandoffOpenStepsFast" : "runHandoffFastEntry",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: `core/scripts/handoff-${name === "open-steps" ? "open-steps" : name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    })),
+    {
+        name: "worktree-gc",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/worktree-gc.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    {
+        name: "clean-worktree-reconcile-handoff",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/clean-worktree-reconcile-handoff.sh",
+        root: "cwd",
+        shellCwd: "caller",
+        shellHqRoot: "none",
+    },
+    {
+        name: "resume-thread-lock",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/resume-thread-lock.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    {
+        name: "verify-story-deliverables",
+        kind: "native",
+        modulePath: "./lib/core-utils/worktree-resume.js",
+        exportName: "runWorktreeResumeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-handoff",
+        asset: "core/scripts/verify-story-deliverables.sh",
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    },
+    ...["schedule-parse", "validate", "reconcile"].map((name) => ({
+        name: `jobs ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-jobs-native.js",
+        exportName: "runJobsFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-jobs",
+        asset: `core/scripts/${name === "reconcile" ? "outpost-jobs-reconcile" : `jobs-${name}`}.sh`,
+        root: name === "reconcile" ? "passthrough" : "cwd",
+        shellCwd: "caller",
+        shellHqRoot: name === "reconcile" ? "reconcile-default" : "none",
+    })),
+    ...["resolve", "pickup", "repo", "secrets", "transfer"].map((name) => ({
+        name: `delegate ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-delegate.js",
+        exportName: "runDelegateFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-delegate",
+        asset: `core/scripts/hq-delegate-${name}.sh`,
+        root: name === "pickup" ? "cwd" : "live",
+        shellCwd: name === "pickup" ? "caller" : "live",
+        shellHqRoot: name === "pickup" ? "none" : "live",
+    })),
+    ...["bundle", "grant", "publish", "send", "verify"].map((name) => ({
+        name: `delegate ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-delegate-w1b.js",
+        exportName: "runDelegateW1bFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-delegate",
+        asset: `core/scripts/hq-delegate-${name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+    })),
+    ...["audience-grant", "brief", "candidate", "garden", "source-worklist", "source-yaml-validate"].map((name) => ({
+        name: `ontology ${name}`,
+        kind: "native",
+        modulePath: "./commands/core-ontology-native.js",
+        exportName: "runOntologyNativeFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-ontology",
+        asset: `core/scripts/${name === "audience-grant" ? "ontology-audience-grant" : name === "source-worklist" ? "ontology-source-worklist" : name === "source-yaml-validate" ? "source-yaml-validate" : `ontology-${name}`}.${name === "brief" || name === "garden" ? "mjs" : "sh"}`,
+        root: name === "source-yaml-validate" ? "cwd" : "live",
+        shellCwd: "caller",
+        shellHqRoot: name === "source-yaml-validate" ? "none" : "live",
+    })),
 ];
 /**
  * Parse the small, non-ambiguous `hq secrets env` surface for the gated entry
@@ -148,13 +308,13 @@ export function parseFastCore(argv) {
         hqRootArg = head.slice("--hq-root=".length);
         i += 1;
     }
-    const name = argv[i];
-    if (typeof name !== "string")
-        return null;
-    const entry = FAST_SCAFFOLD_SCRIPTS.find((candidate) => candidate.name === name);
+    const commandArgs = argv.slice(i);
+    const entry = [...FAST_SCAFFOLD_SCRIPTS]
+        .sort((left, right) => right.name.split(" ").length - left.name.split(" ").length)
+        .find((candidate) => candidate.name.split(" ").every((part, index) => commandArgs[index] === part));
     if (!entry)
         return null;
-    return { entry, hqRootArg, args: argv.slice(i + 1) };
+    return { entry, hqRootArg, args: argv.slice(i + entry.name.split(" ").length) };
 }
 /** Whether this invocation is a fast-path scaffold dispatch. */
 export function isFastCoreRequest(argv) {

package/dist/lib/core-utils/sentry-report.js

@@ -677,13 +677,13 @@ function scrubbedSentryEnvelope(event, overrides, additionalTags = {}) {
         ...sentryEnvelope(event, overrides, additionalTags),
     }, {});
 }
-/** Keep all hook-timeout conditions together by script while retaining tags for triage. */
+/** Group hook-timeout conditions by normalized kind while retaining triage tags. */
 function hookTimeoutExceededOverrides(event) {
     if (!isHookTimeoutEvent(event))
         return undefined;
     return {
         level: "warning",
-        fingerprint: ["hook-timeout", hookScript(event.metadata)],
+        fingerprint: ["hook-timeout", hookTimeoutKind(event)],
     };
 }
 /**

package/dist/lib/core-utils/worktree-resume.d.ts

@@ -15,4 +15,6 @@ export declare function runWorktreeGc(args: readonly string[], hqRoot: string, i
 export declare function runCleanWorktreeReconcileHandoff(args: readonly string[], io?: CoreIo): number;
 export declare function runResumeThreadLock(args: readonly string[], hqRoot: string, io?: CoreIo): number;
 export declare function runVerifyStoryDeliverables(args: readonly string[], hqRoot: string, io?: CoreIo): Promise<number>;
+/** Fast-entry adapter; family gating and shell fallback happen before import. */
+export declare function runWorktreeResumeFast(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined, commandName: string): Promise<number>;
 //# sourceMappingURL=worktree-resume.d.ts.map

package/dist/lib/core-utils/worktree-resume.js

@@ -1179,4 +1179,20 @@ export async function runVerifyStoryDeliverables(args, hqRoot, io = {}) {
         stdout(io, `verify-story-deliverables: ${storyId} — all ${refs.length} reference(s) present (${declaredCount} declared, ${refs.length - declaredCount} from worker evidence)${recordedSuffix}\n`);
     return 0;
 }
+/** Fast-entry adapter; family gating and shell fallback happen before import. */
+export async function runWorktreeResumeFast(args, _stdin, cwd, hqRoot, commandName) {
+    const root = hqRoot ?? cwd;
+    let code;
+    if (commandName === "worktree-gc")
+        code = runWorktreeGc(args, root);
+    else if (commandName === "clean-worktree-reconcile-handoff")
+        code = runCleanWorktreeReconcileHandoff(args);
+    else if (commandName === "resume-thread-lock")
+        code = runResumeThreadLock(args, root);
+    else
+        code = await runVerifyStoryDeliverables(args, root);
+    if (code !== 0)
+        process.exitCode = code;
+    return code;
+}
 //# sourceMappingURL=worktree-resume.js.map

package/dist/lib/daemon/migrate.d.ts

@@ -9,7 +9,9 @@
  * back. A unit whose stop fails is left where it was and not recorded.
  *
  * Units owned by another product (the desktop app's sync agent) are never
- * touched, and box system units need root. System units are recorded and
+ * touched, and box system units need root. Root on a box stops and restarts
+ * the login user's own units through that user's systemd manager, since
+ * root's `systemctl --user` reaches only root's. System units are recorded and
  * saved in root-owned storage (not the login user's daemon folder, which the
  * user can edit), and a restore checks each one lands in the system unit
  * folder, so nobody but root decides what gets installed there.
@@ -33,6 +35,11 @@ export interface MigrateDeps {
     systemRecordPath: string;
     /** Where box system units live (/etc/systemd/system); restores must land here. */
     systemUnitDir: string;
+    /** Root on a box: the login user whose systemd user units these are. */
+    userUnitsOwner?: {
+        user: string;
+        uid: number;
+    };
     now?: () => number;
     /** Tests inject a failing writer. */
     writeRecord?: (recordPath: string, units: AdoptedUnit[]) => void;

package/dist/lib/daemon/migrate.js

@@ -9,7 +9,9 @@
  * back. A unit whose stop fails is left where it was and not recorded.
  *
  * Units owned by another product (the desktop app's sync agent) are never
- * touched, and box system units need root. System units are recorded and
+ * touched, and box system units need root. Root on a box stops and restarts
+ * the login user's own units through that user's systemd manager, since
+ * root's `systemctl --user` reaches only root's. System units are recorded and
  * saved in root-owned storage (not the login user's daemon folder, which the
  * user can edit), and a restore checks each one lands in the system unit
  * folder, so nobody but root decides what gets installed there.
@@ -56,6 +58,18 @@ function must(run, cmd, args) {
     }
     return r.stdout;
 }
+/** `systemctl` for a unit: `--user` units go to their owner's manager, as that user when root acts for them. */
+function systemctl(unit, deps, args) {
+    if (unit.kind !== "systemd-user")
+        return ["systemctl", args];
+    const owner = deps.isRoot ? deps.userUnitsOwner : undefined;
+    if (!owner)
+        return ["systemctl", ["--user", ...args]];
+    return [
+        "runuser",
+        ["-u", owner.user, "--", "env", `XDG_RUNTIME_DIR=/run/user/${owner.uid}`, "systemctl", "--user", ...args],
+    ];
+}
 function moveFile(from, to) {
     ensurePrivateDir(path.dirname(to));
     try {
@@ -92,10 +106,9 @@ function adoptOne(unit, deps) {
         case "systemd-system": {
             if (!unit.path)
                 throw new Error(`no unit file path for ${unit.name}`);
-            const scope = unit.kind === "systemd-user" ? ["--user"] : [];
-            must(deps.run, "systemctl", [...scope, "disable", "--now", unit.name]);
+            must(deps.run, ...systemctl(unit, deps, ["disable", "--now", unit.name]));
             moveFile(unit.path, to);
-            deps.run("systemctl", [...scope, "daemon-reload"]);
+            deps.run(...systemctl(unit, deps, ["daemon-reload"]));
             return to;
         }
         case "schtasks": {
@@ -190,10 +203,9 @@ function restoreOne(unit, deps) {
             if (unit.kind === "systemd-system" && !deps.isRoot) {
                 throw new Error("a system unit; run `sudo hq daemon uninstall --restore-legacy`");
             }
-            const scope = unit.kind === "systemd-user" ? ["--user"] : [];
             moveBack(unit, unit.path);
-            deps.run("systemctl", [...scope, "daemon-reload"]);
-            must(deps.run, "systemctl", [...scope, "enable", "--now", unit.name]);
+            deps.run(...systemctl(unit, deps, ["daemon-reload"]));
+            must(deps.run, ...systemctl(unit, deps, ["enable", "--now", unit.name]));
             return;
         }
         case "schtasks":

package/dist/lib/daemon/run.d.ts

@@ -62,5 +62,16 @@ export declare function rotateLogs(logsDir: string, maxBytes?: number): number;
  * an on-failure unit down. The daemon's updater handles CLI updates.
  */
 export declare function unitProcessEnv(base: NodeJS.ProcessEnv, unit: UnitPlan): NodeJS.ProcessEnv;
+/**
+ * A systemd system unit starts the daemon as the login user without the
+ * variables a login session sets, so `systemctl --user` from its services
+ * cannot find the user bus ("Failed to connect to bus: No medium found").
+ * Point them at the user's runtime dir when it exists and nothing set one.
+ */
+export declare function withUserRuntimeDir(env: NodeJS.ProcessEnv, host: {
+    platform: NodeJS.Platform;
+    uid: number;
+    exists: (dir: string) => boolean;
+}): NodeJS.ProcessEnv;
 export declare function runDaemon(opts: RunDaemonOptions): Promise<number>;
 //# sourceMappingURL=run.d.ts.map

package/dist/lib/daemon/run.js

@@ -233,8 +233,24 @@ function isFifo(file) {
         return false;
     }
 }
+/**
+ * A systemd system unit starts the daemon as the login user without the
+ * variables a login session sets, so `systemctl --user` from its services
+ * cannot find the user bus ("Failed to connect to bus: No medium found").
+ * Point them at the user's runtime dir when it exists and nothing set one.
+ */
+export function withUserRuntimeDir(env, host) {
+    if (host.platform !== "linux" || host.uid === 0 || env.XDG_RUNTIME_DIR)
+        return env;
+    const dir = `/run/user/${host.uid}`;
+    return host.exists(dir) ? { ...env, XDG_RUNTIME_DIR: dir } : env;
+}
 export async function runDaemon(opts) {
-    const env = opts.env ?? process.env;
+    const env = withUserRuntimeDir(opts.env ?? process.env, {
+        platform: process.platform,
+        uid: process.getuid?.() ?? -1,
+        exists: fs.existsSync,
+    });
     const home = opts.home ?? os.homedir();
     const platform = process.platform;
     const paths = daemonPaths(home, env);

package/dist/lib/lanes/autopilot-metrics.d.ts

@@ -0,0 +1,99 @@
+export interface AutopilotMetricsLead {
+    team: string;
+    lane_id: string;
+    project_id: string;
+}
+export interface AutopilotMetricsLane {
+    lane_id: string;
+    project_id: string;
+    story_id: string;
+    senior: {
+        kind: string;
+        id?: string;
+    };
+    state: string;
+    created_at: string;
+    updated_at?: string;
+    ended_at?: string;
+    hire_grant?: number;
+    last_resume?: {
+        at?: string;
+    };
+    last_envelope?: {
+        at?: string;
+        artifacts?: unknown[];
+    };
+}
+export interface AutopilotMetricsStory {
+    id: string;
+    state?: string;
+    status?: string;
+    created_at?: string;
+    updated_at?: string;
+    prs?: unknown[];
+    lanes?: unknown[];
+}
+export interface AutopilotMetricsProject {
+    project_id: string;
+    stories: readonly AutopilotMetricsStory[];
+}
+export interface AutopilotMetricsNudge {
+    team: string;
+    at: string;
+}
+export interface AutopilotMetricsReview {
+    repo: string;
+    pr: number;
+    recorded_at: string;
+    worker_lane?: string | null;
+}
+export interface AutopilotMetricsResume {
+    lane_id: string;
+    at: string;
+}
+export interface AutopilotMetricsDefect {
+    at: string;
+    team: string;
+    defect: string;
+}
+export interface BuildAutopilotMetricsReportInput {
+    since: string;
+    until: string;
+    leads: readonly AutopilotMetricsLead[];
+    lanes: readonly AutopilotMetricsLane[];
+    projects: readonly AutopilotMetricsProject[];
+    reviews: readonly AutopilotMetricsReview[];
+    nudges: readonly AutopilotMetricsNudge[];
+    nudgeDefects: readonly AutopilotMetricsDefect[];
+    seniorResumes: readonly AutopilotMetricsResume[];
+}
+export interface AutopilotMetricsDay {
+    team: string;
+    day: string;
+    operator_nudges: number;
+    reviewed_lanes: number;
+    review_latency_minutes_total: number;
+    review_latency_minutes_average: number | null;
+    idle_slot_minutes_ready_work: number;
+}
+export interface AutopilotReviewLatency {
+    team: string;
+    lane_id: string;
+    story_id: string;
+    finished_at: string;
+    reviewed_at: string;
+    minutes: number;
+    end_event: "review_record" | "senior_resume" | "story_closed";
+}
+export interface AutopilotNudgeDefect extends AutopilotMetricsDefect {
+    wake: null;
+}
+export interface AutopilotMetricsReport {
+    since: string;
+    until: string;
+    days: AutopilotMetricsDay[];
+    review_latencies: AutopilotReviewLatency[];
+    nudge_defects: AutopilotNudgeDefect[];
+}
+export declare function buildAutopilotMetricsReport(input: BuildAutopilotMetricsReportInput): AutopilotMetricsReport;
+//# sourceMappingURL=autopilot-metrics.d.ts.map