@petepetrash/circuit 0.1.0

package/dist/flows/sweep/paths.js

@@ -0,0 +1,18 @@
+// Run-folder paths shared between Sweep's assembly spec and its writers.
+//
+// The partition writer reads the engine-written carried-notes file directly
+// (a compose head has no relay prompt to re-inline it), so the path constant
+// must be identical to the one the assembly spec hands the until-loop flag.
+// Keeping them in one module removes the chance of a silent drift between where
+// the engine writes the notes and where the writer looks for them.
+export const SWEEP_CENSUS_REPORT_PATH = 'reports/sweep/census.json';
+export const SWEEP_PARTITION_REPORT_PATH = 'reports/sweep/partition.json';
+export const SWEEP_WAVE_AGGREGATE_PATH = 'reports/sweep/wave-aggregate.json';
+export const SWEEP_WAVE_BRANCHES_DIR = 'reports/sweep/wave-branches';
+export const SWEEP_RESCAN_REPORT_PATH = 'reports/sweep/rescan.json';
+export const SWEEP_CARRIED_NOTES_PATH = 'reports/sweep/carried-notes.json';
+export const SWEEP_JUDGE_REQUEST_PATH = 'reports/sweep/judgment.request.json';
+export const SWEEP_JUDGE_RECEIPT_PATH = 'reports/sweep/judgment.receipt.txt';
+export const SWEEP_JUDGE_RESULT_PATH = 'reports/sweep/judgment.result.json';
+export const SWEEP_JUDGE_REPORT_PATH = 'reports/sweep/judgment.report.json';
+//# sourceMappingURL=paths.js.map

package/dist/flows/sweep/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../../src/flows/sweep/paths.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,EAAE;AACF,4EAA4E;AAC5E,6EAA6E;AAC7E,4EAA4E;AAC5E,gFAAgF;AAChF,mEAAmE;AAEnE,MAAM,CAAC,MAAM,wBAAwB,GAAG,2BAA2B,CAAC;AACpE,MAAM,CAAC,MAAM,2BAA2B,GAAG,8BAA8B,CAAC;AAC1E,MAAM,CAAC,MAAM,yBAAyB,GAAG,mCAAmC,CAAC;AAC7E,MAAM,CAAC,MAAM,uBAAuB,GAAG,6BAA6B,CAAC;AACrE,MAAM,CAAC,MAAM,wBAAwB,GAAG,2BAA2B,CAAC;AACpE,MAAM,CAAC,MAAM,wBAAwB,GAAG,kCAAkC,CAAC;AAC3E,MAAM,CAAC,MAAM,wBAAwB,GAAG,qCAAqC,CAAC;AAC9E,MAAM,CAAC,MAAM,wBAAwB,GAAG,oCAAoC,CAAC;AAC7E,MAAM,CAAC,MAAM,uBAAuB,GAAG,oCAAoC,CAAC;AAC5E,MAAM,CAAC,MAAM,uBAAuB,GAAG,oCAAoC,CAAC"}

package/dist/flows/sweep/relay-hints.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaShapeHint } from '../registries/shape-hints/types.js';
+export declare const sweepUnitFixShapeHint: SchemaShapeHint;
+//# sourceMappingURL=relay-hints.d.ts.map

package/dist/flows/sweep/relay-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-hints.d.ts","sourceRoot":"","sources":["../../../src/flows/sweep/relay-hints.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAE1E,eAAO,MAAM,qBAAqB,EAAE,eAYnC,CAAC"}

package/dist/flows/sweep/relay-hints.js

