@quickchatai/pi-quickreview 0.0.0-stage → 1.2.0

package/dist/src/pibuiltins.d.ts

@@ -0,0 +1,36 @@
+export declare const PI_DISABLED_BUILTINS: readonly ["-builtin:mcp", "-builtin:codemode", "-builtin:tool-search", "-builtin:llama.cpp"];
+/**
+ * pi 1.0.0 made the interactive TUI fullscreen by default (CHANGELOG 1.0.0,
+ * "Changed the default TUI mode to fullscreen"). Every interactive pi we run
+ * sits in tmux — the VM's PR sessions and overseer, the companion — and the
+ * operator TUI mirrors those panes and scrolls them (PgUp), which needs the
+ * terminal's normal scrollback: pi 0.99's default. The three entrypoint merges
+ * set it; tests/pibuiltins.test.ts pins each one to this value.
+ */
+export declare const PI_TUI_MODE = "regular";
+/** pi's agent-level retry for a benchmark sandbox — every session and every
+ * lens child reads it (one agent dir). pi's own default (3 attempts, ≤ 60 s
+ * apart) gives up inside two minutes, and a provider's overload window
+ * (DigitalOcean "529 Platform overloaded", or a request timeout) is longer than
+ * that: the lens is lost and the review posts without it. This backs off from
+ * 5 s doubling to a 2-minute cap over 10 attempts — about 13 minutes of
+ * patience per request — so a PR is processed fully and fails only when the
+ * provider is really unavailable. Provider-level retries stay off (pi's advice:
+ * they would hide quota and usage-limit errors from pi). */
+export declare const BENCH_RETRY: {
+    readonly enabled: true;
+    readonly maxRetries: 10;
+    readonly baseDelayMs: 5000;
+    readonly maxAgentDelayMs: 120000;
+};
+/** pi's global settings for the sandbox: pi's built-in extensions switched off
+ * (packages/pi-plugin/src/pibuiltins.ts — the reviewed checkout is exactly the untrusted ground a
+ * `.pi/mcp.json` would come from); every project trusted so no modal can stall
+ * a run; /opt/quickreview pre-trusted; and the durable retry above. No global
+ * bash-guard: every route that runs a model hands the guard to
+ * its sessions itself, as an `--extension` or a factory. */
+export declare function benchSettings(_root: string): {
+    settings: string;
+    trust: string;
+};
+//# sourceMappingURL=pibuiltins.d.ts.map

package/dist/src/pibuiltins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pibuiltins.d.ts","sourceRoot":"","sources":["../../src/pibuiltins.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,oBAAoB,8FAKvB,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,YAAY,CAAC;AAErC;;;;;;;;4DAQ4D;AAC5D,eAAO,MAAM,WAAW;;;;;CAKd,CAAC;AAEX;;;;;4DAK4D;AAC5D,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAchF"}

package/dist/src/pibuiltins.js

