audit-tools 0.52.5 → 0.54.0

package/dist/remediate/contractPipeline/semanticProjection.js

@@ -1,136 +0,0 @@
-/**
- * Semantic projection for contract-pipeline staleness (B3).
- *
- * The staleness DAG used to key every dependency on the upstream's RAW payload
- * content hash, so any byte change to an upstream — a reworded rationale, a
- * regenerated `created_at` stamp, a reordered list — re-staled the entire
- * downstream chain and forced a full (often LLM-driven) re-authoring of
- * artifacts whose load-bearing inputs had not actually changed. That is the
- * exact friction B3 names: "an edit to finalized_module_contracts re-stales
- * obligation_ledger → test_validator_plan → contract_assessment even when the
- * obligation set is unchanged."
- *
- * The fix is to make staleness content/semantics-aware: a dependency is recorded
- * and compared by the hash of its *semantic projection* — only the structure a
- * downstream actually consumes — not its raw bytes. A cosmetic upstream edit
- * projects to the same value, so downstreams stay fresh; a real change to the
- * load-bearing structure (a new module invariant, a changed interface) projects
- * differently and correctly re-stales.
- *
- * This mirrors audit-code's `normalizeForMetadataHash`
- * (`src/shared/artifactFreshness.ts`): strip non-semantic provenance fields
- * universally, then apply a per-artifact structural projection. The two
- * orchestrators stay in conceptual parity (semantic-projection staleness) while
- * each owns the projection table for its own artifact set.
- */
-import { isRecord, stableStringifyProjection } from "audit-tools/shared";
-import { DERIVABLE_MODULE_CONTRACT_FIELDS } from "./finalizedContractFields.js";
-export { stableStringifyProjection };
-/**
- * Non-semantic top-level fields stripped from EVERY artifact before projecting.
- * These are provenance (wall-clock stamps), never meaning: re-deriving the
- * obligation ledger or re-emitting any artifact mints a fresh `created_at`, and
- * without stripping it the artifact's hash churns on every rebuild and
- * perpetually re-stales its downstreams — a finalization-oscillation hazard.
- */
-const UNIVERSAL_NON_SEMANTIC_FIELDS = ["created_at", "generated_at"];
-/**
- * The module-contract fields that are load-bearing for ALL downstreams, at BOTH
- * layers (the intermediate `module_contracts` draft and the
- * `finalized_module_contracts`). These are the fields the deterministic
- * consumers read: `deriveObligationLedger` derives the obligation set and
- * test-plan premises from them, and `buildBaselineSymbolCorpus`
- * (`contractPipeline/changeClassification.ts`) additionally builds the
- * change-vs-addition corpus from the declared interface surface — `inputs`,
- * `outputs`, `side_effects`, `validation_boundary` — so a side_effects-only
- * edit is exactly as load-bearing as an interface edit and re-stales the
- * obligation_ledger like any other consumed field (CP-NODE-19). Never the
- * surrounding rationale/narrative/seam prose: a pure-prose edit leaves the
- * whole obligation-bearing chain fresh, while a changed interface, a new
- * invariant, or a changed side effect correctly re-stales it.
- */
-// The projection's field list is the COPIED half of the ONE module-contract
-// vocabulary (`finalizedContractFields.ts`) — see that module for why
-// `seam_adjustments` (DERIVED at finalization, read by no deterministic
-// consumer) is excluded: a re-agreed seam must not re-stale the ledger.
-export { DERIVABLE_MODULE_CONTRACT_FIELDS };
-function stripFields(record, fields) {
-    const drop = new Set(fields);
-    return Object.fromEntries(Object.entries(record).filter(([key]) => !drop.has(key)));
-}
-function projectModuleContract(value, fields) {
-    const record = isRecord(value) ? value : {};
-    const out = {};
-    for (const field of fields) {
-        // Skip ABSENT fields rather than projecting them as undefined: a projection
-        // must be stable across a JSON round-trip (the review snapshot stores its
-        // reviewed_inputs as JSON, and JSON.stringify drops undefined values), so
-        // `side_effects: undefined` on the live side would read as an ADDED field
-        // against the round-tripped snapshot and fabricate a re-review delta.
-        if (record[field] === undefined)
-            continue;
-        out[field] = record[field];
-    }
-    return out;
-}
-/**
- * Collapse cosmetic whitespace in every projected string (trim + runs → single
- * space), recursively. A reflow / trailing-space / indentation edit to a contract
- * field is not a semantic change, but without this it churns the projection hash
- * and re-stales the downstream chain. Safe: the downstream gates/derivers match on
- * word boundaries and substrings, which whitespace normalization never alters.
- */
-function normalizeWhitespaceDeep(value) {
-    if (typeof value === "string")
-        return value.replace(/\s+/g, " ").trim();
-    if (Array.isArray(value))
-        return value.map(normalizeWhitespaceDeep);
-    if (isRecord(value)) {
-        const out = {};
-        for (const [key, v] of Object.entries(value))
-            out[key] = normalizeWhitespaceDeep(v);
-        return out;
-    }
-    return value;
-}
-/**
- * Project a contract-pipeline artifact payload to only its load-bearing
- * structure for downstream-staleness purposes. The universal provenance strip
- * applies to every artifact; both module-contract artifacts
- * (`module_contracts` and `finalized_module_contracts`) additionally project
- * their `module_contracts` entries to the derivable fields. Artifacts with no
- * special case fall back to the provenance-stripped payload (conservative:
- * behaves like the raw payload minus stamps).
- *
- * Non-object payloads pass through unchanged.
- */
-export function semanticProjection(name, payload) {
-    if (!isRecord(payload))
-        return payload;
-    const stripped = stripFields(payload, UNIVERSAL_NON_SEMANTIC_FIELDS);
-    // Both the intermediate `module_contracts` and the `finalized_module_contracts`
-    // carry the same module-entry shape; narrow each entry to the derivable fields —
-    // including `side_effects`, which the baseline symbol corpus reads at both
-    // layers. A reworded per-module rationale / a tweaked non-derivable array
-    // (seam_adjustments / neighbor_needs) projects identically while a changed
-    // interface / new invariant / side effect does not. Keep every top-level field
-    // (contract_version, goal_id, …): the narrowing is per-entry, so any top-level
-    // field a downstream might read still participates in staleness.
-    if (name === "finalized_module_contracts" || name === "module_contracts") {
-        if (Array.isArray(stripped.module_contracts)) {
-            return normalizeWhitespaceDeep({
-                ...stripped,
-                module_contracts: stripped.module_contracts.map((entry) => projectModuleContract(entry, DERIVABLE_MODULE_CONTRACT_FIELDS)),
-            });
-        }
-        return normalizeWhitespaceDeep(stripped);
-    }
-    return normalizeWhitespaceDeep(stripped);
-}
-/**
- * The order-independent stable serialization used to hash a projection is the
- * shared `stableStringifyProjection` (re-exported above) — single-sourced in
- * `audit-tools/shared` so audit-code and remediate-code hash projections
- * identically.
- */
-//# sourceMappingURL=semanticProjection.js.map