@@ -0,0 +1,27 @@
+// Sweep fanout-worker relay shape hint.
+//
+// Each partition unit is handed to one implementer worker via a fanout branch
+// whose report_schema is sweep.unit-fix@v1. Without an explicit shape hint the
+// worker receives only its fix_prompt goal and produces a free-form body the
+// strict SweepUnitFix schema then rejects, aborting the branch. This hint tells
+// the worker the exact JSON to emit so a REAL run's workers report a typed fix.
+//
+// The judge tail's shape is NOT defined here: it is bound to the built-in
+// converge.judgment@v1 contract, which fix-until-green's convergeJudgmentRelayShapeHint
+// already covers globally (it keys on the bound contract, not a flow id). Sweep
+// must not re-register that hint — buildStructuralHintList throws on a duplicate
+// id — so Sweep registers only this worker hint and inherits the judge hint.
+export const sweepUnitFixShapeHint = {
+    kind: 'schema',
+    schema: 'sweep.unit-fix@v1',
+    instruction: [
+        'You are one worker in a wave clearing a backlog of one mechanical finding. Your goal names a single file and the findings to clear in it. Fix the underlying cause of every finding in that file. Change only that file.',
+        'Do not add suppression directives (no eslint-disable, no @ts-ignore/@ts-expect-error, no equivalent) and do not edit the project config to hide the finding. Both are audited separately and will keep the run red — a suppressed finding is a failed fix, not a passed one.',
+        'Respond with a single raw JSON object whose top-level shape is exactly:',
+        '{ "unit_id": "<the unit id this branch was assigned>", "verdict": "<fixed|partial|blocked>", "changed_files": ["<repo-relative path you edited>"], "rule_fixed": "<the rule id you cleared>", "evidence": "<what you changed and why it clears the findings>" }',
+        'Set unit_id to the exact unit id named in your assignment; the runtime rejects a report whose unit_id is not the unit you were given. Use verdict "fixed" when you cleared every finding in the file, "partial" when you cleared some, and "blocked" only when you could change nothing (a blocked worker leaves its findings for the next wave). A "fixed" or "partial" verdict MUST list at least one changed file; a "blocked" verdict lists none.',
+        'Do not include extra top-level keys. Do not wrap the JSON in Markdown code fences. Do not include any prose before or after the JSON object.',
+        'The runtime parses your response with JSON.parse and validates the full body against sweep.unit-fix@v1 before writing your branch report. The wave does not trust your verdict to decide whether the backlog is clear — a pinned re-scan does that — so report honestly.',
+    ].join(' '),
+};
+//# sourceMappingURL=relay-hints.js.map

package/dist/flows/sweep/relay-hints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-hints.js","sourceRoot":"","sources":["../../../src/flows/sweep/relay-hints.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,6EAA6E;AAC7E,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,0EAA0E;AAC1E,wFAAwF;AACxF,gFAAgF;AAChF,iFAAiF;AACjF,6EAA6E;AAI7E,MAAM,CAAC,MAAM,qBAAqB,GAAoB;IACpD,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,mBAAmB;IAC3B,WAAW,EAAE;QACX,0NAA0N;QAC1N,8QAA8Q;QAC9Q,yEAAyE;QACzE,iQAAiQ;QACjQ,ubAAub;QACvb,8IAA8I;QAC9I,0QAA0Q;KAC3Q,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC"}