@@ -0,0 +1,83 @@
+// pi's built-in extensions that every surface we provision switches OFF.
+//
+// pi 0.99.0 started shipping four extensions INSIDE the package, loaded by
+// default: `builtin:mcp`, `builtin:codemode`, `builtin:tool-search` and
+// `builtin:llama.cpp` (dist/extensions/index.js `builtInExtensions`). The
+// documented switch is a `-builtin:<name>` entry in the GLOBAL settings'
+// `extensions` array (docs/settings.md "The built-in extensions are named …
+// `-builtin:mcp` disables one"; dist/core/package-manager.js resolves each
+// built-in through isEnabledByOverrides, where a `-` entry is an exact-match
+// force-exclude on the literal path `builtin:<name>`). A `+`/`-`/`!` entry in a
+// trusted PROJECT `.pi/settings.json` overrides the user setting — which is why
+// `.pi/` is also on bash-guard's policy surface.
+//
+// Why each one is off (none is used by any reviewer, lens, judge or companion):
+//  - mcp: launches stdio server PROCESSES and opens HTTP connections from an
+//    `mcp.json` — global, or a trusted project's `.pi/mcp.json`, and every
+//    project is trusted (`defaultProjectTrust = "always"`). A process launch
+//    that never passes through a tool call, so bash-guard never sees it.
+//  - codemode: a QuickJS tool that runs model-written scripts calling the
+//    other tools. Registered inactive, but one `defaultTools: ["+codemode"]`
+//    in a project settings file activates it — a changed tool set.
+//  - tool-search: declares not-yet-declared tools mid-session (MCP's deferred
+//    tools); a changed tool set, and useless without MCP.
+//  - llama.cpp: registers a model provider that talks to a local llama.cpp
+//    server (127.0.0.1:8080 by default). Starts nothing, but it is a model
+//    route nobody configured; off so the provider set stays the one we pin.
+//
+// VERIFY-ON-PIN (0.99.1, re-read at 1.0.0, 1.3.0 and 1.4.0 — dist/extensions/index.js unchanged): the four names and
+// the `-builtin:<name>` spelling. A later pi that adds a built-in is NOT
+// covered by this list — re-read dist/extensions/index.js on every bump.
+//
+// The mirrors (plain JS, they run before any build): the release image's
+// entrypoint (docker/entrypoint.sh, the VM's too), the companion's
+// (docker/companion/entrypoint.sh)
+// and the sandbox settings below (`benchSettings`, the bench's and
+// `qcr review`'s). tests/pibuiltins.test.ts pins every mirror to this list.
+export const PI_DISABLED_BUILTINS = [
+    "-builtin:mcp",
+    "-builtin:codemode",
+    "-builtin:tool-search",
+    "-builtin:llama.cpp",
+];
+/**
+ * pi 1.0.0 made the interactive TUI fullscreen by default (CHANGELOG 1.0.0,
+ * "Changed the default TUI mode to fullscreen"). Every interactive pi we run
+ * sits in tmux — the VM's PR sessions and overseer, the companion — and the
+ * operator TUI mirrors those panes and scrolls them (PgUp), which needs the
+ * terminal's normal scrollback: pi 0.99's default. The three entrypoint merges
+ * set it; tests/pibuiltins.test.ts pins each one to this value.
+ */
+export const PI_TUI_MODE = "regular";
+/** pi's agent-level retry for a benchmark sandbox — every session and every
+ * lens child reads it (one agent dir). pi's own default (3 attempts, ≤ 60 s
+ * apart) gives up inside two minutes, and a provider's overload window
+ * (DigitalOcean "529 Platform overloaded", or a request timeout) is longer than
+ * that: the lens is lost and the review posts without it. This backs off from
+ * 5 s doubling to a 2-minute cap over 10 attempts — about 13 minutes of
+ * patience per request — so a PR is processed fully and fails only when the
+ * provider is really unavailable. Provider-level retries stay off (pi's advice:
+ * they would hide quota and usage-limit errors from pi). */
+export const BENCH_RETRY = {
+    enabled: true,
+    maxRetries: 10,
+    baseDelayMs: 5_000,
+    maxAgentDelayMs: 120_000,
+};
+/** pi's global settings for the sandbox: pi's built-in extensions switched off
+ * (packages/pi-plugin/src/pibuiltins.ts — the reviewed checkout is exactly the untrusted ground a
+ * `.pi/mcp.json` would come from); every project trusted so no modal can stall
+ * a run; /opt/quickreview pre-trusted; and the durable retry above. No global
+ * bash-guard: every route that runs a model hands the guard to
+ * its sessions itself, as an `--extension` or a factory. */
+export function benchSettings(_root) {
+    return {
+        settings: JSON.stringify({
+            extensions: [...PI_DISABLED_BUILTINS],
+            defaultProjectTrust: "always",
+            retry: BENCH_RETRY,
+        }, null, 2) + "\n",
+        trust: JSON.stringify({ "/opt/quickreview": true }, null, 2) + "\n",
+    };
+}
+//# sourceMappingURL=pibuiltins.js.map

package/dist/src/pibuiltins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pibuiltins.js","sourceRoot":"","sources":["../../src/pibuiltins.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,EAAE;AACF,2EAA2E;AAC3E,wEAAwE;AACxE,0EAA0E;AAC1E,yEAAyE;AACzE,4EAA4E;AAC5E,2EAA2E;AAC3E,6EAA6E;AAC7E,gFAAgF;AAChF,gFAAgF;AAChF,iDAAiD;AACjD,EAAE;AACF,gFAAgF;AAChF,6EAA6E;AAC7E,2EAA2E;AAC3E,6EAA6E;AAC7E,yEAAyE;AACzE,0EAA0E;AAC1E,6EAA6E;AAC7E,mEAAmE;AACnE,8EAA8E;AAC9E,0DAA0D;AAC1D,2EAA2E;AAC3E,2EAA2E;AAC3E,4EAA4E;AAC5E,EAAE;AACF,qHAAqH;AACrH,yEAAyE;AACzE,yEAAyE;AACzE,EAAE;AACF,yEAAyE;AACzE,mEAAmE;AACnE,mCAAmC;AACnC,mEAAmE;AACnE,4EAA4E;AAC5E,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,cAAc;IACd,mBAAmB;IACnB,sBAAsB;IACtB,oBAAoB;CACZ,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC;AAErC;;;;;;;;4DAQ4D;AAC5D,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,EAAE;IACd,WAAW,EAAE,KAAK;IAClB,eAAe,EAAE,OAAO;CAChB,CAAC;AAEX;;;;;4DAK4D;AAC5D,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO;QACL,QAAQ,EACN,IAAI,CAAC,SAAS,CACZ;YACE,UAAU,EAAE,CAAC,GAAG,oBAAoB,CAAC;YACrC,mBAAmB,EAAE,QAAQ;YAC7B,KAAK,EAAE,WAAW;SACnB,EACD,IAAI,EACJ,CAAC,CACF,GAAG,IAAI;QACV,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,kBAAkB,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI;KACpE,CAAC;AACJ,CAAC"}