package/dist/remediate/contractPipeline/semanticProjection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"semanticProjection.js","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/semanticProjection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,QAAQ,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAEzE,OAAO,EAAE,gCAAgC,EAAE,MAAM,8BAA8B,CAAC;AAEhF,OAAO,EAAE,yBAAyB,EAAE,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,6BAA6B,GAAsB,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;AAExF;;;;;;;;;;;;;;GAcG;AACH,4EAA4E;AAC5E,sEAAsE;AACtE,wEAAwE;AACxE,wEAAwE;AACxE,OAAO,EAAE,gCAAgC,EAAE,CAAC;AAE5C,SAAS,WAAW,CAClB,MAA+B,EAC/B,MAAyB;IAEzB,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CACzD,CAAC;AACJ,CAAC;AAED,SAAS,qBAAqB,CAC5B,KAAc,EACd,MAAyB;IAEzB,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAC5C,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,4EAA4E;QAC5E,0EAA0E;QAC1E,0EAA0E;QAC1E,0EAA0E;QAC1E,sEAAsE;QACtE,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,SAAS;YAAE,SAAS;QAC1C,GAAG,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,SAAS,uBAAuB,CAAC,KAAc;IAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;IACxE,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;IACpE,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACpB,MAAM,GAAG,GAA4B,EAAE,CAAC;QACxC,KAAK,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,CAAC;QACpF,OAAO,GAAG,CAAC;IACb,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAChC,IAAkC,EAClC,OAAgB;IAEhB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,OAAO,CAAC;IACvC,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,6BAA6B,CAAC,CAAC;IAErE,gFAAgF;IAChF,iFAAiF;IACjF,2EAA2E;IAC3E,0EAA0E;IAC1E,2EAA2E;IAC3E,+EAA+E;IAC/E,+EAA+E;IAC/E,iEAAiE;IACjE,IAAI,IAAI,KAAK,4BAA4B,IAAI,IAAI,KAAK,kBAAkB,EAAE,CAAC;QACzE,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAC7C,OAAO,uBAAuB,CAAC;gBAC7B,GAAG,QAAQ;gBACX,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CACxD,qBAAqB,CAAC,KAAK,EAAE,gCAAgC,CAAC,CAC/D;aACF,CAAC,CAAC;QACL,CAAC;QACD,OAAO,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAED,OAAO,uBAAuB,CAAC,QAAQ,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;GAKG"}

