@fro.bot/systematic 3.12.3 → 3.13.0

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   loadConfig,
   loadConfigWithSources,
   parseFrontmatter
-} from "./index-h26p98ny.js";
+} from "./index-0stf3ag0.js";
 
 // src/index.ts
 import { createHash as createHash4 } from "crypto";

package/dist/lib/review-artifact-schema.d.ts

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+export declare const REVIEW_ARTIFACT_CUSTOM_MESSAGES: readonly ['severity count must match rejected finding count', 'filtered findings require a validation reason'];
+export declare const DispatchOutcomeSchema: z.ZodEnum<{
+    empty: "empty";
+    findings: "findings";
+    malformed: "malformed";
+    never_returned: "never_returned";
+}>;
+export declare const DispositionSchema: z.ZodEnum<{
+    filtered: "filtered";
+    merged: "merged";
+    rejected: "rejected";
+    suppressed: "suppressed";
+    surviving: "surviving";
+}>;
+export declare const HarnessSchema: z.ZodEnum<{
+    "claude-code": "claude-code";
+    opencode: "opencode";
+    pi: "pi";
+}>;
+export declare const RepoRelativePathSchema: z.ZodString;
+export declare const InputFindingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    record_type: z.ZodLiteral<"admitted">;
+    input_id: z.ZodString;
+    reviewer: z.ZodString;
+    confidence: z.ZodNumber;
+    disposition: z.ZodEnum<{
+        filtered: "filtered";
+        merged: "merged";
+        suppressed: "suppressed";
+        surviving: "surviving";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    record_type: z.ZodLiteral<"rejected_summary">;
+    reviewer: z.ZodString;
+    dispatch_outcome: z.ZodEnum<{
+        empty: "empty";
+        findings: "findings";
+        malformed: "malformed";
+        never_returned: "never_returned";
+    }>;
+    rejected_finding_count: z.ZodNumber;
+    rejected_severities: z.ZodArray<z.ZodEnum<{
+        P0: "P0";
+        P1: "P1";
+        P2: "P2";
+        P3: "P3";
+        unknown: "unknown";
+    }>>;
+    disposition: z.ZodEnum<{
+        rejected: "rejected";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>], "record_type">;
+declare const SynthesizedFindingFieldsSchema: z.ZodObject<{
+    title: z.ZodString;
+    severity: z.ZodEnum<{
+        P0: "P0";
+        P1: "P1";
+        P2: "P2";
+        P3: "P3";
+    }>;
+    file: z.ZodString;
+    line: z.ZodNumber;
+    why_it_matters: z.ZodString;
+    autofix_class: z.ZodEnum<{
+        advisory: "advisory";
+        gated_auto: "gated_auto";
+        manual: "manual";
+        safe_auto: "safe_auto";
+    }>;
+    owner: z.ZodEnum<{
+        "downstream-resolver": "downstream-resolver";
+        human: "human";
+        release: "release";
+        "review-fixer": "review-fixer";
+    }>;
+    requires_verification: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        overflow: z.ZodLiteral<true>;
+        excerpt: z.ZodString;
+    }, z.core.$strict>]>>;
+    pre_existing: z.ZodBoolean;
+    suggested_fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    validated: z.ZodOptional<z.ZodBoolean>;
+    validation_reason: z.ZodOptional<z.ZodString>;
+    input_finding_ids: z.ZodArray<z.ZodString>;
+    provenance: z.ZodObject<{
+        fingerprint: z.ZodString;
+        submitters: z.ZodArray<z.ZodString>;
+        agreement_credit: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type SynthesizedFindingFields = z.infer<typeof SynthesizedFindingFieldsSchema>;
+type SynthesizedFinding = Omit<SynthesizedFindingFields, 'validated' | 'validation_reason'> & ({
+    validated: false;
+    validation_reason: string;
+} | {
+    validated?: true;
+    validation_reason?: string;
+});
+export declare const ReviewArtifactSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    run_id: z.ZodString;
+    mode: z.ZodEnum<{
+        autofix: "autofix";
+        headless: "headless";
+        interactive: "interactive";
+    }>;
+    harness: z.ZodEnum<{
+        "claude-code": "claude-code";
+        opencode: "opencode";
+        pi: "pi";
+    }>;
+    run_status: z.ZodEnum<{
+        abnormal: "abnormal";
+        completed: "completed";
+        degraded: "degraded";
+        in_progress: "in_progress";
+    }>;
+    verdict: z.ZodString;
+    dispatches: z.ZodArray<z.ZodObject<{
+        persona: z.ZodString;
+        dispatch_outcome: z.ZodEnum<{
+            empty: "empty";
+            findings: "findings";
+            malformed: "malformed";
+            never_returned: "never_returned";
+        }>;
+        input_finding_count: z.ZodNumber;
+        rejection_reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    input_findings: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        record_type: z.ZodLiteral<"admitted">;
+        input_id: z.ZodString;
+        reviewer: z.ZodString;
+        confidence: z.ZodNumber;
+        disposition: z.ZodEnum<{
+            filtered: "filtered";
+            merged: "merged";
+            suppressed: "suppressed";
+            surviving: "surviving";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        record_type: z.ZodLiteral<"rejected_summary">;
+        reviewer: z.ZodString;
+        dispatch_outcome: z.ZodEnum<{
+            empty: "empty";
+            findings: "findings";
+            malformed: "malformed";
+            never_returned: "never_returned";
+        }>;
+        rejected_finding_count: z.ZodNumber;
+        rejected_severities: z.ZodArray<z.ZodEnum<{
+            P0: "P0";
+            P1: "P1";
+            P2: "P2";
+            P3: "P3";
+            unknown: "unknown";
+        }>>;
+        disposition: z.ZodEnum<{
+            rejected: "rejected";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>], "record_type">>;
+    findings: z.ZodArray<z.ZodType<SynthesizedFinding, {
+        title: string;
+        severity: "P0" | "P1" | "P2" | "P3";
+        file: string;
+        line: number;
+        why_it_matters: string;
+        autofix_class: "advisory" | "gated_auto" | "manual" | "safe_auto";
+        owner: "downstream-resolver" | "human" | "release" | "review-fixer";
+        requires_verification: boolean;
+        confidence: number;
+        evidence: (string | {
+            overflow: true;
+            excerpt: string;
+        })[];
+        pre_existing: boolean;
+        suggested_fix?: string | null | undefined;
+        validated?: boolean | undefined;
+        validation_reason?: string | undefined;
+        input_finding_ids: string[];
+        provenance: {
+            fingerprint: string;
+            submitters: string[];
+            agreement_credit: string[];
+        };
+    }, z.core.$ZodTypeInternals<SynthesizedFinding, {
+        title: string;
+        severity: "P0" | "P1" | "P2" | "P3";
+        file: string;
+        line: number;
+        why_it_matters: string;
+        autofix_class: "advisory" | "gated_auto" | "manual" | "safe_auto";
+        owner: "downstream-resolver" | "human" | "release" | "review-fixer";
+        requires_verification: boolean;
+        confidence: number;
+        evidence: (string | {
+            overflow: true;
+            excerpt: string;
+        })[];
+        pre_existing: boolean;
+        suggested_fix?: string | null | undefined;
+        validated?: boolean | undefined;
+        validation_reason?: string | undefined;
+        input_finding_ids: string[];
+        provenance: {
+            fingerprint: string;
+            submitters: string[];
+            agreement_credit: string[];
+        };
+    }>>>;
+    disposition_counts: z.ZodObject<{
+        surviving: z.ZodNumber;
+        merged: z.ZodNumber;
+        suppressed: z.ZodNumber;
+        filtered: z.ZodNumber;
+        rejected: z.ZodNumber;
+    }, z.core.$strict>;
+    applied_fixes: z.ZodArray<z.ZodString>;
+    residual_actionable_work: z.ZodArray<z.ZodString>;
+    advisory_outputs: z.ZodArray<z.ZodString>;
+    coverage: z.ZodObject<{
+        reviewers: z.ZodOptional<z.ZodNumber>;
+        validators: z.ZodOptional<z.ZodNumber>;
+        residual_risks: z.ZodArray<z.ZodString>;
+        testing_gaps: z.ZodArray<z.ZodString>;
+        failed_reviewers: z.ZodArray<z.ZodString>;
+        validator_failures: z.ZodArray<z.ZodString>;
+        intent_uncertainty: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ReviewArtifact = z.infer<typeof ReviewArtifactSchema>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "3.12.3",
+  "version": "3.13.0",
   "description": "Compound-engineering loops for OpenCode, Pi, and Claude Code",
   "type": "module",
   "homepage": "https://fro.bot/systematic",
@@ -49,6 +49,8 @@
     "docs:generate": "bun docs/scripts/generate-stats.ts && bun docs/scripts/transform-content.ts && bun scripts/generate-config-schema.ts && bun docs/scripts/generate-config-reference.ts",
     "schema:generate": "bun scripts/generate-config-schema.ts",
     "schema:drift": "bun scripts/generate-config-schema.ts --check",
+    "review-schema:generate": "bun scripts/generate-review-artifact-schema.ts",
+    "review-schema:drift": "bun scripts/generate-review-artifact-schema.ts --check",
     "agent-browser:build": "bun scripts/generate-agent-browser-skill.ts",
     "agent-browser:drift": "bun scripts/generate-agent-browser-skill.ts --check",
     "registry:build": "bun scripts/build-registry.ts",
@@ -91,7 +93,7 @@
     }
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.8",
+    "@biomejs/biome": "2.5.9",
     "@earendil-works/pi-coding-agent": "0.83.0",
     "@opencode-ai/plugin": "1.18.18",
     "@opencode-ai/sdk": "1.18.18",
@@ -100,15 +102,15 @@
     "@types/bun": "latest",
     "@types/js-yaml": "4.0.9",
     "@types/node": "26.2.0",
-    "agent-browser": "0.33.1",
+    "agent-browser": "0.34.0",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",
-    "conventional-changelog-conventionalcommits": "10.3.0",
+    "conventional-changelog-conventionalcommits": "10.4.0",
     "markdownlint-cli": "0.49.1",
     "rimraf": "6.1.3",
     "semantic-release": "25.0.9",
     "semantic-release-export-data": "1.2.0",
-    "typebox": "1.3.14",
+    "typebox": "1.3.16",
     "typescript": "7.0.2"
   },
   "dependencies": {
@@ -120,7 +122,8 @@
   },
   "overrides": {
     "@earendil-works/pi-ai": "0.83.0",
-    "brace-expansion": "^5.0.8"
+    "brace-expansion": "^5.0.8",
+    "conventional-changelog-writer": ">=9"
   },
   "publishConfig": {
     "access": "public",

package/skills/ce-review/SKILL.md

@@ -456,17 +456,17 @@ The parent-owned artifact and its reconciliation rules are defined in the [synth
 
 Convert multiple reviewer JSON returns into one deduplicated, confidence-gated finding set. Each persona return already contains both tiers. The parent must retain the validated payload in memory for merge and synthesis, then persist only the same validated data.
 
-Before applying the confidence gate, assign every finding in a valid return a stable parent-owned `input_id` of `<reviewer>#<1-based finding index>` and keep the parent-owned ledger through every later stage. See the [synthesis artifact contract](./references/synthesis-artifact-contract.md) for the ledger's authoritative reconciliation rules.
+Before applying the confidence gate, keep the parent-owned ledger through every later stage. See the [synthesis artifact contract](./references/synthesis-artifact-contract.md) for the input-ID and reconciliation rules.
 
 1. **Validate before any write.** Treat every persona return as untrusted input. Parse the returned text as JSON without logging the raw text, then validate the complete parsed object against `references/findings-schema.json`, including `why_it_matters` and `evidence`.
    - **Top-level required:** reviewer (string), findings (array), residual_risks (array), testing_gaps (array). Reject the entire persona return if any are missing or wrong type.
    - **Per-finding required:** title, severity, file, line, why_it_matters, confidence, evidence, autofix_class, owner, requires_verification, pre_existing.
    - **Schema constraints:** enforce every enum, type, confidence, line, path, evidence count, evidence length, and explicit overflow-marker bound from the schema. Empty evidence, absolute paths, and over-bound evidence are rejection cases, not truncation cases.
-   - **Environment-value detection:** JSON Schema cannot determine where a string came from, so recursively inspect every string leaf in the parsed payload before writing. Reject the payload when a string contains a shell/environment reference (`$NAME`, `${NAME}`, `process.env.NAME`, or `os.environ[...]`), an assignment using a known environment variable (`NAME=value`), or a current environment value as an exact or embedded match. Use a conservative match set of non-empty runtime environment values; never log the matched value. This detector is an additional parent-side check, not a schema claim.
-   - **Safe rejection message:** report only `Rejected persona <name> return: field <JSON path> failed <reason>.` Derive `<JSON path>` from the validator or recursive scan and use a fixed reason such as `schema validation`, `environment-value detection`, or `malformed JSON`; never include the offending value, raw return, or validator parameters.
-   - **No partial writes:** do not write a per-agent record or merge any finding until the entire persona payload passes schema and environment-value validation. A valid payload is then annotated by the parent with `harness` and `dispatch_outcome` and written by the parent only. Revalidate the enriched record before persistence.
+   - **Environment-value detection:** JSON Schema cannot determine where a string came from, so recursively inspect every string leaf in the parsed payload before writing. Apply the environment-value matching, structural-detector, and finding-granularity rules in the [synthesis artifact contract](./references/synthesis-artifact-contract.md). This detector is an additional parent-side check, not a schema claim.
+   - **Safe rejection message:** Use the safe rejection message rule in the [synthesis artifact contract](./references/synthesis-artifact-contract.md); never include the offending value, raw return, or validator parameters.
+   - **No partial writes:** Do not write or merge a finding until it passes the parent-side validation rules. Apply the admitted-finding persistence and rejected-payload ledger rules in the [synthesis artifact contract](./references/synthesis-artifact-contract.md). A valid admitted finding is then annotated by the parent with `harness` and `dispatch_outcome` and written by the parent only. Revalidate the enriched record before persistence.
    - **Dispatch outcome:** Record the parent-owned dispatch outcomes and ledger dispositions according to the [synthesis artifact contract](./references/synthesis-artifact-contract.md); keep dispatch outcomes separate from finding dispositions.
-   - **Rejection policy: degrade, do not fail the whole review.** Continue merging conforming returns when a persona is rejected; record the rejection according to the [synthesis artifact contract](./references/synthesis-artifact-contract.md). If every persona fails or times out, use the existing degraded-review behavior.
+   - **Rejection policy: degrade, do not fail the whole review.** Continue merging conforming returns when a persona or finding is rejected; record the rejection and apply the risk-aware verdict according to the [synthesis artifact contract](./references/synthesis-artifact-contract.md). If every persona fails or times out, use the existing degraded-review behavior.
 2. **Confidence gate.** Suppress findings below 0.60 confidence. Exception: P0 findings at 0.50+ confidence survive the gate -- critical-but-uncertain issues must not be silently dropped. Record the suppressed finding's original confidence and an explicit reason in the input ledger. A retained P0 at 0.50+ is recorded as `surviving` unless it later participates in a deduplication merge. This matches the persona instructions and the schema's confidence thresholds.
 3. **Deduplicate.** Compute fingerprint: `normalize(file) + line_bucket(line, +/-3) + normalize(title)`. When fingerprints match, merge: keep highest severity, keep highest confidence, preserve the exact fingerprint, and retain the input IDs that produced the merged entry. A singleton that passes the gate is `surviving`; each input in a multi-input merge is provisionally `merged`.
 4. **Cross-reviewer agreement.** When 2+ independent reviewers flag the same issue (same fingerprint), boost the merged confidence by 0.10 (capped at 1.0). Cross-reviewer agreement is strong signal -- independent reviewers converging on the same issue is more reliable than any single reviewer's confidence. Preserve the distinction in the merged finding's artifact provenance according to the [synthesis artifact contract](./references/synthesis-artifact-contract.md).
@@ -480,7 +480,7 @@ Before applying the confidence gate, assign every finding in a valid return a st
 9. **Sort.** Order by severity (P0 first) -> confidence (descending) -> file path -> line number.
 10. **Collect coverage data.** Union residual_risks and testing_gaps across reviewers.
 11. **Preserve CE agent artifacts.** Keep the learnings, agent-native, schema-drift, and deployment-verification outputs alongside the merged finding set. Do not drop unstructured agent output just because it does not match the persona JSON schema.
-12. **Keep the input ledger complete.** Every enumerated input finding must receive exactly one final disposition and reason; reconcile the ledger according to the [synthesis artifact contract](./references/synthesis-artifact-contract.md).
+12. **Keep the input ledger complete.** Reconcile admitted findings and rejected-payload summaries according to the [synthesis artifact contract](./references/synthesis-artifact-contract.md).
 
 ### Stage 5b: Validation pass
 
@@ -519,7 +519,7 @@ Assemble the final report using **pipe-delimited markdown tables for findings**
 9. **Agent-Native Gaps.** Surface agent-native-reviewer results. Omit section if no gaps found.
 10. **Deployment Notes.** If deployment-verification-agent ran, surface the key Go/No-Go items: blocking pre-deploy checks, the most important verification queries, rollback caveats, and monitoring focus areas. Keep the checklist actionable rather than dropping it into Coverage.
 11. **Coverage.** Suppressed count, residual risks, testing gaps, failed/timed-out reviewers, validator failures, and any intent uncertainty carried by non-interactive modes.
-12. **Verdict.** Ready to merge / Ready with fixes / Not ready. Fix order if applicable. When an `explicit` plan has unaddressed requirements, the verdict must reflect it — a PR that's code-clean but missing planned requirements is "Not ready" unless the omission is intentional. When an `inferred` plan has unaddressed requirements, note it in the verdict reasoning but do not block on it alone.
+12. **Verdict.** Ready to merge / Ready with fixes / Not ready. Fix order if applicable. When an `explicit` plan has unaddressed requirements, the verdict must reflect it — a PR that's code-clean but missing planned requirements is "Not ready" unless the omission is intentional. When an `inferred` plan has unaddressed requirements, note it in the verdict reasoning but do not block on it alone. Apply the risk-aware degraded verdict rule from the [synthesis artifact contract](./references/synthesis-artifact-contract.md).
 
 Do not include time estimates.
 
@@ -704,6 +704,7 @@ After presenting findings and verdict (Stage 6), route the next steps by mode. R
 
 - In interactive, autofix, and headless modes, write **`review-summary.json` unconditionally** under `.context/systematic/ce-review/<run-id>`; `mode:report-only` remains the deliberate no-write exception.
 - `review-summary.json` is the parent-owned synthesis artifact. Its lifecycle, dispatch outcomes, complete input ledger, synthesized and filtered findings with provenance, disposition counts, and downstream work are defined in the [canonical synthesis artifact contract](./references/synthesis-artifact-contract.md), whose vocabulary and bounds are executable in [`findings-schema.json`](./references/findings-schema.json).
+- Before finalizing, follow the [artifact validation and failure path](./references/synthesis-artifact-contract.md).
 - Initialize the artifact before dispatch and persist only validated parent-owned records. Finalize lifecycle and reconciliation after synthesis; preserve the existing degraded and abnormal-run behavior described in the canonical contract.
 - Also write `metadata.json` alongside the findings so downstream skills can verify the artifact matches the current branch and HEAD. Minimum fields:
   ```json