package/dist/src/plankey.d.ts

@@ -0,0 +1,4 @@
+/** What a preview's key covers: change any of it and a start quoting the old
+ * key is refused — the operator always saw the price of what runs. */
+export declare function planKey(parts: unknown): string;
+//# sourceMappingURL=plankey.d.ts.map

package/dist/src/plankey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plankey.d.ts","sourceRoot":"","sources":["../../src/plankey.ts"],"names":[],"mappings":"AAKA;sEACsE;AACtE,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE9C"}

package/dist/src/plankey.js

@@ -0,0 +1,10 @@
+// The key a start must quote: a hash of everything a preview showed. A leaf
+// with only a node import, shared by `qcr scan` (src/setup/scan.ts) and
+// `qcr review` (packages/pi-plugin/src/localreview.ts) so neither reaches into the other.
+import { createHash } from "node:crypto";
+/** What a preview's key covers: change any of it and a start quoting the old
+ * key is refused — the operator always saw the price of what runs. */
+export function planKey(parts) {
+    return createHash("sha256").update(JSON.stringify(parts)).digest("hex").slice(0, 16);
+}
+//# sourceMappingURL=plankey.js.map

package/dist/src/plankey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plankey.js","sourceRoot":"","sources":["../../src/plankey.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,wEAAwE;AACxE,0FAA0F;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;sEACsE;AACtE,MAAM,UAAU,OAAO,CAAC,KAAc;IACpC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACvF,CAAC"}

package/dist/src/planner.d.ts