package/dist/remediate/contractPipeline/sketchSource.d.ts

@@ -1,194 +0,0 @@
-export { CONCEPTUAL_CRITIQUE_REPAIR_TARGETS } from "../../shared/types/contractPipeline/design.js";
-/**
- * The value vocabularies a step prompt's schema sketch and its VALIDATOR both
- * read — declared once, here, so they cannot disagree.
- *
- * Why this module exists. A step prompt hands the worker a JSON shape to write,
- * and a validator in `src/remediate/validation/` decides whether what came back
- * is admissible. Those were two independent statements of the same fact: the
- * prompt carried a hand-written sketch (`contractPipelinePrompts.ts`, plus two
- * extra sketches in `contractPipeline.ts`) and the validator carried its own
- * literal list. Measured drifts at HEAD before this module existed:
- *
- *   - `cyclic_seam_resolution.status` — sketch offered 2 values, the validator
- *     admits 4 (`user_decision_required` and `blocked` were unrenderable but
- *     required by the refusal path);
- *   - `judge_report.repair_directive.target` — sketch offered 3, the validator 4
- *     (the fourth, `counterexample`, could never be asked for);
- *   - `verification_report.finding.traces[].kind` — sketch offered 5, the
- *     validator 6;
- *   - `implementation_dag.node.status` — sketch showed exactly 1 of the 4 the
- *     validator admits.
- *
- * Every one is the same failure: a worker reads the sketch, emits a value the
- * sketch allowed, and the tool refuses it — or, worse in the opposite
- * direction, never learns a legal value exists. A drift test made of "remember
- * to update the other one" is exactly the class of guarantee this repo bans
- * (enforce in tooling, never host — or author — discretion), so the fix is not
- * a test that watches two lists. It is ONE declaration, with the validator and
- * the sketch both deriving from it.
- *
- * What is MINED vs DECLARED. The values are declared here; they are NOT read out
- * of the validator module, because a validator states its values as inline
- * `requireOneOf(...)` literals inside a function body — a declaration a test can
- * only reach by parsing source text, which is the brittle thing this replaces.
- * Instead the exported constants are the single declaration and the VALIDATOR
- * imports them, so the drift is impossible by construction rather than detected
- * after the fact. The test in
- * `tests/remediate/step-prompt-sketch-drift.test.ts` then re-derives each
- * vocabulary from what each validator actually REFUSES (by feeding it values),
- * and compares that to the sketch the prompt renders — so a value added to a
- * validator without the sketch still reds, without depending on how the
- * validator happens to spell its list.
- *
- * NOT A LIST. Every value vocabulary that the CONTRACT-PIPELINE role sketches
- * render as an alternation is declared here — the four drifted ones above, the
- * obligation/test-plan pairs, and the nine that were still hand-written literals
- * in `contractPipelinePrompts.ts` (goal `source_type`; context-entry `kind`; the
- * critique item `kind` and `severity`; the critique `verdict`; the assessment
- * finding `status` and report `verdict`; the judge `verdict`; and the judge's
- * counterexample `classification`). That is the whole point: a vocabulary kept
- * as a literal is only safe while someone remembers, and the drift test below
- * sweeps every rendered alternation of those sketches rather than a hand-kept
- * field list, so the next literal to appear reds immediately instead of waiting
- * to be noticed.
- *
- * The scope is those sketches, NOT every sketch in the repository, and the
- * difference is recorded rather than implied: the sweep reaches the modules in
- * `SKETCH_SOURCE_MODULES`, and the clarification-resolution sketch in
- * `steps/prompts.ts` is outside them — a declared-gap row in
- * `tests/shared/promptContractRegistry.ts`. So this module claims nothing about
- * that one, and widening the sweep is its own change.
- */
-/**
- * `cyclic_seam_resolution.status` — what the validator admits. `no_cycles` is
- * the tool's own record, written when the ledger has no cycle; `resolved` is the
- * worker's record of the breaks it made. The escalation states
- * (`user_decision_required`, `blocked`) are routes the gate takes, never a
- * record: nothing wrote them, and a worker that wrote one moved the pipeline
- * forward with the cycles still in the ledger.
- */
-export declare const CYCLIC_SEAM_RESOLUTION_STATUSES: readonly ["no_cycles", "resolved"];
-/**
- * The subset of {@link CYCLIC_SEAM_RESOLUTION_STATUSES} the worker's sketch
- * offers. The worker is emitted only when the ledger has a cycle, so its one
- * answer is `resolved`; the re-check refuses any record while a cycle remains.
- */
-export declare const CYCLIC_SEAM_RESOLUTION_STATUSES_OFFERED: readonly ["resolved"];
-/** `cyclic_seam_resolution.cycles[].break_strategy`. */
-export declare const CYCLIC_SEAM_BREAK_STRATEGIES: readonly ["mediator", "single_authority"];
-/**
- * `judge_report.repair_directive.target`, its legacy aliases, and the offered
- * subset — DECLARED in `src/shared/types/contractPipeline/obligations.ts`,
- * beside the `JudgeRepairTarget` type that derives from them, and re-exported
- * here so the validator and the prompt sketches keep reading them from this
- * module.
- *
- * Why they moved. `src/shared` is the base layer; this module lives in
- * `src/remediate`. A value import from the base layer into an orchestrator is
- * the dependency direction inverted, and the declaration had to live on the
- * side the TYPE could reach.
- */
-export { CONTRACT_REPAIR_TARGETS, CONTRACT_REPAIR_TARGETS_LEGACY, CONTRACT_REPAIR_TARGETS_OFFERED, } from "audit-tools/shared";
-/** `verification_report` trace `kind`. */
-export declare const VERIFICATION_TRACE_KINDS: readonly ["requirement", "invariant", "counterexample", "task", "file", "command"];
-/** `verification_report` finding-level `overall_status` (report level excludes `skipped`). */
-export declare const VERIFICATION_FINDING_STATUSES: readonly ["passed", "failed", "skipped"];
-/** `verification_report` report-level `overall_status`. */
-export declare const VERIFICATION_REPORT_STATUSES: readonly ["passed", "failed"];
-/** `verification_report` trace `status`. */
-export declare const VERIFICATION_TRACE_STATUSES: readonly ["passed", "failed"];
-/** `implementation_dag.nodes[].status`. */
-export declare const IMPLEMENTATION_NODE_STATUSES: readonly ["pending", "in_progress", "resolved", "blocked"];
-/** `implementation_dag.edges[].kind`. */
-export declare const IMPLEMENTATION_EDGE_KINDS: readonly ["dependency", "verification"];
-/**
- * `obligation_ledger.obligations[].status`. `satisfied` is reachable only
- * through the tool's own derivation (`contractPipeline/derive.ts`) — a worker
- * emits `pending` and the tool advances it — but the value is part of the
- * contract the prompt describes, so it is declared here rather than implied.
- */
-export declare const OBLIGATION_STATUSES: readonly ["pending", "satisfied", "failed"];
-/** `obligation_ledger.obligations[].kind`. */
-export declare const OBLIGATION_KINDS: readonly ["invariant", "behavioral", "structural", "test"];
-/** `test_validator_plan.test_specs[].kind`. */
-export declare const TEST_SPEC_KINDS: readonly ["unit", "integration", "schema", "invariant", "e2e"];
-/** `goal_spec.source_type`. */
-export declare const GOAL_SOURCE_TYPES: readonly ["conversation", "document", "structured_audit", "mixed"];
-/** `context_bundle.entries[].kind`. */
-export declare const CONTEXT_ENTRY_KINDS: readonly ["source", "test", "config", "doc"];
-/** `conceptual_design_critique.items[].kind`. */
-export declare const CRITIQUE_ITEM_KINDS: readonly ["concern", "alternative", "suggestion"];
-/** `conceptual_design_critique.items[].severity`. */
-export declare const CRITIQUE_ITEM_SEVERITIES: readonly ["blocking", "advisory"];
-/** `conceptual_design_critique.verdict`. */
-export declare const CRITIQUE_VERDICTS: readonly ["approved", "approved_with_concerns", "rejected"];
-/** `contract_assessment_report.findings[].status`. */
-export declare const ASSESSMENT_FINDING_STATUSES: readonly ["satisfied", "violated", "uncertain"];
-/** `contract_assessment_report.verdict`. */
-export declare const ASSESSMENT_VERDICTS: readonly ["passed", "failed", "partial"];
-/** `judge_report.verdict`. */
-export declare const JUDGE_VERDICTS: readonly ["approved", "needs_repair"];
-/**
- * `judge_report.classifications[].classification` — what the judge may decide
- * about one counterexample.
- *
- * Declared here rather than in the validator that reads it, because the judge
- * role's prompt sketch states the same five values and a sketch that renders a
- * hand-written copy of a validator's list is the drift this module bans. The
- * validator imports THIS declaration (it was a local `as const` beside
- * `validateJudgeReport`), so the two are one fact.
- */
-export declare const COUNTEREXAMPLE_CLASSIFICATIONS: readonly ["accepted", "out_of_scope", "duplicate", "invalid", "residual_risk"];
-/**
- * `seam_reconciliation_report.mismatches[].resolution.decision` — which side of
- * a seam adjusts. Declared here beside the rest for ONE reason: the alternative
- * would be to exclude it from the drift test by hand, and an exclusion list is
- * the drift this module exists to make impossible (see the test's alternation
- * sweep, which matches EVERY rendered alternation to a validator probe).
- */
-export declare const SEAM_RESOLUTION_DECISIONS: readonly ["A", "B", "both"];
-/**
- * The vocabularies that carry a `created_at`, and the ones that do not.
- *
- * `created_at` asymmetry, resolved in one place. Every contract-pipeline
- * validator ends with `requireString(v.created_at, ...)`, and NO sketch
- * declares the field — the reconciliation is `stampToolCreatedAt`
- * (`contractPipeline/artifactStore.ts`), which the tool calls on the payload at
- * ingest and at the `validate-artifact` self-check. The host has no clock, so
- * asking it for a timestamp is asking it to invent one; the tool owns the field
- * and stamps it.
- *
- * The decision, stated once rather than left implicit: THE VALIDATORS KEEP
- * REQUIRING IT AND THE SKETCHES KEEP OMITTING IT — because the requirement is
- * enforced on the POST-STAMP payload, not on what the worker wrote. The
- * asymmetry is not a drift to be closed in either direction: declaring
- * `created_at` in the sketches would tell the worker to supply a value the tool
- * then overrides (the stamp is `created_at`-wins-if-present, but a host-invented
- * clock reading is still worse than the tool's), and dropping the requirement
- * from the validators would let an artifact that never passed the stamp path —
- * a hand-written file validated directly — carry no timestamp at all.
- *
- * This is a DECISION, not a drift (see the drift test's `created_at` block):
- * the validators keep requiring it and the sketches keep omitting it, because
- * the requirement is enforced on the POST-STAMP payload rather than on what the
- * worker wrote. Closing the asymmetry in either direction is worse — declaring
- * it in the sketches asks the host for a clock reading the tool then overrides,
- * and dropping it from the validators lets a directly-validated hand-written
- * file carry no timestamp at all.
- */
-export declare const CREATED_AT_OWNER: "stampToolCreatedAt";
-/**
- * Whether `value` is one of {@link CYCLIC_SEAM_BREAK_STRATEGIES} — the ONE
- * membership test for the vocabulary, so the tool's post-hoc cycle-break check
- * and the prompt's sketch read the same declaration.
- */
-export declare function isCyclicSeamBreakStrategy(value: unknown): value is (typeof CYCLIC_SEAM_BREAK_STRATEGIES)[number];
-/**
- * Render a sketch fragment for a value vocabulary: `"a | b | c"`.
- *
- * The ONE renderer for every `requireOneOf`-style vocabulary in the sketches,
- * so the separators and quoting in a prompt cannot drift from each other either.
- */
-export declare function sketchValues(values: readonly string[]): string;
-//# sourceMappingURL=sketchSource.d.ts.map