package/dist/flows/sweep/reports.d.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+export declare const SweepFinding: z.ZodObject<{
+    finding_id: z.ZodString;
+    file: z.ZodNullable<z.ZodString>;
+    rule: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type SweepFinding = z.infer<typeof SweepFinding>;
+export declare const SweepCensus: z.ZodObject<{
+    objective: z.ZodString;
+    scanner: z.ZodObject<{
+        id: z.ZodString;
+        cwd: z.ZodString;
+        argv: z.ZodArray<z.ZodString>;
+        timeout_ms: z.ZodNumber;
+        max_output_bytes: z.ZodNumber;
+        env: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+    suppression_audit: z.ZodObject<{
+        id: z.ZodString;
+        cwd: z.ZodString;
+        argv: z.ZodArray<z.ZodString>;
+        timeout_ms: z.ZodNumber;
+        max_output_bytes: z.ZodNumber;
+        env: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+    suppression_baseline: z.ZodNumber;
+    config_surface: z.ZodArray<z.ZodString>;
+    findings: z.ZodArray<z.ZodObject<{
+        finding_id: z.ZodString;
+        file: z.ZodNullable<z.ZodString>;
+        rule: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    total_finding_count: z.ZodNumber;
+}, z.core.$strict>;
+export type SweepCensus = z.infer<typeof SweepCensus>;
+export declare const SweepIndependence: z.ZodEnum<{
+    project: "project";
+    serial: "serial";
+    isolated: "isolated";
+    shared: "shared";
+}>;
+export type SweepIndependence = z.infer<typeof SweepIndependence>;
+export declare const SweepUnit: z.ZodObject<{
+    unit_id: z.ZodString;
+    files: z.ZodArray<z.ZodString>;
+    finding_ids: z.ZodArray<z.ZodString>;
+    independence: z.ZodEnum<{
+        project: "project";
+        serial: "serial";
+        isolated: "isolated";
+        shared: "shared";
+    }>;
+    fix_prompt: z.ZodString;
+}, z.core.$strict>;
+export type SweepUnit = z.infer<typeof SweepUnit>;
+export declare const SweepPartition: z.ZodObject<{
+    units: z.ZodArray<z.ZodObject<{
+        unit_id: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        finding_ids: z.ZodArray<z.ZodString>;
+        independence: z.ZodEnum<{
+            project: "project";
+            serial: "serial";
+            isolated: "isolated";
+            shared: "shared";
+        }>;
+        fix_prompt: z.ZodString;
+    }, z.core.$strict>>;
+    covers_all_findings: z.ZodBoolean;
+}, z.core.$strict>;
+export type SweepPartition = z.infer<typeof SweepPartition>;
+export declare const SweepUnitFixVerdict: z.ZodEnum<{
+    fixed: "fixed";
+    partial: "partial";
+    blocked: "blocked";
+}>;
+export type SweepUnitFixVerdict = z.infer<typeof SweepUnitFixVerdict>;
+export declare const SweepUnitFix: z.ZodObject<{
+    unit_id: z.ZodString;
+    verdict: z.ZodEnum<{
+        fixed: "fixed";
+        partial: "partial";
+        blocked: "blocked";
+    }>;
+    changed_files: z.ZodArray<z.ZodString>;
+    rule_fixed: z.ZodString;
+    evidence: z.ZodString;
+}, z.core.$strict>;
+export type SweepUnitFix = z.infer<typeof SweepUnitFix>;
+export declare const SweepWaveAggregateBranch: z.ZodObject<{
+    branch_id: z.ZodString;
+    child_run_id: z.ZodString;
+    child_outcome: z.ZodEnum<{
+        complete: "complete";
+        stopped: "stopped";
+        handoff: "handoff";
+        aborted: "aborted";
+        escalated: "escalated";
+    }>;
+    verdict: z.ZodString;
+    admitted: z.ZodBoolean;
+    result_path: z.ZodString;
+    duration_ms: z.ZodNumber;
+    result_body: z.ZodOptional<z.ZodObject<{
+        unit_id: z.ZodString;
+        verdict: z.ZodEnum<{
+            fixed: "fixed";
+            partial: "partial";
+            blocked: "blocked";
+        }>;
+        changed_files: z.ZodArray<z.ZodString>;
+        rule_fixed: z.ZodString;
+        evidence: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SweepWaveAggregateBranch = z.infer<typeof SweepWaveAggregateBranch>;
+export declare const SweepWaveAggregate: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    join_policy: z.ZodLiteral<"aggregate-only">;
+    branch_count: z.ZodNumber;
+    branches: z.ZodArray<z.ZodObject<{
+        branch_id: z.ZodString;
+        child_run_id: z.ZodString;
+        child_outcome: z.ZodEnum<{
+            complete: "complete";
+            stopped: "stopped";
+            handoff: "handoff";
+            aborted: "aborted";
+            escalated: "escalated";
+        }>;
+        verdict: z.ZodString;
+        admitted: z.ZodBoolean;
+        result_path: z.ZodString;
+        duration_ms: z.ZodNumber;
+        result_body: z.ZodOptional<z.ZodObject<{
+            unit_id: z.ZodString;
+            verdict: z.ZodEnum<{
+                fixed: "fixed";
+                partial: "partial";
+                blocked: "blocked";
+            }>;
+            changed_files: z.ZodArray<z.ZodString>;
+            rule_fixed: z.ZodString;
+            evidence: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SweepWaveAggregate = z.infer<typeof SweepWaveAggregate>;
+export declare const SweepVerification: z.ZodObject<{
+    overall_status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>;
+    commands: z.ZodArray<z.ZodObject<{
+        command_id: z.ZodString;
+        argv: z.ZodArray<z.ZodString>;
+        cwd: z.ZodString;
+        exit_code: z.ZodNumber;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        duration_ms: z.ZodNumber;
+        stdout_summary: z.ZodString;
+        stderr_summary: z.ZodString;
+        timed_out: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SweepVerification = z.infer<typeof SweepVerification>;
+//# sourceMappingURL=reports.d.ts.map

package/dist/flows/sweep/reports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reports.d.ts","sourceRoot":"","sources":["../../../src/flows/sweep/reports.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,YAAY;;;;;kBAOd,CAAC;AACZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAWxD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0BpB,CAAC;AACL,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAQtD,eAAO,MAAM,iBAAiB;;;;;EAAsD,CAAC;AACrF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAGlE,eAAO,MAAM,SAAS;;;;;;;;;;;kBAQX,CAAC;AACZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAOlD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;kBAqBvB,CAAC;AACL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAS5D,eAAO,MAAM,mBAAmB;;;;EAA0C,CAAC;AAC3E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,eAAO,MAAM,YAAY;;;;;;;;;;kBAiBrB,CAAC;AACL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAMxD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;kBAW1B,CAAC;AACZ,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6B3B,CAAC;AACL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;kBAAqB,CAAC;AACpD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/flows/sweep/reports.js

@@ -0,0 +1,179 @@
+// Sweep's report schemas.
+//
+// Sweep clears a whole backlog of one mechanical finding (tsc/eslint/clippy
+// diagnostics) by driving an external scanner to a zero-finding exit. Its loop
+// body fans one worker out per partition unit, re-scans with a pinned oracle,
+// and lets a judge decide whether the backlog is clear. Every schema name below
+// is globally unique (the compose, verification, and report-schema registries
+// are one keyspace shared across all flow packages), so Sweep owns `sweep.*`
+// names and reuses only the shared VerificationCommand / VerificationResult
+// shapes and the built-in converge.judgment@v1 contract.
+import { z } from 'zod';
+import { VerificationCommand, VerificationResult } from '../../schemas/verification.js';
+// A single mechanical finding the scanner reported. `file` is null when a
+// finding is not file-scoped (a project-level diagnostic), so partitioning can
+// group it under the project unit rather than a file unit.
+export const SweepFinding = z
+    .object({
+    finding_id: z.string().min(1),
+    file: z.string().min(1).nullable(),
+    rule: z.string().min(1),
+    message: z.string().min(1),
+})
+    .strict();
+// The preamble's census. It runs ONCE before the loop and does three jobs:
+//   1. Resolves the scanner and the suppression audit into pinnable
+//      VerificationCommands. The loop's rescan step reads exactly these, so the
+//      oracle-command pin can snapshot them the first wave and refuse a swap.
+//   2. Records the suppression baseline — the count of suppression directives
+//      already in the tree — so a worker that silences a finding instead of
+//      fixing it shows up as an audit that exits red against a baseline of zero.
+//   3. Captures the opening finding census and the config surface, so the
+//      operator sees the size of the backlog and which files define "clean".
+export const SweepCensus = z
+    .object({
+    objective: z.string().min(1),
+    // The scanner whose zero-finding exit is the oracle. A package-script
+    // invocation (`npm run <script>`) so engine change 2 fingerprints its body.
+    scanner: VerificationCommand,
+    // The suppression audit: a second command whose non-zero exit means a
+    // suppression directive was added. Also a package script, also fingerprinted.
+    suppression_audit: VerificationCommand,
+    suppression_baseline: z.number().int().nonnegative(),
+    // The config files that define what the scanner treats as a finding
+    // (recorded for legibility; the frozen-paths engine flag is what enforces
+    // that a worker cannot edit them out from under the oracle).
+    config_surface: z.array(z.string().min(1)),
+    findings: z.array(SweepFinding),
+    total_finding_count: z.number().int().nonnegative(),
+})
+    .strict()
+    .superRefine((census, ctx) => {
+    if (census.total_finding_count !== census.findings.length) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['total_finding_count'],
+            message: 'total_finding_count must match findings.length',
+        });
+    }
+});
+// How independent a unit's fix is from its siblings, so the partition is honest
+// about what may run in parallel:
+//   isolated — touches only its own files; safe to fan out concurrently.
+//   shared   — touches files another unit also needs; grouped, not split.
+//   serial   — must run after an earlier unit (an ordering dependency).
+//   project  — a project-level finding with no single file to scope.
+export const SweepIndependence = z.enum(['isolated', 'shared', 'serial', 'project']);
+// One partition unit: a disjoint slice of the backlog one worker owns this wave.
+export const SweepUnit = z
+    .object({
+    unit_id: z.string().min(1),
+    files: z.array(z.string().min(1)).min(1),
+    finding_ids: z.array(z.string().min(1)).min(1),
+    independence: SweepIndependence,
+    fix_prompt: z.string().min(1),
+})
+    .strict();
+// The head step's output each wave. A partition must carry at least one unit:
+// when a re-scan finds nothing left, the loop must already have stopped at the
+// judge on a green rescan, so a zero-unit partition is a contract violation the
+// writer surfaces rather than emitting. Units must be file-disjoint so the
+// fanout can run them concurrently without two workers racing one file.
+export const SweepPartition = z
+    .object({
+    units: z.array(SweepUnit).min(1),
+    covers_all_findings: z.boolean(),
+})
+    .strict()
+    .superRefine((partition, ctx) => {
+    const owner = new Map();
+    for (const [index, unit] of partition.units.entries()) {
+        for (const file of unit.files) {
+            const prior = owner.get(file);
+            if (prior !== undefined && prior !== unit.unit_id) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: ['units', index, 'files'],
+                    message: `file '${file}' is claimed by units '${prior}' and '${unit.unit_id}'; partition units must be file-disjoint`,
+                });
+            }
+            owner.set(file, unit.unit_id);
+        }
+    }
+});
+// A fanout worker's report. `unit_id` is the branch's provenance field — the
+// engine forces it to equal the branch_id, so a worker cannot report against a
+// unit it was not assigned. `verdict` is what the fanout admit list reads; all
+// three values are admitted because the rescan floor, not the fanout, decides
+// whether the backlog is clear — a `blocked` worker simply leaves its findings
+// for the next wave. A `fixed` or `partial` worker must name the files it
+// changed; a `blocked` worker legitimately changed nothing.
+export const SweepUnitFixVerdict = z.enum(['fixed', 'partial', 'blocked']);
+export const SweepUnitFix = z
+    .object({
+    unit_id: z.string().min(1),
+    verdict: SweepUnitFixVerdict,
+    changed_files: z.array(z.string().min(1)),
+    rule_fixed: z.string().min(1),
+    evidence: z.string().min(1),
+})
+    .strict()
+    .superRefine((fix, ctx) => {
+    if (fix.verdict !== 'blocked' && fix.changed_files.length === 0) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['changed_files'],
+            message: `a '${fix.verdict}' unit fix must name at least one changed file`,
+        });
+    }
+});
+// The fanout aggregate the engine writes after joining the wave's branches
+// (buildFanoutAggregate). Sweep joins aggregate-only with no rubric, so
+// rubric_result is always absent. branch_count is positive because the fanout
+// executor refuses a zero-branch wave before any aggregate is written.
+export const SweepWaveAggregateBranch = z
+    .object({
+    branch_id: z.string().min(1),
+    child_run_id: z.string().min(1),
+    child_outcome: z.enum(['complete', 'aborted', 'handoff', 'stopped', 'escalated']),
+    verdict: z.string().min(1),
+    admitted: z.boolean(),
+    result_path: z.string().min(1),
+    duration_ms: z.number().nonnegative(),
+    result_body: SweepUnitFix.optional(),
+})
+    .strict();
+export const SweepWaveAggregate = z
+    .object({
+    schema_version: z.literal(1),
+    join_policy: z.literal('aggregate-only'),
+    branch_count: z.number().int().positive(),
+    branches: z.array(SweepWaveAggregateBranch).min(1),
+})
+    .strict()
+    .superRefine((aggregate, ctx) => {
+    if (aggregate.branch_count !== aggregate.branches.length) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['branch_count'],
+            message: 'branch_count must match branches.length',
+        });
+    }
+    for (const [index, branch] of aggregate.branches.entries()) {
+        if (branch.child_outcome === 'complete' &&
+            branch.result_body !== undefined &&
+            branch.result_body.unit_id !== branch.branch_id) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['branches', index, 'result_body', 'unit_id'],
+                message: `branch_id '${branch.branch_id}' must match result_body.unit_id '${branch.result_body.unit_id}'`,
+            });
+        }
+    }
+});
+// The rescan's canonical command-list result. Its overall_status is the proof
+// the until-loop evidence floor reads each wave: passed only when the scanner
+// AND the suppression audit both exit clean. The same strict VerificationResult
+// shape Build and Fix Until Green emit, reused verbatim.
+export const SweepVerification = VerificationResult;
+//# sourceMappingURL=reports.js.map