@@ -0,0 +1,375 @@
+import type { CoreConfig } from "./reviewconfig.js";
+import { type Ecosystem } from "./ecosystem.js";
+import type { PrFileEntry } from "./githubcore.js";
+import type { HeuristicsExtension } from "./heuristics.js";
+import { type CiLinter } from "./lintconfig.js";
+import type { MigrationCollision } from "./migrations.js";
+import { type PrOwnedDelta, type PrOwnedDeltaFile } from "./prdelta.js";
+import type { PriorFindingsList } from "./priorfindings.js";
+import type { LedgerCarry, PassPlanEntry, PassTier, RoundDelta, RoundOrder, RoundRecoveryContext, RoundType } from "./types.js";
+/** A plan's lens names, each once, in plan order — the compatibility list
+ * the rounds table, the event log and every order carry (a lens with several
+ * rows, the sweep, once). */
+export declare function lensesOf(plan: readonly PassPlanEntry[]): string[];
+/** The head a round reviews: the prepared tree's, else the PR row's (a
+ * caller with no worktree seam). The one rule the round row, the posting key
+ * and the prompt all name their head by. */
+export declare function reviewedHeadOf(tree: Pick<PreparedTree, "head_sha"> | undefined, row: Pick<PlannedPr, "head_sha">): string;
+/**
+ * The tier the round's validator runs at: its own tier, the configured
+ * `validate_tier` under the profile's `min_tier` for it, whatever tier or
+ * effort any lens runs at. It is never raised to match a lens: a finding the
+ * validator cannot stand behind is kept as `doubted` in the findings record
+ * (never posted, shown in the TUI), not discarded, so a cheaper validator
+ * cannot make a stronger lens's finding vanish. Lens tiers are deliberately
+ * not an input.
+ */
+export declare function validatorTier(cfg: Pick<CoreConfig, "lenses" | "models">): PassTier;
+/**
+ * The tier a lens ADDED by the session runs at (the round templates' add
+ * rule): a risk pass exists only as `sol-high`; every other lens at `sol-med`,
+ * or at the profile's `min_tier` for it when that is higher.
+ */
+export declare function addTierOf(cfg: CoreConfig, lens: string): PassTier;
+/** The facts a prepared worktree hands the round — the tree's own, less
+ * where it lives (the app's worktree facts add the path). */
+export interface PreparedTree {
+    /** The sha the worktree is actually checked out at — the authority for the
+     * round. It is the just-fetched `refs/pull/<n>/head`, or the caller's
+     * `expectedHead` when that ref lags behind it. */
+    head_sha: string;
+    /** Branch the PR targets; "" when the caller did not supply one. */
+    base_ref: string;
+    /** Tip of base_ref at fetch time; "" when no base_ref was fetched. */
+    base_sha: string;
+    /** merge-base(base_sha, head_sha); "" when unavailable. */
+    merge_base: string;
+    /** Set when GitHub's `refs/pull/<n>/head` lagged the head the caller expected
+     * and the worktree holds that head instead: the stale commit the ref named. */
+    pull_ref_sha?: string;
+}
+/** The PR a round is planned for: the fields of its state row the plan reads. */
+export interface PlannedPr {
+    number: number;
+    head_sha: string;
+    title: string;
+}
+/** What `buildPassPlan` returns. */
+export interface PassPlan {
+    pass_plan: PassPlanEntry[];
+    addable_lenses: string[];
+    sweep_unswept: string[];
+    /** Files the behaviour-delta lens would read but its group cap left out —
+     * present only when the cap cut something, so a capped lens never reads
+     * as covering the change. */
+    behaviour_unread?: string[];
+}
+/** Deterministic per-round pass plan (agent = `${lens}--${tier}`):
+ * - risk passes are always "sol-high", single variant, not raisable;
+ * - pass-validate runs at validatorTier() — its own configured tier, never
+ *   raised to match a lens — is not raisable, and is always last;
+ * - every other selected lens gets the passTier() tier and may be raised to
+ *   any higher tier's variant (ascending order).
+ * addable_lenses = every known pass not already in the plan.
+ * The rows come back in launch order, slowest first (`slowestFirst`).
+ *
+ * The profile's per-lens tuning (`cfg.lenses`) wins over all of
+ * that: a `min_tier` floors the lens's row (and so its `raisable_to`) and the
+ * sweep rows; `enabled = false` removes a lens from the plan AND the addable
+ * list whatever selected it — the validator included, when the round
+ * has no validator row at all; `enabled = true` on a lever-gated lens switches
+ * it on whatever its `[review]` lever says. */
+export declare function buildPassPlan(cfg: CoreConfig, files: PrFileEntry[], intent?: {
+    title?: string | null;
+    body?: string | null;
+}, 
+/** Whose tier-forcing gate applies. Default Django; `none` never forces
+ * sol-med off a migrations path. */
+ecosystem?: Ecosystem, 
+/** Profile lens-heuristics extension; absent ⇒ generic core. */
+heuristics?: HeuristicsExtension, 
+/** The repo's written style guide references (packages/pi-plugin/src/styleguide.ts); empty or
+ * absent ⇒ the style lens only on the profile's guide, if any. */
+styleGuide?: readonly string[], 
+/** The linters and formatters a CI job of the repo runs (packages/pi-plugin/src/lintconfig.ts);
+ * empty or absent ⇒ no lint-conformance row. */
+ciLinters?: readonly CiLinter[], 
+/** `tierFiles` — the files the round's default TIER is chosen from, when
+ * the plan is built over fewer files than the PR (a follow-up round plans
+ * from the delta, but a small fix push keeps the PR's tier and its
+ * migration floor). Absent ⇒ `files`. */
+opts?: {
+    tierFiles?: PrFileEntry[];
+}): PassPlan;
+/**
+ * The plan's rows in LAUNCH order — the expected-slowest first.
+ *
+ * The session launches a turn's rows in table order, and the lens runner
+ * (packages/pi-plugin/src/engine/lens/runlens.ts) runs them under a process-wide cap in that order,
+ * so a 15–27 row plan runs in waves: a slow row listed late starts in the
+ * last wave and sets the round's critical path (typically pass-baseline,
+ * sol-high sweep and behaviour-delta rows). The order:
+ * pass-baseline; then by tier, highest first; within a tier the risk passes,
+ * then the focused rows (behaviour-delta, then sweep) by the changed lines
+ * their focus covers, larger first, then every other lens, then the cheap
+ * conditional lenses (`CHEAP_LAST_PASSES`); pass-validate stays last. Ties
+ * keep their planned order (a stable sort).
+ *
+ * Only the ORDER moves — the same rows, each byte-identical. Every consumer
+ * that indexes rows (the task files, `lenses`, lesson rows, the recorded
+ * pass_plan) reads this one array, so they agree. Exported for
+ * `planFollowUp`, which splices a carried row into an already-ordered plan.
+ */
+export declare function slowestFirst(rows: readonly PassPlanEntry[], files: readonly PrFileEntry[], risk: ReadonlySet<string>): PassPlanEntry[];
+/** Why a non-first round runs as a full re-review: every doubt is a full
+ * round, never a quieter one. */
+export type FollowUpFullReason = "follow_up_full" | "no-reviewed-head" | "no-adapter" | "delta-too-large" | "baseline-unplanned" | "delta-threw" | "patch-write-failed" | Exclude<PrOwnedDelta, {
+    ok: true;
+}>["reason"];
+/** A follow-up round's plan, decided before the round row exists. */
+export interface FollowUpDecision {
+    delta: Extract<PrOwnedDelta, {
+        ok: true;
+    }>;
+    /** The reviewed head the delta was computed from. */
+    fromSha: string;
+    deltaFiles: PrFileEntry[];
+    plan: PassPlan;
+    /** The pre-approval sweep's plan — the whole PR's full plan — when owed. */
+    sweepPlan?: PassPlanEntry[];
+    /** The full plan's files left over the per-round sweep cap — carried with
+     * `sweepPlan`, so the sweep is told what it does not cover, as round 1 is. */
+    sweepUnswept?: string[];
+    sweepBehaviourUnread?: string[];
+    /** `follow_up_extent = "session"`: the full delta plan's rows the
+     * lean core left out — per-file sweep rows, quality and style lenses —
+     * offered to the session as optional rows. */
+    optionalPlan?: PassPlanEntry[];
+}
+/**
+ * The reads a follow-up decision makes of the PR's review history — exactly
+ * these, so the planner holds no store. The bot passes its state store, which
+ * answers both.
+ */
+export interface FollowUpHistory {
+    /** The PR's rounds (only these fields are read). */
+    roundsFor(pr: number): ReadonlyArray<{
+        backfilled: number;
+        head_sha: string | null;
+        merge_base: string | null;
+        verdict: string | null;
+        round_no: number;
+    }>;
+    /** Has a full look happened since the PR's first round? */
+    fullLookSinceFirst(pr: number): boolean;
+}
+/** The PR-owned delta between two reviewed heads, as the decision asks for it. */
+export type PrOwnedDeltaReader = (q: {
+    pr: number;
+    from: string;
+    to: string;
+    mergeBase: string;
+    baseSha?: string;
+    /** The merge base the reviewed round recorded, when known. */
+    fromMergeBase?: string;
+}) => Promise<PrOwnedDelta>;
+/**
+ * Decide whether a non-first round is a FOLLOW-UP round
+ * (docs/follow-up-rounds.md), and plan it. Total: any doubt — the knob, no
+ * reviewed-head mark, no git seam, a delta git could not compute, a delta
+ * above `follow_up_max_delta_ratio` of the PR's diff lines, a delta plan
+ * without pass-baseline — answers `{full: reason}`, and the caller runs a
+ * full re-review.
+ *
+ * The plan is built over the DELTA's files with the intent text arms off
+ * (the title and body did not change since the last review), its tier chosen
+ * from the WHOLE PR. The sweep is owed as `followUpSweepOwed` decides (the
+ * standing verdict not APPROVE and no full look since the first round, or a
+ * large enough post-approval delta); its plan is
+ * the whole PR's full plan, exactly as a full round would run it.
+ */
+export declare function decideFollowUp(deps: {
+    cfg: CoreConfig;
+    history: FollowUpHistory;
+    /** The PR-owned delta reader (`WorktreeManager.prOwnedDelta`). Absent ⇒
+     * `{full: "no-adapter"}`. */
+    prOwnedDelta?: PrOwnedDeltaReader;
+    heuristics?: HeuristicsExtension;
+}, args: {
+    pr: number;
+    markHead: string | null | undefined;
+    tree: {
+        head_sha: string;
+        base_sha: string;
+        merge_base: string;
+    } | undefined;
+    files: PrFileEntry[];
+    fullPlan: PassPlan;
+    standing: string | null;
+    /** An approval-withheld mark stood when this round was picked up: the
+     * standing APPROVE never reached GitHub, so it is not an approval the
+     * sweep may rely on (a withheld approval is an approval yet to be posted). */
+    approvalWithheld?: boolean;
+    ecosystem: Ecosystem;
+    styleGuide: readonly string[];
+    ciLinters: readonly CiLinter[];
+}): Promise<{
+    kind: "delta";
+    decision: FollowUpDecision;
+} | {
+    kind: "full";
+    reason: FollowUpFullReason;
+    detail?: Record<string, unknown>;
+}>;
+/**
+ * Whether a follow-up round owes the pre-approval sweep, the
+ * `[review] follow_up_sweep` knob aside. Before a posted approval (a withheld
+ * one never reached GitHub, so it counts as none): owed until a full look has
+ * happened since the first round. After a posted approval: owed only when the
+ * change since it reaches `follow_up_post_approval_sweep_lines` — a large push
+ * onto an approved PR is where live re-reviews found blockers outside the
+ * change; a small one stays delta-only.
+ */
+export declare function followUpSweepOwed(cfg: CoreConfig, args: {
+    standing: string | null;
+    approvalWithheld: boolean;
+    fullLookSinceFirst: () => boolean;
+    deltaLines: number;
+}): boolean;
+/**
+ * The PURE half of `decideFollowUp`: given a computed delta, plan
+ * the follow-up round — or answer `{full: reason}`. The daemon reaches it
+ * through `decideFollowUp`; the bench's follow-up replay (src/bench/
+ * followup.ts) calls it directly with a delta computed by the same
+ * `WorktreeManager.prOwnedDelta` over its replay tree, so the two never
+ * disagree about what a follow-up round plans.
+ *
+ * `sweepOwed` is consulted only when the `[review] follow_up_sweep` knob is on
+ * and the plan stands: the daemon's answer reads the standing verdict and the
+ * store; the bench's is the recorded case's.
+ */
+export declare function planFollowUp(cfg: CoreConfig, heuristics: HeuristicsExtension | undefined, args: {
+    delta: Extract<PrOwnedDelta, {
+        ok: true;
+    }>;
+    fromSha: string;
+    files: PrFileEntry[];
+    fullPlan: PassPlan;
+    ecosystem: Ecosystem;
+    styleGuide: readonly string[];
+    ciLinters: readonly CiLinter[];
+    /** Handed the delta's line count. */
+    sweepOwed: (deltaLines: number) => boolean;
+}): {
+    kind: "delta";
+    decision: FollowUpDecision;
+} | {
+    kind: "full";
+    reason: FollowUpFullReason;
+    detail?: Record<string, unknown>;
+};
+/** The lenses a lean follow-up plan offers as addable instead of planning. */
+export declare const LEAN_ADDABLE_PASSES: readonly string[];
+/**
+ * The LEAN follow-up plan: the plan without its per-file
+ * pass-sweep rows, and with the quality and style lenses moved to
+ * `addable_lenses`. Every other row — baseline, the triggered risk lenses,
+ * the validator — is kept as planned, and so is a quality or style row the
+ * plan marks `required` (one the operator made a risk pass): a required row
+ * is an obligation, never an offer. No lens leaves the round: a session that
+ * sees a quality or style question in the change adds the lens.
+ */
+export declare function leanFollowUpPlan(plan: PassPlan): PassPlan;
+/** A delta's files as one git-style patch (the hunks `prOwnedDelta` read,
+ * each under its file header). */
+export declare function renderDeltaPatch(files: readonly PrOwnedDeltaFile[]): string;
+/** The order's view of a delta (types.ts `RoundDelta`). */
+export declare function roundDeltaOf(d: FollowUpDecision, patchFile: string): RoundDelta;
+/** The order the follow-up round's OPTIONAL rows render their task files
+ * from: the follow-up order itself — the change since the last
+ * review stays their scope — with `optional_plan` as its plan. Prior
+ * findings ride the core rows only (their assignment indexes `pass_plan`),
+ * so none ride here. Pure. */
+export declare function optionalOrderOf(order: RoundOrder, optionalPlan: PassPlanEntry[]): RoundOrder;
+/** The order the pre-approval sweep's task files render from: the
+ * follow-up order minus its follow-up fields, planned with the whole PR's
+ * full plan — exactly the order a full round would hand its lenses. Pure;
+ * the daemon and the bench's follow-up replay render the sweep's tasks from
+ * it alike. */
+export declare function sweepOrderOf(order: RoundOrder, sweepPlan: PassPlanEntry[]): RoundOrder;
+/** Build the round order for one PR — pure once the files list is in hand. */
+export declare function buildRoundOrder(args: {
+    cfg: CoreConfig;
+    row: PlannedPr;
+    files: PrFileEntry[];
+    roundId: number;
+    roundNo: number;
+    /** Prior VERDICTED rounds + 1 — the PR's review age. Drives the nit cap;
+     * failed (cancelled/overdue) rounds advance round_no but not this. */
+    reviewNo?: number;
+    roundType: RoundType;
+    worktree: string;
+    settledDigest: string;
+    /** The PR's mirrored ledger; absent ⇒ no `ledger_carry`. */
+    ledgerCarry?: LedgerCarry;
+    issuedAt: string;
+    /** Facts established by preparing the worktree. Absent only for callers with
+     * no worktree seam (the stub-wired daemon core and unit tests), which fall
+     * back to the PR row's sha and an unknown base. */
+    tree?: PreparedTree;
+    /** Collisions the pre-check found — delivered as a COMMENT unless
+     * `migrationCollisionsUndelivered` says the COMMENT did not reach the PR. */
+    migrationCollisions?: MigrationCollision[];
+    /** True when the collisions' COMMENT was withheld, refused or failed: the
+     * gate note then hands the remedy to the session. */
+    migrationCollisionsUndelivered?: boolean;
+    /** True when the PR touches migrations and the pre-check could NOT run —
+     * the prompt must tell the session to check collisions itself. */
+    migrationPrecheckDegraded?: boolean;
+    /** First-party directive files + the picked escalation mention. */
+    firstPartyDirectives?: {
+        files: string[];
+        mention: string;
+    };
+    /** The PR body as GitHub returned it: pass-intent's whole intent
+     * artifact and the substance-bar input. Absent (stub-wired core, unit tests
+     * without an adapter body) ⇒ the intent lens is never selected. */
+    prBody?: string;
+    /** The round's ecosystem. Absent ⇒ Django. */
+    ecosystem?: Ecosystem;
+    /** Exact predecessor identity for a pre-fanout recovery successor. */
+    recovery?: RoundRecoveryContext;
+    /** Profile lens-heuristics extension; absent ⇒ generic core. */
+    heuristics?: HeuristicsExtension;
+    /** The names the order launches lenses in (`SessionHooks.lensRuntime`): the
+     * worker host's engine tools. Absent ⇒ native, the tmux host's. */
+    lensRuntime?: "engine";
+    /** The rendered third-party-sources block (packages/pi-plugin/src/depsources.ts). */
+    dependencyNote?: string;
+    /** The repo's written style guide references (packages/pi-plugin/src/styleguide.ts). */
+    styleGuide?: readonly string[];
+    /** The linters a CI job of the repo runs (packages/pi-plugin/src/lintconfig.ts). */
+    ciLinters?: readonly CiLinter[];
+    /** The plan, already built by the caller (dispatch builds it once and
+     * records the same plan on the round row). Absent ⇒ built here from
+     * `files`, the PR body, the style guide and the linters. */
+    plan?: PassPlan;
+    /** A FOLLOW-UP round's facts: the delta, the prior findings note, the owed
+     * sweep's plan. The coverage check then holds the round to the delta's
+     * files. Absent ⇒ a full round's order. */
+    followUp?: {
+        delta: RoundDelta;
+        deltaFiles: PrFileEntry[];
+        priorFindingsNote: string;
+        /** The listed prior findings: each is assigned to the plan row that owns
+         * it and written into that row's task file. Absent (the list could not be
+         * assembled) ⇒ the session assigns them. */
+        priorFindings?: Pick<PriorFindingsList, "findings" | "round_no">;
+        /** The optional rows the session decides (`optional_plan`). */
+        optionalPlan?: PassPlanEntry[];
+        sweepPlan?: PassPlanEntry[];
+        sweepUnswept?: string[];
+        sweepBehaviourUnread?: string[];
+    };
+}): RoundOrder;
+//# sourceMappingURL=planner.d.ts.map