package/dist/remediate/contractPipeline/sketchSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sketchSource.d.ts","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/sketchSource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,+CAA+C,CAAC;AAEnG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,oCAAqC,CAAC;AAElF;;;;GAIG;AACH,eAAO,MAAM,uCAAuC,uBAAwB,CAAC;AAE7E,wDAAwD;AACxD,eAAO,MAAM,4BAA4B,2CAG/B,CAAC;AAEX;;;;;;;;;;;GAWG;AACH,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,+BAA+B,GAChC,MAAM,oBAAoB,CAAC;AAE5B,0CAA0C;AAC1C,eAAO,MAAM,wBAAwB,oFAO3B,CAAC;AAEX,8FAA8F;AAC9F,eAAO,MAAM,6BAA6B,0CAIhC,CAAC;AAEX,2DAA2D;AAC3D,eAAO,MAAM,4BAA4B,+BAAgC,CAAC;AAE1E,4CAA4C;AAC5C,eAAO,MAAM,2BAA2B,+BAAgC,CAAC;AAEzE,2CAA2C;AAC3C,eAAO,MAAM,4BAA4B,4DAK/B,CAAC;AAEX,yCAAyC;AACzC,eAAO,MAAM,yBAAyB,yCAA0C,CAAC;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,6CAItB,CAAC;AAEX,8CAA8C;AAC9C,eAAO,MAAM,gBAAgB,4DAKnB,CAAC;AAEX,+CAA+C;AAC/C,eAAO,MAAM,eAAe,gEAMlB,CAAC;AAEX,+BAA+B;AAC/B,eAAO,MAAM,iBAAiB,oEAKpB,CAAC;AAEX,uCAAuC;AACvC,eAAO,MAAM,mBAAmB,8CAKtB,CAAC;AAEX,iDAAiD;AACjD,eAAO,MAAM,mBAAmB,mDAItB,CAAC;AAEX,qDAAqD;AACrD,eAAO,MAAM,wBAAwB,mCAAoC,CAAC;AAE1E,4CAA4C;AAC5C,eAAO,MAAM,iBAAiB,6DAIpB,CAAC;AAEX,sDAAsD;AACtD,eAAO,MAAM,2BAA2B,iDAI9B,CAAC;AAEX,4CAA4C;AAC5C,eAAO,MAAM,mBAAmB,0CAA2C,CAAC;AAE5E,8BAA8B;AAC9B,eAAO,MAAM,cAAc,uCAAwC,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,8BAA8B,gFAMjC,CAAC;AAEX;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,6BAA8B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,gBAAgB,EAAG,oBAA6B,CAAC;AAE9D;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,OAAO,4BAA4B,CAAC,CAAC,MAAM,CAAC,CAKxD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAE9D"}

