dorfl 0.0.0 → 0.1.0

package/dist/tasker-review-loop.d.ts

@@ -0,0 +1,249 @@
+import { type Harness } from './harness.js';
+import { ReviewParseError, type ReviewFinding, type ReviewVerdict, type UncertainTask } from './review-verdict.js';
+export type { TaskEdit, UncertainTask } from './review-verdict.js';
+export { parseReviewVerdict as parseTaskReviewVerdict } from './review-verdict.js';
+/**
+ * **The tasker review→edit→re-review→converge LOOP** (`slicer-review-edit-loop`,
+ * GATES prd `work/prds/ready/review.md` RESOLVED DESIGN — Shape 2 / insertion point A).
+ *
+ * On the `do prd:<slug>` tasking path (`tasking.ts`/`performTask`), AFTER the
+ * agent produces a candidate set of `work/tasks/backlog/<slug>.md` tasks and BEFORE the
+ * runner finalises/lands them, this loop RUNS the `review` SKILL
+ * (`skills/review/SKILL.md`), APPLIES its findings as EDITS to the candidate task
+ * files, then re-reviews — until a pass finds NO NEW blocking issue (the natural
+ * terminator) or the `taskerLoopMax` hard cap is hit. It is an IMPROVER, NOT a one-shot
+ * gate: tasks measurably keep getting better when reviewed, so the findings feed
+ * back into edits, repeatedly. The destination/goal check is part of the SAME
+ * review pass (it can itself trigger edits — which is why it is a loop).
+ *
+ * Two axes (the M×N grid from the idea file):
+ *   - **N** — the in-context multipass: ONE agent reviews AND edits in a single
+ *     context, accumulating findings across angle-switched passes. `taskerLoopMax` caps
+ *     N so the loop can never run forever.
+ *
+ *     ⚠️ ASPIRATION-VS-BUILT (2026-06-10): the "single context" wording above is the
+ *     prd's ASPIRATION, NOT what this module does at runtime. The ACTUAL N loop is
+ *     RUNNER-DRIVEN and PER-PASS: `runOneExecution` does `for (pass …) { gate(…);
+ *     applyEdits(…to disk…) }` — ONE agent LAUNCH per pass, the runner writing the
+ *     agent's edits to the candidate task FILES (`work/tasks/backlog/`) between passes, the
+ *     next pass's agent re-reading the edited files. Accumulation is via DISK +
+ *     re-launch, NOT one agent retaining context. `prd/review.md` §Shape 2 is internally
+ *     contradictory on this (single-context headline vs "edit the files" operative spec);
+ *     this code implements the operative reading. See
+ *     `work/findings/review-edit-loop-single-context-is-unbuilt-aspiration-vs-per-pass-disk-impl.md`.
+ *     (Relevant to intake: PR #62's lone-task loop mirrors this per-pass STRUCTURE but
+ *     accumulates IN-MEMORY, because intake must not write to `work/tasks/backlog/` pre-emit.)
+ *   - **M** — fresh-context re-executions: a fresh context is simply a NEW EXECUTION
+ *     of that same loop in a fresh harness launch (like the Gate-2 reviewer). The
+ *     loop is implemented ONCE; M is invoking it again. `M=1` is the cheap default;
+ *     `M=k` runs k independent fresh loops.
+ *
+ * This module wires the loop + edit-application + verdict routing AROUND the
+ * `review` SKILL — it does NOT re-author the protocol (the lenses + the destination
+ * check live in the skill). The agent makes the review/edit JUDGEMENTS through the
+ * {@link TaskReviewGate} seam; this module applies the edits to disk and routes
+ * the final verdict to the THREE outcomes (folded in from the deleted
+ * `autotask-confidence`, decision B):
+ *
+ *   - **converge** (a pass found no NEW blocking issue) → the improved tasks land
+ *     claimable.
+ *   - **a specific uncertain task** → emit it `needsAnswers: true` with the
+ *     questions in its body (created, not agent-buildable until a human answers).
+ *   - **the whole decomposition unclear / `taskerLoopMax` exhausted with blockers** →
+ *     route the prd to `work/needs-attention/<slug>.md` with the questions as the
+ *     reason, emitting NO guessed tasks.
+ *
+ * The verdict sink itself (the git transitions for those three outcomes) is the
+ * caller's (`tasking.ts`): this module decides WHICH outcome and prepares the
+ * edits/questions; the runner owns every git-state transition (the agent does no
+ * git, here as everywhere).
+ */
+/**
+ * Backwards-compatible alias for {@link ReviewFinding}. Existing imports keep
+ * compiling; new code should reach for `ReviewFinding` from `review-verdict.ts`.
+ */
+export type TaskReviewFinding = ReviewFinding;
+/**
+ * The tasker-loop verdict shape is now the UNIFIED {@link ReviewVerdict}
+ * (task `review-protocol-doc-and-shared-machinery`). The tasker consumes the
+ * `edits` / `uncertainTasks` / `decompositionUnclear` channels; other review
+ * callers consume different channels of the same wide type. This alias keeps
+ * existing imports compiling; the standalone `TaskReviewVerdict` is retired.
+ */
+export type TaskReviewVerdict = ReviewVerdict;
+/** What the review gate needs to launch a fresh-context review+edit pass. */
+export interface TaskReviewGateInput {
+    /** The prd slug whose candidate tasks are under review. */
+    slug: string;
+    /** The working clone/checkout the loop runs in (candidate tasks live here). */
+    cwd: string;
+    /** Repo-relative paths of the candidate tasks currently on disk. */
+    candidateTasks: string[];
+    /** Which review PASS this is (1-based) within the current fresh context (the N). */
+    pass: number;
+    /** Which fresh-context EXECUTION this is (1-based) — the M. */
+    execution: number;
+    /**
+     * The model the IMPROVER-loop REVIEW agent runs on (de-correlated from the
+     * tasker; the `--tasker-loop-model` family). `undefined` ⇒ no forced model.
+     * Flows through `LaunchInput.model` / `substituteModel`. DISTINCT from the
+     * acceptance gate's `reviewModel`.
+     */
+    taskerLoopModel?: string;
+    /** The HOST-ONLY sessions root the review session FILE is generated under. */
+    sessionsDir?: string;
+    /** Environment for the review-agent launch. */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * The tasker-review-loop SEAM: run ONE fresh-context review+edit pass of the
+ * candidate tasks and return a parsed verdict (incl. the edits to apply). Injected
+ * by tests (a canned verdict+edits, no real model); production uses
+ * {@link harnessTaskReviewGate}. Mirrors `do`'s `DoDorfl` / Gate-2's
+ * `ReviewGate` injectable-seam shape so the loop wiring is testable as pure logic.
+ */
+export type TaskReviewGate = (input: TaskReviewGateInput) => Promise<TaskReviewVerdict>;
+/** The terminal disposition of the loop — the three RESOLVED-DESIGN outcomes. */
+export type LoopOutcome = 
+/** A pass found no NEW blocking issue: the improved tasks land claimable. */
+'converged'
+/** `taskerLoopMax` hit with blockers → specific uncertain task(s) → needsAnswers. */
+ | 'uncertain-tasks'
+/** `taskerLoopMax` hit / decomposition unclear → route the prd to needs-attention. */
+ | 'decomposition-unclear';
+/** The result of running the loop — the disposition the caller's sink routes. */
+export interface RunTaskReviewLoopResult {
+    /** Which of the three outcomes the loop reached. */
+    outcome: LoopOutcome;
+    /**
+     * The candidate tasks as they stand AFTER all applied edits, keyed by
+     * repo-relative path → final content. The caller commits these (on
+     * `converged`/`uncertain-tasks`) — on `decomposition-unclear` it emits NO
+     * tasks, so this is informational only.
+     */
+    tasks: Record<string, string>;
+    /**
+     * On `uncertain-tasks`: the specific tasks to emit `needsAnswers: true` with
+     * the questions recorded in their bodies. Empty otherwise.
+     */
+    uncertainTasks: UncertainTask[];
+    /**
+     * On `decomposition-unclear`: the questions to record as the spec's
+     * needs-attention reason (no guessed tasks emitted). Empty otherwise.
+     */
+    specQuestions: string[];
+    /** How many review passes ran in total across all M executions. */
+    passes: number;
+    /** How many fresh-context executions (M) ran. */
+    executions: number;
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+}
+export interface RunTaskReviewLoopOptions {
+    /** The prd slug whose candidate tasks are being improved. */
+    slug: string;
+    /** The working clone/checkout the loop runs in. */
+    cwd: string;
+    /** The review+edit gate seam (tests inject a canned verdict; production: harness). */
+    gate: TaskReviewGate;
+    /**
+     * **The SCOPING FENCE (the requeue fix).** A snapshot of `work/tasks/backlog/` taken
+     * BEFORE this tasking run produced its candidate tasks (filename → content;
+     * the `before` map `performTask` already computes at step 3). The loop reviews,
+     * edits, and flags ONLY the tasks that are NEW or CHANGED vs this snapshot —
+     * i.e. THIS run's own output — NEVER the pre-existing, already-landed tasks
+     * that share the same `work/tasks/backlog/` directory (the normal steady state). On a
+     * populated backlog this is what keeps the loop from editing / `needsAnswers`-
+     * flagging unrelated tasks and sweeping them into the runner-owned tasking
+     * commit. Omitted ⇒ an EMPTY snapshot (every `work/tasks/backlog/*.md` is treated as
+     * this run's output — the legacy whole-directory behaviour, kept only for the
+     * degenerate empty-backlog case / direct callers that pass none).
+     */
+    before?: Map<string, string>;
+    /**
+     * The HARD CAP on in-context review passes (N) per fresh context. Reaching it
+     * with unresolved blockers REJECTS via the sink (never an infinite loop). The
+     * natural terminator (no new blocking issue) usually fires first.
+     */
+    taskerLoopMax: number;
+    /**
+     * How many fresh-context EXECUTIONS (M) to run — each a NEW launch of the same
+     * loop in a fresh context. Default 1 (the cheap degenerate case). `M>1` runs M
+     * independent fresh loops; the first that converges wins, else the last
+     * execution's blocking verdict is routed.
+     */
+    executions?: number;
+    /** The model the improver-loop review agent runs on (de-correlation; `--tasker-loop-model`). */
+    taskerLoopModel?: string;
+    /** The HOST-ONLY sessions root for the review session file. */
+    sessionsDir?: string;
+    /** Environment for child processes. */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+/**
+ * Run the tasker review→edit→converge loop over the candidate tasks currently on
+ * disk under `work/tasks/backlog/`. Implements the loop ONCE; M (fresh-context
+ * re-executions) is just invoking the inner loop again with a fresh launch.
+ *
+ * Within ONE execution (the N): run the gate (a review+edit pass), APPLY its edits
+ * to the candidate task files, then re-review — until `verdict === 'approve'` (no
+ * NEW blocking issue → converged) or the pass count reaches `taskerLoopMax`. On the cap
+ * with a still-`block` verdict, ROUTE per the verdict's channels:
+ *   - `decompositionUnclear` set ⇒ `decomposition-unclear` (prd → needs-attention,
+ *     no guessed tasks);
+ *   - else `uncertainTasks` (or, as a floor, every candidate task) ⇒
+ *     `uncertain-tasks` (those tasks emitted `needsAnswers: true` + questions).
+ *
+ * With `executions > 1`, the WHOLE loop is re-run in a fresh context; the first
+ * execution that converges short-circuits and lands, otherwise the LAST
+ * execution's blocking routing is taken (a persistent block across M fresh
+ * contexts is a strong signal).
+ */
+export declare function runTaskReviewLoop(options: RunTaskReviewLoopOptions): Promise<RunTaskReviewLoopResult>;
+/** What a harness-backed task-review gate needs to launch the review agent. */
+export interface HarnessTaskReviewGateOptions {
+    /** The harness seam used to launch the fresh-context review+edit agent. */
+    harness?: Harness;
+    /** The agent command the null/shell adapter shells out to (`{model}`-aware). */
+    agentCmd?: string;
+    /**
+     * Read the review agent's textual output for parsing. Production reads
+     * `launched.output` (the harness seam's ANSWER channel, task
+     * `harness-agent-output`); tests inject `readOutput` to stub a canned verdict
+     * string. Defaults to the launch's `output` verbatim.
+     */
+    readOutput?: (output: string | undefined) => string;
+}
+/**
+ * Backwards-compatible alias for {@link ReviewParseError} — unified across all
+ * review callers. New code should reach for `ReviewParseError` directly.
+ */
+export declare const TaskReviewParseError: typeof ReviewParseError;
+export type TaskReviewParseError = ReviewParseError;
+/**
+ * The PRODUCTION tasker-review gate: launch the `review` SKILL as a fresh-context
+ * agent through the EXISTING harness seam (a fresh context per pass = a fresh
+ * launch, like the Gate-2 reviewer), routing the `reviewModel` override via
+ * `LaunchInput.model` (the §13 model-routing intent — NOT a new mechanism), then
+ * parse the emitted `{verdict, findings, edits, …}`.
+ *
+ * The agent makes the review/edit JUDGEMENTS (it runs the skill's lenses + the
+ * destination check and proposes edits); this gate only launches it and parses its
+ * verdict. The runner (the loop) applies the edits to disk and routes the verdict —
+ * the agent does no git / no escaping disk writes.
+ */
+export declare function harnessTaskReviewGate(options?: HarnessTaskReviewGateOptions): TaskReviewGate;
+/**
+ * Render the task-review-loop PROMPT: instruct a fresh-context agent to run the
+ * `review` SKILL on the candidate tasks for `slug` (the lenses IN ORDER, ENDING in
+ * the destination/goal check — which may itself trigger edits), and to EMIT a
+ * single JSON object carrying the verdict, the findings, the EDITS to apply, and
+ * the routing channels (so {@link parseTaskReviewVerdict} can read it). The skill
+ * carries the protocol; this prompt frames the artifact (a candidate decomposition)
+ * + the required output shape (incl. the improver `edits` and the two non-converge
+ * routing channels).
+ */
+export declare function buildTaskReviewPrompt(input: TaskReviewGateInput): string;
+//# sourceMappingURL=tasker-review-loop.d.ts.map

package/dist/tasker-review-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasker-review-loop.d.ts","sourceRoot":"","sources":["../src/tasker-review-loop.ts"],"names":[],"mappings":"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"}

package/dist/tasker-review-loop.js

@@ -0,0 +1,369 @@
+import { readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { workFolderPrefix, workFolderPath, workItemRel, stripWorkFolderPrefix, isWorkItemFile, } from './work-layout.js';
+import { NullHarness } from './harness.js';
+import { launchWithOptionalWatch } from './agent-launch.js';
+import { parseReviewVerdict, ReviewParseError, reviewDisciplinePrompt, verdictContractPrompt, } from './review-verdict.js';
+export { parseReviewVerdict as parseTaskReviewVerdict } from './review-verdict.js';
+/**
+ * Run the tasker review→edit→converge loop over the candidate tasks currently on
+ * disk under `work/tasks/backlog/`. Implements the loop ONCE; M (fresh-context
+ * re-executions) is just invoking the inner loop again with a fresh launch.
+ *
+ * Within ONE execution (the N): run the gate (a review+edit pass), APPLY its edits
+ * to the candidate task files, then re-review — until `verdict === 'approve'` (no
+ * NEW blocking issue → converged) or the pass count reaches `taskerLoopMax`. On the cap
+ * with a still-`block` verdict, ROUTE per the verdict's channels:
+ *   - `decompositionUnclear` set ⇒ `decomposition-unclear` (prd → needs-attention,
+ *     no guessed tasks);
+ *   - else `uncertainTasks` (or, as a floor, every candidate task) ⇒
+ *     `uncertain-tasks` (those tasks emitted `needsAnswers: true` + questions).
+ *
+ * With `executions > 1`, the WHOLE loop is re-run in a fresh context; the first
+ * execution that converges short-circuits and lands, otherwise the LAST
+ * execution's blocking routing is taken (a persistent block across M fresh
+ * contexts is a strong signal).
+ */
+export async function runTaskReviewLoop(options) {
+    const note = options.note ?? (() => { });
+    const executions = Math.max(1, options.executions ?? 1);
+    const taskerLoopMax = Math.max(1, options.taskerLoopMax);
+    // The SCOPING FENCE: review/edit/flag ONLY this run's own new-or-changed
+    // tasks, never pre-existing landed ones (the requeue fix). No snapshot ⇒ an
+    // empty one (the legacy whole-directory behaviour for the empty-backlog case).
+    const before = options.before ?? new Map();
+    let totalPasses = 0;
+    let last;
+    for (let m = 1; m <= executions; m++) {
+        if (executions > 1) {
+            note(`Tasker review loop — fresh context ${m}/${executions}.`);
+        }
+        const exec = await runOneExecution({
+            slug: options.slug,
+            cwd: options.cwd,
+            gate: options.gate,
+            taskerLoopMax,
+            execution: m,
+            before,
+            taskerLoopModel: options.taskerLoopModel,
+            sessionsDir: options.sessionsDir,
+            env: options.env,
+            note,
+        });
+        totalPasses += exec.passes;
+        last = exec;
+        if (exec.converged) {
+            note(`Tasker review loop converged after ${exec.passes} pass(es)` +
+                (executions > 1 ? ` in fresh context ${m}/${executions}` : '') +
+                '; the improved tasks land.');
+            return {
+                outcome: 'converged',
+                tasks: readCandidates(options.cwd, before),
+                uncertainTasks: [],
+                specQuestions: [],
+                passes: totalPasses,
+                executions: m,
+                message: `Tasked '${options.slug}' — the review→edit loop converged ` +
+                    `(${totalPasses} pass(es), ${m} fresh context(s)); no new blocking ` +
+                    'issue. The improved tasks land claimable.',
+            };
+        }
+    }
+    // Every execution hit `taskerLoopMax` with unresolved blockers — REJECT via the
+    // sink. The LAST execution's verdict carries the routing channels.
+    const verdict = last.lastVerdict;
+    if (verdict.decompositionUnclear) {
+        const questions = verdict.decompositionUnclear.questions;
+        note(`Tasker review loop did not converge within taskerLoopMax=${taskerLoopMax} ` +
+            `across ${executions} fresh context(s); the whole decomposition is ` +
+            'unclear — routing the prd to needs-attention (no guessed tasks).');
+        return {
+            outcome: 'decomposition-unclear',
+            tasks: readCandidates(options.cwd, before),
+            uncertainTasks: [],
+            specQuestions: questions,
+            passes: totalPasses,
+            executions,
+            message: `The decomposition of '${options.slug}' is still unclear after ` +
+                `taskerLoopMax=${taskerLoopMax} review pass(es) across ${executions} fresh ` +
+                'context(s); routing the prd to needs-attention with the open ' +
+                'questions, emitting no guessed tasks.',
+        };
+    }
+    // A specific-task rejection: emit the uncertain task(s) `needsAnswers: true`.
+    // SCOPED to THIS run's own output (the requeue fix): an agent-named uncertain
+    // task that is NOT one of this run's new-or-changed tasks is DROPPED (the
+    // agent must never flag a pre-existing landed task). Floor: if the agent named
+    // none (or named only out-of-scope ones) but still blocks, treat THIS run's own
+    // candidates as uncertain — never land a task the loop could not approve, never
+    // silently drop the rejection, but never escape to unrelated tasks.
+    const ownPaths = new Set(newOrChangedBacklog(options.cwd, before));
+    const named = (verdict.uncertainTasks ?? []).filter((u) => {
+        const normalized = u.path.replace(/\\/g, '/');
+        if (ownPaths.has(normalized)) {
+            return true;
+        }
+        note(`Dropped an uncertain-task flag on ${u.path} — not one of THIS run’s ` +
+            'own candidate tasks (the loop never flags pre-existing landed tasks).');
+        return false;
+    });
+    const uncertain = named.length > 0
+        ? named
+        : [...ownPaths].sort().map((path) => ({
+            path,
+            questions: blockingQuestions(verdict),
+        }));
+    note(`Tasker review loop did not converge within taskerLoopMax=${taskerLoopMax} across ` +
+        `${executions} fresh context(s); emitting ${uncertain.length} uncertain ` +
+        'task(s) with needsAnswers + questions.');
+    return {
+        outcome: 'uncertain-tasks',
+        tasks: readCandidates(options.cwd, before),
+        uncertainTasks: uncertain,
+        specQuestions: [],
+        passes: totalPasses,
+        executions,
+        message: `Tasking '${options.slug}' did not converge after taskerLoopMax=${taskerLoopMax} ` +
+            `review pass(es) across ${executions} fresh context(s); ` +
+            `${uncertain.length} task(s) emitted needsAnswers: true with the open ` +
+            'questions in their bodies (a human must answer before they are buildable).',
+    };
+}
+/** Run ONE fresh-context execution of the in-context (N) review→edit loop. */
+async function runOneExecution(params) {
+    const { slug, cwd, gate, taskerLoopMax, execution, before, note } = params;
+    let lastVerdict = { verdict: 'block', findings: [] };
+    let passes = 0;
+    for (let pass = 1; pass <= taskerLoopMax; pass++) {
+        // SCOPED: only THIS run's own new-or-changed tasks are reviewed — a task
+        // the loop CREATED in an earlier pass is new-vs-`before` so it is in scope;
+        // a pre-existing landed task is unchanged so it is NOT (the requeue fix).
+        const candidateTasks = newOrChangedBacklog(cwd, before);
+        const verdict = await gate({
+            slug,
+            cwd,
+            candidateTasks,
+            pass,
+            execution,
+            taskerLoopModel: params.taskerLoopModel,
+            sessionsDir: params.sessionsDir,
+            env: params.env,
+        });
+        passes = pass;
+        lastVerdict = verdict;
+        // APPLY the edits to the candidate task files (the improver step) — the
+        // runner writes the agent's full-content edits; the agent does no disk/git.
+        // SCOPED to this run's own output: an edit may improve a task THIS run
+        // produced or CREATE a new candidate, but NEVER overwrite a pre-existing
+        // landed task (the requeue fix).
+        if (verdict.edits && verdict.edits.length > 0) {
+            applyEdits(cwd, verdict.edits, before, note);
+        }
+        if (verdict.verdict === 'approve') {
+            return { converged: true, lastVerdict: verdict, passes };
+        }
+        note(`Tasker review pass ${pass}/${taskerLoopMax} (context ${execution}) found ` +
+            `${blockingCount(verdict)} blocking issue(s); ` +
+            `${verdict.edits?.length ?? 0} edit(s) applied — re-reviewing.`);
+    }
+    return { converged: false, lastVerdict, passes };
+}
+/**
+ * Apply the review agent's full-content edits to the candidate task files. ONLY
+ * paths under `work/tasks/backlog/` are written — the loop improves the CANDIDATE TASKS,
+ * never escapes to other parts of the tree (a defensive scope fence; the runner,
+ * not the agent, performs the write). An edit may CREATE a new candidate task file
+ * (e.g. the review split one task into two) — that is in-scope.
+ *
+ * **SCOPED to this run's own output (the requeue fix).** Beyond the
+ * `work/tasks/backlog/` prefix fence, an edit is only applied when its target is THIS
+ * run's own task: either a path NOT present in the `before` snapshot (a task this
+ * run created, or a new file the review is splitting out) OR one this run already
+ * changed vs `before`. A pre-existing, unchanged landed task (present in `before`
+ * with identical content) is REFUSED — the loop must never edit an unrelated,
+ * already-landed task and sweep it into the runner-owned tasking commit.
+ */
+function applyEdits(cwd, edits, before, note) {
+    for (const edit of edits) {
+        const normalized = edit.path.replace(/\\/g, '/');
+        const filename = stripWorkFolderPrefix(normalized, 'tasks-backlog');
+        if (filename === undefined || normalized.includes('..')) {
+            note(`Skipped a review edit outside ${workFolderPrefix('tasks-backlog')} (${edit.path}) — the ` +
+                'loop only improves candidate tasks.');
+            continue;
+        }
+        // A pre-existing task this run did NOT touch must not be overwritten: it is
+        // in `before` and the current on-disk content still equals the snapshot.
+        if (before.has(filename)) {
+            const abs = join(cwd, normalized);
+            let current;
+            try {
+                current = readFileSync(abs, 'utf8');
+            }
+            catch {
+                current = undefined;
+            }
+            if (current !== undefined && current === before.get(filename)) {
+                note(`Skipped a review edit to the pre-existing landed task ${edit.path} ` +
+                    '— the loop only improves THIS run’s own candidate tasks.');
+                continue;
+            }
+        }
+        const abs = join(cwd, normalized);
+        writeFileSync(abs, edit.content);
+    }
+}
+/**
+ * Repo-relative paths of the `work/tasks/backlog/*.md` files that are NEW or CHANGED vs
+ * the `before` snapshot — exactly THIS tasking run's own output (the requeue-fix
+ * scoping fence). A pre-existing task present in `before` with identical content
+ * is excluded; a file the loop created (absent from `before`) or improved (content
+ * differs) is included. Mirrors `tasking.ts`'s `newOrChangedBacklog`.
+ */
+function newOrChangedBacklog(cwd, before) {
+    const dir = workFolderPath(cwd, 'tasks-backlog');
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of entries) {
+        if (!isWorkItemFile(name)) {
+            continue;
+        }
+        const content = readFileSync(join(dir, name), 'utf8');
+        if (before.get(name) !== content) {
+            out.push(workItemRel('tasks-backlog', name));
+        }
+    }
+    return out.sort();
+}
+/**
+ * THIS run's candidate tasks keyed by repo-relative path → current content —
+ * scoped to the new-or-changed set (never the pre-existing landed tasks).
+ */
+function readCandidates(cwd, before) {
+    const out = {};
+    for (const rel of newOrChangedBacklog(cwd, before)) {
+        out[rel] = readFileSync(join(cwd, rel), 'utf8');
+    }
+    return out;
+}
+/** Count blocking findings in a verdict. */
+function blockingCount(verdict) {
+    return verdict.findings.filter((f) => f.severity === 'blocking').length;
+}
+/** The blocking findings' questions (the floor questions for an unnamed rejection). */
+function blockingQuestions(verdict) {
+    const blocking = verdict.findings.filter((f) => f.severity === 'blocking');
+    const source = blocking.length > 0 ? blocking : verdict.findings;
+    return source.map((f) => f.context ? `${f.question} (${f.context})` : f.question);
+}
+/**
+ * Backwards-compatible alias for {@link ReviewParseError} — unified across all
+ * review callers. New code should reach for `ReviewParseError` directly.
+ */
+export const TaskReviewParseError = ReviewParseError;
+/**
+ * The PRODUCTION tasker-review gate: launch the `review` SKILL as a fresh-context
+ * agent through the EXISTING harness seam (a fresh context per pass = a fresh
+ * launch, like the Gate-2 reviewer), routing the `reviewModel` override via
+ * `LaunchInput.model` (the §13 model-routing intent — NOT a new mechanism), then
+ * parse the emitted `{verdict, findings, edits, …}`.
+ *
+ * The agent makes the review/edit JUDGEMENTS (it runs the skill's lenses + the
+ * destination check and proposes edits); this gate only launches it and parses its
+ * verdict. The runner (the loop) applies the edits to disk and routes the verdict —
+ * the agent does no git / no escaping disk writes.
+ */
+export function harnessTaskReviewGate(options = {}) {
+    const harness = options.harness ?? new NullHarness();
+    const readOutput = options.readOutput ?? ((output) => output ?? '');
+    return async (input) => {
+        const launched = await launchWithOptionalWatch({
+            harness,
+            dir: input.cwd,
+            slug: input.slug,
+            command: options.agentCmd ?? '',
+            prompt: buildTaskReviewPrompt(input),
+            model: input.taskerLoopModel,
+            // A DISTINCT session id per pass + fresh context so launches never collide.
+            sessionId: `task-review-${input.slug}-m${input.execution}-n${input.pass}`,
+            sessionsDir: input.sessionsDir,
+            env: input.env,
+        });
+        if (!launched.ok) {
+            throw new ReviewParseError(`task review agent launch failed${launched.detail ? `: ${launched.detail}` : ''}`);
+        }
+        return parseReviewVerdict(readOutput(launched.output));
+    };
+}
+/**
+ * Render the task-review-loop PROMPT: instruct a fresh-context agent to run the
+ * `review` SKILL on the candidate tasks for `slug` (the lenses IN ORDER, ENDING in
+ * the destination/goal check — which may itself trigger edits), and to EMIT a
+ * single JSON object carrying the verdict, the findings, the EDITS to apply, and
+ * the routing channels (so {@link parseTaskReviewVerdict} can read it). The skill
+ * carries the protocol; this prompt frames the artifact (a candidate decomposition)
+ * + the required output shape (incl. the improver `edits` and the two non-converge
+ * routing channels).
+ */
+export function buildTaskReviewPrompt(input) {
+    const list = input.candidateTasks.map((p) => `  - ${p}`).join('\n');
+    return [
+        `You are a FRESH-CONTEXT reviewer in the TASKER review→edit→converge LOOP`,
+        `(insertion point A). Review the CANDIDATE TASKS just produced for the prd`,
+        `"${input.slug}":`,
+        list || '  (no candidate tasks found)',
+        ``,
+        reviewDisciplinePrompt(),
+        ``,
+        `Read the source prd (work/prds/ready/${input.slug}.md) and review the candidate`,
+        `decomposition ADVERSARIALLY. Review the WHOLE SET — graph coherence / gaps /`,
+        `overlap / goal-composition (dependency-graph coherence, set-level gaps,`,
+        `overlapping/duplicated tasks, and "does the set compose into the prd goal")`,
+        `— not just per-task well-formedness. The DESTINATION CHECK ("if every task`,
+        `is built exactly as written, do we end up with the system the prd describes?")`,
+        `is PART OF this pass and may ITSELF trigger edits — that is why this is a`,
+        `loop, not a one-shot gate.`,
+        ``,
+        `This is review pass ${input.pass} (fresh context ${input.execution}). You`,
+        `do NOT edit files or run git yourself — you EMIT the edits to apply as FULL`,
+        `replacement content and the runner applies them, then re-reviews. Tasks`,
+        `measurably keep improving when reviewed, so propose edits that fix the`,
+        `findings; converge when a pass finds NO NEW blocking issue.`,
+        ``,
+        verdictContractPrompt(),
+        ``,
+        `Fill the channels appropriate to THIS caller (the tasker improver loop):`,
+        `  - "edits" — full-content replacements for candidate task files when you`,
+        `    can FIX a finding by editing (the natural improver step).`,
+        `  - "uncertainTasks" — specific tasks you cannot make buildable (each gets`,
+        `    \`needsAnswers: true\` with the questions in its body).`,
+        `  - "decompositionUnclear" — the WHOLE decomposition is unsound (the prd is`,
+        `    routed to needs-attention; emit no guessed tasks).`,
+        `Do NOT fill "review" / "edit" / "questions" — those are other callers'`,
+        `channels. Flag, do not guess: a flagged question costs one human glance; a`,
+        `guessed task ships wrong-but-compiling work.`,
+        ``,
+        `TASK \`humanOnly\` IS NARROW. Only edit a task to add \`humanOnly: true\``,
+        `when building THAT task is genuinely never-for-agents BY NATURE (secrets/`,
+        `release/security/AGENTS.md prohibition) — a \`humanOnly\` task is not agent-`,
+        `claimable EVEN from the pool \`work/tasks/ready/\`. Do NOT stamp \`humanOnly\` to`,
+        `mean "a human should review this first": that is the POSITION's job — every`,
+        `candidate task is BIRTHED STAGED in \`work/tasks/backlog/\` (not eligible) and a`,
+        `human promotes the approved ones into the pool.`,
+        `Review-first is the staging position; the overloaded "stamp \`humanOnly\` for`,
+        `review" reading is retired.`,
+    ].join('\n');
+}
+// Parsing of the tasker-loop verdict is now the SHARED `parseReviewVerdict`
+// from `review-verdict.ts` (re-exported above as `parseTaskReviewVerdict` for
+// backwards compatibility). The unified parser validates the SAME shape this
+// loop's prompt asks for; routing reads `findings` / `edits` /
+// `uncertainTasks` / `decompositionUnclear` off the unified `ReviewVerdict`,
+// identical to the old typed-narrow validator.
+//# sourceMappingURL=tasker-review-loop.js.map

package/dist/tasker-review-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasker-review-loop.js","sourceRoot":"","sources":["../src/tasker-review-loop.ts"],"names":[],"mappings":"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"}