package/dist/src/planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/planner.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGlE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAqBnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAI3D,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAI1D,OAAO,EAAkB,KAAK,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACxF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG5D,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,QAAQ,EAER,UAAU,EACV,UAAU,EACV,oBAAoB,EACpB,SAAS,EACV,MAAM,YAAY,CAAC;AAEpB;;6BAE6B;AAC7B,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,EAAE,CAEjE;AAED;;4CAE4C;AAC5C,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,GAAG,SAAS,EAChD,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,GAC/B,MAAM,CAER;AAQD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,QAAQ,GAAG,QAAQ,CAAC,GAAG,QAAQ,CAElF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAIjE;AAED;6DAC6D;AAC7D,MAAM,WAAW,YAAY;IAC3B;;sDAEkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB;mFAC+E;IAC/E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,iFAAiF;AACjF,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,oCAAoC;AACpC,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB;;iCAE6B;IAC7B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;+CAc+C;AAC/C,wBAAgB,aAAa,CAC3B,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,WAAW,EAAE,EACpB,MAAM,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AACxD;oCACoC;AACpC,SAAS,GAAE,SAA4B;AACvC,gEAAgE;AAChE,UAAU,CAAC,EAAE,mBAAmB;AAChC;kEACkE;AAClE,UAAU,GAAE,SAAS,MAAM,EAAO;AAClC;gDACgD;AAChD,SAAS,GAAE,SAAS,QAAQ,EAAO;AACnC;;;yCAGyC;AACzC,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,WAAW,EAAE,CAAA;CAAO,GACvC,QAAQ,CA6OV;AAWD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,aAAa,EAAE,EAC9B,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,GACxB,aAAa,EAAE,CA2BjB;AAED;iCACiC;AACjC,MAAM,MAAM,kBAAkB,GAC1B,gBAAgB,GAChB,kBAAkB,GAClB,YAAY,GACZ,iBAAiB,GACjB,oBAAoB,GACpB,aAAa,GACb,oBAAoB,GACpB,OAAO,CAAC,YAAY,EAAE;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC,CAAC;AAElD,qEAAqE;AACrE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC,YAAY,EAAE;QAAE,EAAE,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IAC3C,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,WAAW,EAAE,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,4EAA4E;IAC5E,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IAC5B;kFAC8E;IAC9E,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC;;kDAE8C;IAC9C,YAAY,CAAC,EAAE,aAAa,EAAE,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,oDAAoD;IACpD,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,CAAC;QACnC,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;IACH,2DAA2D;IAC3D,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;CACzC;AAED,kFAAkF;AAClF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,EAAE;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAE5B;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE;IACJ,GAAG,EAAE,UAAU,CAAC;IAChB,OAAO,EAAE,eAAe,CAAC;IACzB;iCAC6B;IAC7B,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,UAAU,CAAC,EAAE,mBAAmB,CAAC;CAClC,EACD,IAAI,EAAE;IACJ,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACpC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IAC7E,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;kFAE8E;IAC9E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;CAChC,GACA,OAAO,CACN;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CACjF,CAgDA;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,UAAU,EACf,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,kBAAkB,EAAE,MAAM,OAAO,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB,GACA,OAAO,CAQT;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,UAAU,EACf,UAAU,EAAE,mBAAmB,GAAG,SAAS,EAC3C,IAAI,EAAE;IACJ,KAAK,EAAE,OAAO,CAAC,YAAY,EAAE;QAAE,EAAE,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC/B,qCAAqC;IACrC,SAAS,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C,GAEC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAiGjF;AAKD,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAAoC,CAAC;AAEtF;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAazD;AAED;kCACkC;AAClC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAkB3E;AAED,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CAe/E;AAED;;;;8BAI8B;AAC9B,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,UAAU,CAO5F;AAED;;;;eAIe;AACf,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,UAAU,CA0BtF;AAED,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,GAAG,EAAE,UAAU,CAAC;IAChB,GAAG,EAAE,SAAS,CAAC;IACf,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;0EACsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB;;uDAEmD;IACnD,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB;iFAC6E;IAC7E,mBAAmB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC3C;yDACqD;IACrD,8BAA8B,CAAC,EAAE,OAAO,CAAC;IACzC;sEACkE;IAClE,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,mEAAmE;IACnE,oBAAoB,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5D;;uEAEmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,gEAAgE;IAChE,UAAU,CAAC,EAAE,mBAAmB,CAAC;IACjC;uEACmE;IACnE,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,qFAAqF;IACrF,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,wFAAwF;IACxF,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,oFAAoF;IACpF,SAAS,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IAChC;;gEAE4D;IAC5D,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB;;+CAE2C;IAC3C,QAAQ,CAAC,EAAE;QACT,KAAK,EAAE,UAAU,CAAC;QAClB,UAAU,EAAE,WAAW,EAAE,CAAC;QAC1B,iBAAiB,EAAE,MAAM,CAAC;QAC1B;;oDAE4C;QAC5C,aAAa,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,UAAU,CAAC,CAAC;QACjE,+DAA+D;QAC/D,YAAY,CAAC,EAAE,aAAa,EAAE,CAAC;QAC/B,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;QAC5B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;KACjC,CAAC;CACH,GAAG,UAAU,CAoIb"}