package/dist/remediate/contractPipeline/sketchSource.js

@@ -1,262 +0,0 @@
-export { CONCEPTUAL_CRITIQUE_REPAIR_TARGETS } from "../../shared/types/contractPipeline/design.js";
-// sites-pinned: tests/remediate/step-prompt-sketch-drift.test.ts
-/**
- * The value vocabularies a step prompt's schema sketch and its VALIDATOR both
- * read — declared once, here, so they cannot disagree.
- *
- * Why this module exists. A step prompt hands the worker a JSON shape to write,
- * and a validator in `src/remediate/validation/` decides whether what came back
- * is admissible. Those were two independent statements of the same fact: the
- * prompt carried a hand-written sketch (`contractPipelinePrompts.ts`, plus two
- * extra sketches in `contractPipeline.ts`) and the validator carried its own
- * literal list. Measured drifts at HEAD before this module existed:
- *
- *   - `cyclic_seam_resolution.status` — sketch offered 2 values, the validator
- *     admits 4 (`user_decision_required` and `blocked` were unrenderable but
- *     required by the refusal path);
- *   - `judge_report.repair_directive.target` — sketch offered 3, the validator 4
- *     (the fourth, `counterexample`, could never be asked for);
- *   - `verification_report.finding.traces[].kind` — sketch offered 5, the
- *     validator 6;
- *   - `implementation_dag.node.status` — sketch showed exactly 1 of the 4 the
- *     validator admits.
- *
- * Every one is the same failure: a worker reads the sketch, emits a value the
- * sketch allowed, and the tool refuses it — or, worse in the opposite
- * direction, never learns a legal value exists. A drift test made of "remember
- * to update the other one" is exactly the class of guarantee this repo bans
- * (enforce in tooling, never host — or author — discretion), so the fix is not
- * a test that watches two lists. It is ONE declaration, with the validator and
- * the sketch both deriving from it.
- *
- * What is MINED vs DECLARED. The values are declared here; they are NOT read out
- * of the validator module, because a validator states its values as inline
- * `requireOneOf(...)` literals inside a function body — a declaration a test can
- * only reach by parsing source text, which is the brittle thing this replaces.
- * Instead the exported constants are the single declaration and the VALIDATOR
- * imports them, so the drift is impossible by construction rather than detected
- * after the fact. The test in
- * `tests/remediate/step-prompt-sketch-drift.test.ts` then re-derives each
- * vocabulary from what each validator actually REFUSES (by feeding it values),
- * and compares that to the sketch the prompt renders — so a value added to a
- * validator without the sketch still reds, without depending on how the
- * validator happens to spell its list.
- *
- * NOT A LIST. Every value vocabulary that the CONTRACT-PIPELINE role sketches
- * render as an alternation is declared here — the four drifted ones above, the
- * obligation/test-plan pairs, and the nine that were still hand-written literals
- * in `contractPipelinePrompts.ts` (goal `source_type`; context-entry `kind`; the
- * critique item `kind` and `severity`; the critique `verdict`; the assessment
- * finding `status` and report `verdict`; the judge `verdict`; and the judge's
- * counterexample `classification`). That is the whole point: a vocabulary kept
- * as a literal is only safe while someone remembers, and the drift test below
- * sweeps every rendered alternation of those sketches rather than a hand-kept
- * field list, so the next literal to appear reds immediately instead of waiting
- * to be noticed.
- *
- * The scope is those sketches, NOT every sketch in the repository, and the
- * difference is recorded rather than implied: the sweep reaches the modules in
- * `SKETCH_SOURCE_MODULES`, and the clarification-resolution sketch in
- * `steps/prompts.ts` is outside them — a declared-gap row in
- * `tests/shared/promptContractRegistry.ts`. So this module claims nothing about
- * that one, and widening the sweep is its own change.
- */
-/**
- * `cyclic_seam_resolution.status` — what the validator admits. `no_cycles` is
- * the tool's own record, written when the ledger has no cycle; `resolved` is the
- * worker's record of the breaks it made. The escalation states
- * (`user_decision_required`, `blocked`) are routes the gate takes, never a
- * record: nothing wrote them, and a worker that wrote one moved the pipeline
- * forward with the cycles still in the ledger.
- */
-export const CYCLIC_SEAM_RESOLUTION_STATUSES = ["no_cycles", "resolved"];
-/**
- * The subset of {@link CYCLIC_SEAM_RESOLUTION_STATUSES} the worker's sketch
- * offers. The worker is emitted only when the ledger has a cycle, so its one
- * answer is `resolved`; the re-check refuses any record while a cycle remains.
- */
-export const CYCLIC_SEAM_RESOLUTION_STATUSES_OFFERED = ["resolved"];
-/** `cyclic_seam_resolution.cycles[].break_strategy`. */
-export const CYCLIC_SEAM_BREAK_STRATEGIES = [
-    "mediator",
-    "single_authority",
-];
-/**
- * `judge_report.repair_directive.target`, its legacy aliases, and the offered
- * subset — DECLARED in `src/shared/types/contractPipeline/obligations.ts`,
- * beside the `JudgeRepairTarget` type that derives from them, and re-exported
- * here so the validator and the prompt sketches keep reading them from this
- * module.
- *
- * Why they moved. `src/shared` is the base layer; this module lives in
- * `src/remediate`. A value import from the base layer into an orchestrator is
- * the dependency direction inverted, and the declaration had to live on the
- * side the TYPE could reach.
- */
-export { CONTRACT_REPAIR_TARGETS, CONTRACT_REPAIR_TARGETS_LEGACY, CONTRACT_REPAIR_TARGETS_OFFERED, } from "audit-tools/shared";
-/** `verification_report` trace `kind`. */
-export const VERIFICATION_TRACE_KINDS = [
-    "requirement",
-    "invariant",
-    "counterexample",
-    "task",
-    "file",
-    "command",
-];
-/** `verification_report` finding-level `overall_status` (report level excludes `skipped`). */
-export const VERIFICATION_FINDING_STATUSES = [
-    "passed",
-    "failed",
-    "skipped",
-];
-/** `verification_report` report-level `overall_status`. */
-export const VERIFICATION_REPORT_STATUSES = ["passed", "failed"];
-/** `verification_report` trace `status`. */
-export const VERIFICATION_TRACE_STATUSES = ["passed", "failed"];
-/** `implementation_dag.nodes[].status`. */
-export const IMPLEMENTATION_NODE_STATUSES = [
-    "pending",
-    "in_progress",
-    "resolved",
-    "blocked",
-];
-/** `implementation_dag.edges[].kind`. */
-export const IMPLEMENTATION_EDGE_KINDS = ["dependency", "verification"];
-/**
- * `obligation_ledger.obligations[].status`. `satisfied` is reachable only
- * through the tool's own derivation (`contractPipeline/derive.ts`) — a worker
- * emits `pending` and the tool advances it — but the value is part of the
- * contract the prompt describes, so it is declared here rather than implied.
- */
-export const OBLIGATION_STATUSES = [
-    "pending",
-    "satisfied",
-    "failed",
-];
-/** `obligation_ledger.obligations[].kind`. */
-export const OBLIGATION_KINDS = [
-    "invariant",
-    "behavioral",
-    "structural",
-    "test",
-];
-/** `test_validator_plan.test_specs[].kind`. */
-export const TEST_SPEC_KINDS = [
-    "unit",
-    "integration",
-    "schema",
-    "invariant",
-    "e2e",
-];
-/** `goal_spec.source_type`. */
-export const GOAL_SOURCE_TYPES = [
-    "conversation",
-    "document",
-    "structured_audit",
-    "mixed",
-];
-/** `context_bundle.entries[].kind`. */
-export const CONTEXT_ENTRY_KINDS = [
-    "source",
-    "test",
-    "config",
-    "doc",
-];
-/** `conceptual_design_critique.items[].kind`. */
-export const CRITIQUE_ITEM_KINDS = [
-    "concern",
-    "alternative",
-    "suggestion",
-];
-/** `conceptual_design_critique.items[].severity`. */
-export const CRITIQUE_ITEM_SEVERITIES = ["blocking", "advisory"];
-/** `conceptual_design_critique.verdict`. */
-export const CRITIQUE_VERDICTS = [
-    "approved",
-    "approved_with_concerns",
-    "rejected",
-];
-/** `contract_assessment_report.findings[].status`. */
-export const ASSESSMENT_FINDING_STATUSES = [
-    "satisfied",
-    "violated",
-    "uncertain",
-];
-/** `contract_assessment_report.verdict`. */
-export const ASSESSMENT_VERDICTS = ["passed", "failed", "partial"];
-/** `judge_report.verdict`. */
-export const JUDGE_VERDICTS = ["approved", "needs_repair"];
-/**
- * `judge_report.classifications[].classification` — what the judge may decide
- * about one counterexample.
- *
- * Declared here rather than in the validator that reads it, because the judge
- * role's prompt sketch states the same five values and a sketch that renders a
- * hand-written copy of a validator's list is the drift this module bans. The
- * validator imports THIS declaration (it was a local `as const` beside
- * `validateJudgeReport`), so the two are one fact.
- */
-export const COUNTEREXAMPLE_CLASSIFICATIONS = [
-    "accepted",
-    "out_of_scope",
-    "duplicate",
-    "invalid",
-    "residual_risk",
-];
-/**
- * `seam_reconciliation_report.mismatches[].resolution.decision` — which side of
- * a seam adjusts. Declared here beside the rest for ONE reason: the alternative
- * would be to exclude it from the drift test by hand, and an exclusion list is
- * the drift this module exists to make impossible (see the test's alternation
- * sweep, which matches EVERY rendered alternation to a validator probe).
- */
-export const SEAM_RESOLUTION_DECISIONS = ["A", "B", "both"];
-/**
- * The vocabularies that carry a `created_at`, and the ones that do not.
- *
- * `created_at` asymmetry, resolved in one place. Every contract-pipeline
- * validator ends with `requireString(v.created_at, ...)`, and NO sketch
- * declares the field — the reconciliation is `stampToolCreatedAt`
- * (`contractPipeline/artifactStore.ts`), which the tool calls on the payload at
- * ingest and at the `validate-artifact` self-check. The host has no clock, so
- * asking it for a timestamp is asking it to invent one; the tool owns the field
- * and stamps it.
- *
- * The decision, stated once rather than left implicit: THE VALIDATORS KEEP
- * REQUIRING IT AND THE SKETCHES KEEP OMITTING IT — because the requirement is
- * enforced on the POST-STAMP payload, not on what the worker wrote. The
- * asymmetry is not a drift to be closed in either direction: declaring
- * `created_at` in the sketches would tell the worker to supply a value the tool
- * then overrides (the stamp is `created_at`-wins-if-present, but a host-invented
- * clock reading is still worse than the tool's), and dropping the requirement
- * from the validators would let an artifact that never passed the stamp path —
- * a hand-written file validated directly — carry no timestamp at all.
- *
- * This is a DECISION, not a drift (see the drift test's `created_at` block):
- * the validators keep requiring it and the sketches keep omitting it, because
- * the requirement is enforced on the POST-STAMP payload rather than on what the
- * worker wrote. Closing the asymmetry in either direction is worse — declaring
- * it in the sketches asks the host for a clock reading the tool then overrides,
- * and dropping it from the validators lets a directly-validated hand-written
- * file carry no timestamp at all.
- */
-export const CREATED_AT_OWNER = "stampToolCreatedAt";
-/**
- * Whether `value` is one of {@link CYCLIC_SEAM_BREAK_STRATEGIES} — the ONE
- * membership test for the vocabulary, so the tool's post-hoc cycle-break check
- * and the prompt's sketch read the same declaration.
- */
-export function isCyclicSeamBreakStrategy(value) {
-    return (typeof value === "string" &&
-        CYCLIC_SEAM_BREAK_STRATEGIES.includes(value));
-}
-/**
- * Render a sketch fragment for a value vocabulary: `"a | b | c"`.
- *
- * The ONE renderer for every `requireOneOf`-style vocabulary in the sketches,
- * so the separators and quoting in a prompt cannot drift from each other either.
- */
-export function sketchValues(values) {
-    return values.join(" | ");
-}
-//# sourceMappingURL=sketchSource.js.map