package/dist/flows/sweep/reports.js.map

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

package/dist/flows/sweep/writers/census.d.ts

@@ -0,0 +1,3 @@
+import type { ComposeBuilder } from '../../registries/compose-writers/types.js';
+export declare const sweepCensusComposeBuilder: ComposeBuilder;
+//# sourceMappingURL=census.d.ts.map

package/dist/flows/sweep/writers/census.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"census.d.ts","sourceRoot":"","sources":["../../../../src/flows/sweep/writers/census.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAEV,cAAc,EACf,MAAM,2CAA2C,CAAC;AAsCnD,eAAO,MAAM,yBAAyB,EAAE,cAqBvC,CAAC"}

package/dist/flows/sweep/writers/census.js

@@ -0,0 +1,67 @@
+// Sweep census compose writer.
+//
+// The preamble. It runs ONCE before the loop and pins the two oracle commands
+// the loop's rescan step will re-run every wave: the scanner (whose zero-finding
+// exit is the goal) and the suppression audit (whose non-zero exit means a
+// worker silenced a finding rather than fixing it). Both are `npm run <script>`
+// invocations, so engine change 2 fingerprints each script's package.json body
+// STRING and refuses a swap of that string. It does NOT fingerprint the program
+// that string launches, so rewriting the scanner file itself is a known open gap
+// (spec 6.6 / 9.1), not a closed one.
+// The census also spawns the scanner once to record the opening backlog, the
+// suppression baseline, and the config surface, so the operator sees the size of
+// the job and the run has a documented starting point.
+import { VerificationCommand } from '../../../schemas/verification.js';
+import { SweepCensus } from '../reports.js';
+import { runScannerFindings, runSuppressionBaseline } from './scan.js';
+const ORACLE_TIMEOUT_MS = 120_000;
+const ORACLE_MAX_OUTPUT_BYTES = 1_000_000;
+// The config files that define what the scanner counts as a finding. Recorded
+// for legibility; the assembly spec's frozen_paths is what actually forbids a
+// worker from editing them out from under the oracle.
+const SWEEP_CONFIG_SURFACE = ['tsconfig.json'];
+// The pinned scanner: dual-channel (JSON findings on stdout for the work-list,
+// exit code for the floor). A package script so the pin fingerprints its body.
+function scannerCommand() {
+    return VerificationCommand.parse({
+        id: 'sweep-scan',
+        cwd: '.',
+        argv: ['npm', 'run', 'scan'],
+        timeout_ms: ORACLE_TIMEOUT_MS,
+        max_output_bytes: ORACLE_MAX_OUTPUT_BYTES,
+        env: {},
+    });
+}
+// The pinned suppression audit: exits non-zero once any suppression directive
+// exists (baseline zero on a clean tree). Also a package script, also pinned.
+function suppressionAuditCommand() {
+    return VerificationCommand.parse({
+        id: 'sweep-audit',
+        cwd: '.',
+        argv: ['npm', 'run', 'audit'],
+        timeout_ms: ORACLE_TIMEOUT_MS,
+        max_output_bytes: ORACLE_MAX_OUTPUT_BYTES,
+        env: {},
+    });
+}
+export const sweepCensusComposeBuilder = {
+    resultSchemaName: 'sweep.census@v1',
+    build(context) {
+        const projectRoot = context.projectRoot;
+        if (projectRoot === undefined) {
+            throw new Error('sweep census requires projectRoot to run the scanner; none was provided by the invocation');
+        }
+        const findings = runScannerFindings(projectRoot);
+        const suppressionBaseline = runSuppressionBaseline(projectRoot);
+        return SweepCensus.parse({
+            objective: context.goal,
+            scanner: scannerCommand(),
+            suppression_audit: suppressionAuditCommand(),
+            suppression_baseline: suppressionBaseline,
+            config_surface: [...SWEEP_CONFIG_SURFACE],
+            findings,
+            total_finding_count: findings.length,
+        });
+    },
+};
+//# sourceMappingURL=census.js.map