package/dist/remediate/contractPipeline/sketchSource.js.map

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

package/dist/remediate/contractPipeline/testPlanCarry.d.ts

@@ -1,17 +0,0 @@
-import type { PriorTestSpec } from "./derive.js";
-export declare function testPlanCarryPath(artifactsDir: string): string;
-/**
- * Snapshot a freshly-ingested test-plan's authored specs (identity + assertions)
- * keyed by obligation_id, overwriting any prior snapshot. Only specs with at
- * least one assertion are carried (an `inapplicable_claim` spec re-authors).
- */
-export declare function captureTestPlanCarry(artifactsDir: string, payload: unknown, capturedAt: string): Promise<void>;
-/**
- * Read the carried prior specs keyed by obligation_id; empty when none.
- *
- * The carry is REGENERABLE state — a carry from another schema version is
- * discarded rather than reinterpreted, which costs one re-authoring of the
- * affected specs and is the same fail-shape as an absent file (below).
- */
-export declare function readTestPlanCarry(artifactsDir: string): Promise<Record<string, PriorTestSpec>>;
-//# sourceMappingURL=testPlanCarry.d.ts.map

package/dist/remediate/contractPipeline/testPlanCarry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testPlanCarry.d.ts","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/testPlanCarry.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAajD,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE9D;AAQD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAMxC"}