package/dist/flows/sweep/writers/census.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"census.js","sourceRoot":"","sources":["../../../../src/flows/sweep/writers/census.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,EAAE;AACF,8EAA8E;AAC9E,iFAAiF;AACjF,2EAA2E;AAC3E,gFAAgF;AAChF,+EAA+E;AAC/E,gFAAgF;AAChF,iFAAiF;AACjF,sCAAsC;AACtC,6EAA6E;AAC7E,iFAAiF;AACjF,uDAAuD;AAEvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAKvE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAEvE,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAClC,MAAM,uBAAuB,GAAG,SAAS,CAAC;AAE1C,8EAA8E;AAC9E,8EAA8E;AAC9E,sDAAsD;AACtD,MAAM,oBAAoB,GAAG,CAAC,eAAe,CAAU,CAAC;AAExD,+EAA+E;AAC/E,+EAA+E;AAC/E,SAAS,cAAc;IACrB,OAAO,mBAAmB,CAAC,KAAK,CAAC;QAC/B,EAAE,EAAE,YAAY;QAChB,GAAG,EAAE,GAAG;QACR,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC;QAC5B,UAAU,EAAE,iBAAiB;QAC7B,gBAAgB,EAAE,uBAAuB;QACzC,GAAG,EAAE,EAAE;KACR,CAAC,CAAC;AACL,CAAC;AAED,8EAA8E;AAC9E,8EAA8E;AAC9E,SAAS,uBAAuB;IAC9B,OAAO,mBAAmB,CAAC,KAAK,CAAC;QAC/B,EAAE,EAAE,aAAa;QACjB,GAAG,EAAE,GAAG;QACR,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC;QAC7B,UAAU,EAAE,iBAAiB;QAC7B,gBAAgB,EAAE,uBAAuB;QACzC,GAAG,EAAE,EAAE;KACR,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,MAAM,yBAAyB,GAAmB;IACvD,gBAAgB,EAAE,iBAAiB;IACnC,KAAK,CAAC,OAA4B;QAChC,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;QACxC,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CACb,2FAA2F,CAC5F,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,GAAG,kBAAkB,CAAC,WAAW,CAAC,CAAC;QACjD,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,WAAW,CAAC,CAAC;QAChE,OAAO,WAAW,CAAC,KAAK,CAAC;YACvB,SAAS,EAAE,OAAO,CAAC,IAAI;YACvB,OAAO,EAAE,cAAc,EAAE;YACzB,iBAAiB,EAAE,uBAAuB,EAAE;YAC5C,oBAAoB,EAAE,mBAAmB;YACzC,cAAc,EAAE,CAAC,GAAG,oBAAoB,CAAC;YACzC,QAAQ;YACR,mBAAmB,EAAE,QAAQ,CAAC,MAAM;SACrC,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/flows/sweep/writers/partition.d.ts

@@ -0,0 +1,3 @@
+import type { ComposeBuilder } from '../../registries/compose-writers/types.js';
+export declare const sweepPartitionComposeBuilder: ComposeBuilder;
+//# sourceMappingURL=partition.d.ts.map

package/dist/flows/sweep/writers/partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../../../src/flows/sweep/writers/partition.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAEV,cAAc,EACf,MAAM,2CAA2C,CAAC;AAoHnD,eAAO,MAAM,4BAA4B,EAAE,cAkB1C,CAAC"}