audit-tools 0.52.4 → 0.53.0

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

@@ -1,144 +0,0 @@
-/**
- * Single tool-owned authority for the contract-pipeline's id relationships
- * (S4 of the contract-authoring determinism design).
- *
- * Its block-id relationship caused the recurring "Unknown
- * finding_id" merge trap: the one-way bare-node-id to `CP-BLOCK-` block-id mint.
- * Before this module the prefix was constructed by inline string templates at
- * several sites (the DAG->plan promotion built it for both node block ids AND
- * dependency edges; the dispatch alias map built it again). With the node id and
- * prefix minted in exactly ONE place each, dispatch and merge consume the same
- * persisted identity without a reverse-mapping API.
- *
- * The block-id API is intentionally one-way: callers consume the persisted id
- * minted by `toBlockId` rather than reverse-mapping it.
- * It is a pure module — no IO, no model identity — so it is testable in
- * isolation and feeds the hash/staleness DAG cleanly.
- */
-/** The one prefix that marks a dispatch block id derived from a DAG node id. */
-export declare const CP_BLOCK_PREFIX = "CP-BLOCK-";
-/**
- * Mint the canonical bare node id for a DAG node, applying the deterministic
- * `CP-NNN` fallback when the planner-authored `node.id` is missing (the DAG is
- * parsed from an LLM envelope via an unchecked cast, so `id` can be absent at
- * runtime). This is the ONE place the fallback rule lives, so a node's finding
- * id, block id, `items`, and traceability key can never diverge.
- *
- * This closes a merge-trap: when `node.id` was missing, the finding id used this
- * fallback (`CP-001`) but the block id was built from the raw `node.id`
- * (`CP-BLOCK-undefined`), so the worker result landed in `unresolved`. Routing
- * every node-id site through `ensureNodeId` keeps the finding and block mints
- * aligned.
- */
-export declare function ensureNodeId(rawId: string | undefined, index: number): string;
-/**
- * Mint the block id for a bare DAG node id. This is the ONLY place the
- * `CP-BLOCK-` prefix is applied — every producer of a block id goes through here.
- */
-export declare function toBlockId(nodeId: string): string;
-/** The one prefix every derived obligation id carries. */
-export declare const OBLIGATION_PREFIX = "OBL-";
-/**
- * Lowercase-hyphenate a module name into the id fragment obligation ids encode.
- *
- * The ENCODER (`derive.ts`, minting `OBL-<slug>-…`) and the DECODERS (phase
- * resolution, write-scope inheritance) must agree exactly, or an obligation
- * resolves to no module and its node silently loses its phase and file scope.
- * They previously agreed by way of two identical implementations and a comment
- * saying they must stay in lockstep — a drift test made of memory. One
- * implementation, here with the rest of the id authority, cannot drift.
- */
-export declare function moduleSlug(name: string): string;
-/**
- * Mint a derived obligation id from a module name and a suffix — the ONLY place
- * the `OBL-<slug>-<suffix>` shape is applied, so the decoders above are matching
- * a format with a single author. Callers still pass the result through
- * `mintUniqueId` for collision disambiguation.
- */
-export declare function obligationId(moduleName: string, suffix: string): string;
-/**
- * The ONE exact join from a derived obligation id back to its module slug, or
- * `null` when the id carries no obligation prefix or its body is not
- * `<knownSlug>-<grammaticalSuffix>`.
- *
- * `knownSlugs` MUST be the module slugs in scope; the match is exact, so the
- * caller need not pre-sort them (the previous longest-first sort existed only
- * to arbitrate the prefix ambiguity this rule removes).
- */
-export declare function moduleSlugForObligationId(id: string, knownSlugs: ReadonlySet<string>): string | null;
-/**
- * The one shape a contract-pipeline `goal_id` may take.
- *
- * Why a grammar at all. `goal_id` is the identity JOINING fifteen artifacts —
- * `deriveFinalizedModuleContracts` carries it onto the finalized contracts,
- * `deriveObligationLedger` onto the ledger, `contract_goal_id` onto every
- * promoted finding, and `validateGoalIdConsistency` reds the run when two
- * artifacts disagree. It is the ONE id in this pipeline minted by the LLM
- * rather than by the tool (`goal_normalization` is its sole origin), and its
- * entire specification the model ever saw was the prompt placeholder
- * `<stable-identifier>`. So the format was whatever the model happened to emit:
- * observed values in this repo include `G1`, `GOAL-001`, `goal-abc`, `g`,
- * `goal-test`, and `goal-self-audit-2026-08-21-first-draw`.
- *
- * That matters because an unvalidated identity is not an identity. `goal_id`
- * becomes a path/plan-row join and a consistency key, and the entry's own
- * recorded incident is two artifacts authored in one run under `goal-test` and
- * `g` (audit finding MNT-4829db27-3) — a mismatch only the equality gate
- * catches, and only when both are present.
- *
- * The rule: a lowercase alphanumeric slug, hyphen-separated, starting with a
- * letter, between 1 and 64 characters. Deliberately PERMISSIVE about content —
- * a goal id is an opaque handle, and the model is free to name the goal
- * meaningfully — but STRICT about shape, so an empty string, a placeholder left
- * unsubstituted (`<stable-identifier>`), or a free-text sentence is refused on
- * the way in.
- *
- * A single-token id (`g`, `g1`, `auth`) is deliberately ADMITTED despite being
- * a poor name: the grammar's job is to refuse a non-identity, not to grade one,
- * and the alternative — requiring a hyphen — would retroactively invalidate ids
- * already persisted by real runs. The property the entry asks for is "minted by
- * the registry OR validated on the way in", and validation that rejects
- * everything already in the wild is a migration, not a validation.
- *
- * Kept here, beside the obligation/node/block mints, for the reason this
- * module's header gives: a grammar only one side knows is a drift test made of
- * memory. `derive.ts` validates on the way in; `validation/contractPipeline.ts`
- * and the consistency gate read the same predicate.
- */
-export declare const GOAL_ID_PATTERN: RegExp;
-/** The longest goal id the grammar admits. */
-export declare const GOAL_ID_MAX_LENGTH = 64;
-/**
- * Whether `value` is a well-formed goal id. The ONE home for the question; a
- * caller that re-spells the regex has forked the grammar.
- */
-export declare function isGoalId(value: unknown): value is string;
-/**
- * Coerce a host-supplied `goal_id` to a well-formed one, or return the empty
- * string when it cannot be repaired.
- *
- * Lowercases and slugifies rather than rejecting outright, because the LLM is
- * the producer and a near-miss (`Goal-001`, `goal_001`, `Goal 1`) is the
- * expected input shape — refusing it would strand the pipeline on a
- * formatting detail. What it will NOT do is invent an id from nothing: an
- * absent or placeholder value yields `""`, and every reader's existing
- * empty-string handling stays the signal that no goal id was established.
- * Deterministic: the same input always yields the same id.
- *
- * Case-folding is load-bearing, not cosmetic. `validateGoalIdConsistency`
- * compares ids for EXACT string equality and reds the run on any difference, so
- * under the previous verbatim read two shards that each wrote `Goal-1` and
- * `goal-1` for the same goal would fail the gate — and the failure would name a
- * mismatch where no disagreement exists. Folding on the way in makes the gate's
- * strict comparison mean what it says.
- *
- * The placeholder guard is not decoration. Slugifying alone would turn the
- * prompt's own placeholder `<stable-identifier>` into the well-formed-looking
- * `stable-identifier` — MANUFACTURING an identity out of a failure to
- * substitute one, which is strictly worse than the verbatim read it replaces
- * (that at least kept the angle brackets, so a human could see it). A value
- * that is not already slug-shaped once whitespace is trimmed is a value the
- * model did not mean as an id, so it yields `""` rather than a plausible slug.
- */
-export declare function coerceGoalId(value: unknown): string;
-//# sourceMappingURL=idRegistry.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"idRegistry.d.ts","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/idRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,gFAAgF;AAChF,eAAO,MAAM,eAAe,cAAc,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,KAAK,EAAE,MAAM,GACZ,MAAM,CAER;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,0DAA0D;AAC1D,eAAO,MAAM,iBAAiB,SAAS,CAAC;AAExC;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEvE;AA8BD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,MAAM,GAAG,IAAI,CAUf;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,eAAe,QAAqC,CAAC;AAElE,8CAA8C;AAC9C,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAOxD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAgBnD"}

package/dist/remediate/contractPipeline/idRegistry.js

@@ -1,214 +0,0 @@
-/**
- * Single tool-owned authority for the contract-pipeline's id relationships
- * (S4 of the contract-authoring determinism design).
- *
- * Its block-id relationship caused the recurring "Unknown
- * finding_id" merge trap: the one-way bare-node-id to `CP-BLOCK-` block-id mint.
- * Before this module the prefix was constructed by inline string templates at
- * several sites (the DAG->plan promotion built it for both node block ids AND
- * dependency edges; the dispatch alias map built it again). With the node id and
- * prefix minted in exactly ONE place each, dispatch and merge consume the same
- * persisted identity without a reverse-mapping API.
- *
- * The block-id API is intentionally one-way: callers consume the persisted id
- * minted by `toBlockId` rather than reverse-mapping it.
- * It is a pure module — no IO, no model identity — so it is testable in
- * isolation and feeds the hash/staleness DAG cleanly.
- */
-/** The one prefix that marks a dispatch block id derived from a DAG node id. */
-export const CP_BLOCK_PREFIX = "CP-BLOCK-";
-/**
- * Mint the canonical bare node id for a DAG node, applying the deterministic
- * `CP-NNN` fallback when the planner-authored `node.id` is missing (the DAG is
- * parsed from an LLM envelope via an unchecked cast, so `id` can be absent at
- * runtime). This is the ONE place the fallback rule lives, so a node's finding
- * id, block id, `items`, and traceability key can never diverge.
- *
- * This closes a merge-trap: when `node.id` was missing, the finding id used this
- * fallback (`CP-001`) but the block id was built from the raw `node.id`
- * (`CP-BLOCK-undefined`), so the worker result landed in `unresolved`. Routing
- * every node-id site through `ensureNodeId` keeps the finding and block mints
- * aligned.
- */
-export function ensureNodeId(rawId, index) {
-    return rawId ?? `CP-${String(index + 1).padStart(3, "0")}`;
-}
-/**
- * Mint the block id for a bare DAG node id. This is the ONLY place the
- * `CP-BLOCK-` prefix is applied — every producer of a block id goes through here.
- */
-export function toBlockId(nodeId) {
-    return `${CP_BLOCK_PREFIX}${nodeId}`;
-}
-/** The one prefix every derived obligation id carries. */
-export const OBLIGATION_PREFIX = "OBL-";
-/**
- * Lowercase-hyphenate a module name into the id fragment obligation ids encode.
- *
- * The ENCODER (`derive.ts`, minting `OBL-<slug>-…`) and the DECODERS (phase
- * resolution, write-scope inheritance) must agree exactly, or an obligation
- * resolves to no module and its node silently loses its phase and file scope.
- * They previously agreed by way of two identical implementations and a comment
- * saying they must stay in lockstep — a drift test made of memory. One
- * implementation, here with the rest of the id authority, cannot drift.
- */
-export function moduleSlug(name) {
-    return name.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
-}
-/**
- * Mint a derived obligation id from a module name and a suffix — the ONLY place
- * the `OBL-<slug>-<suffix>` shape is applied, so the decoders above are matching
- * a format with a single author. Callers still pass the result through
- * `mintUniqueId` for collision disambiguation.
- */
-export function obligationId(moduleName, suffix) {
-    return `${OBLIGATION_PREFIX}${moduleSlug(moduleName) || "module"}-${suffix}`;
-}
-/**
- * The suffix GRAMMAR of a derived obligation id — the `…-<suffix>` half, and the
- * half that makes the id → module join exact rather than longest-prefix.
- *
- * Why it has to exist. The decoders (`phaseOrdinalForObligations`, the
- * promotion's module-contract attachment) recover a module from its obligation
- * ids by matching a slug against the id BODY. Two distinct module names can
- * collide there in one direction: `auth` and `auth-service` are different
- * modules, and `OBL-auth-service-contract` starts with `auth-`. Longest-slug-
- * first picks `auth-service` and happens to be right, but only because the
- * SLUG SET is what decides — a plan whose `auth-service` obligations were
- * emitted before the module registry knew that name would silently resolve them
- * to `auth`, and the node would take `auth`'s phase and file scope.
- *
- * The suffix is the tiebreak that removes the guess: once the grammar is
- * stripped, the remaining body must equal a known slug EXACTLY. A module name
- * is free-form prose, so it can contain `contract` or `inv-2`; what it cannot
- * do is make the exact-equality test pass for a DIFFERENT module, because the
- * candidate body is only ever the id minus its one grammatical suffix.
- *
- * Kept here, beside the mint, for the same reason `moduleSlug` is: a grammar
- * only the encoder knows is a drift test made of memory. `derive.ts` is the
- * encoder and imports `obligationId` from this module; the suffixed forms it
- * mints are `contract`, `inv-<n>`, and `fail-<n>`, and `mintUniqueId`
- * (`audit-tools/shared`) appends `-<n>` to disambiguate a collision.
- */
-const OBLIGATION_SUFFIX_PATTERN = /^(?:contract|inv-\d+|fail-\d+)(?:-\d+)?$/u;
-/**
- * The ONE exact join from a derived obligation id back to its module slug, or
- * `null` when the id carries no obligation prefix or its body is not
- * `<knownSlug>-<grammaticalSuffix>`.
- *
- * `knownSlugs` MUST be the module slugs in scope; the match is exact, so the
- * caller need not pre-sort them (the previous longest-first sort existed only
- * to arbitrate the prefix ambiguity this rule removes).
- */
-export function moduleSlugForObligationId(id, knownSlugs) {
-    if (!id.startsWith(OBLIGATION_PREFIX))
-        return null;
-    const body = id.slice(OBLIGATION_PREFIX.length);
-    for (let index = body.lastIndexOf("-"); index > 0; index = body.lastIndexOf("-", index - 1)) {
-        const slug = body.slice(0, index);
-        if (knownSlugs.has(slug) && OBLIGATION_SUFFIX_PATTERN.test(body.slice(index + 1))) {
-            return slug;
-        }
-    }
-    return null;
-}
-// ── The goal-id grammar ─────────────────────────────────────────────────────
-/**
- * The one shape a contract-pipeline `goal_id` may take.
- *
- * Why a grammar at all. `goal_id` is the identity JOINING fifteen artifacts —
- * `deriveFinalizedModuleContracts` carries it onto the finalized contracts,
- * `deriveObligationLedger` onto the ledger, `contract_goal_id` onto every
- * promoted finding, and `validateGoalIdConsistency` reds the run when two
- * artifacts disagree. It is the ONE id in this pipeline minted by the LLM
- * rather than by the tool (`goal_normalization` is its sole origin), and its
- * entire specification the model ever saw was the prompt placeholder
- * `<stable-identifier>`. So the format was whatever the model happened to emit:
- * observed values in this repo include `G1`, `GOAL-001`, `goal-abc`, `g`,
- * `goal-test`, and `goal-self-audit-2026-08-21-first-draw`.
- *
- * That matters because an unvalidated identity is not an identity. `goal_id`
- * becomes a path/plan-row join and a consistency key, and the entry's own
- * recorded incident is two artifacts authored in one run under `goal-test` and
- * `g` (audit finding MNT-4829db27-3) — a mismatch only the equality gate
- * catches, and only when both are present.
- *
- * The rule: a lowercase alphanumeric slug, hyphen-separated, starting with a
- * letter, between 1 and 64 characters. Deliberately PERMISSIVE about content —
- * a goal id is an opaque handle, and the model is free to name the goal
- * meaningfully — but STRICT about shape, so an empty string, a placeholder left
- * unsubstituted (`<stable-identifier>`), or a free-text sentence is refused on
- * the way in.
- *
- * A single-token id (`g`, `g1`, `auth`) is deliberately ADMITTED despite being
- * a poor name: the grammar's job is to refuse a non-identity, not to grade one,
- * and the alternative — requiring a hyphen — would retroactively invalidate ids
- * already persisted by real runs. The property the entry asks for is "minted by
- * the registry OR validated on the way in", and validation that rejects
- * everything already in the wild is a migration, not a validation.
- *
- * Kept here, beside the obligation/node/block mints, for the reason this
- * module's header gives: a grammar only one side knows is a drift test made of
- * memory. `derive.ts` validates on the way in; `validation/contractPipeline.ts`
- * and the consistency gate read the same predicate.
- */
-export const GOAL_ID_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
-/** The longest goal id the grammar admits. */
-export const GOAL_ID_MAX_LENGTH = 64;
-/**
- * Whether `value` is a well-formed goal id. The ONE home for the question; a
- * caller that re-spells the regex has forked the grammar.
- */
-export function isGoalId(value) {
-    return (typeof value === "string" &&
-        value.length > 0 &&
-        value.length <= GOAL_ID_MAX_LENGTH &&
-        GOAL_ID_PATTERN.test(value));
-}
-/**
- * Coerce a host-supplied `goal_id` to a well-formed one, or return the empty
- * string when it cannot be repaired.
- *
- * Lowercases and slugifies rather than rejecting outright, because the LLM is
- * the producer and a near-miss (`Goal-001`, `goal_001`, `Goal 1`) is the
- * expected input shape — refusing it would strand the pipeline on a
- * formatting detail. What it will NOT do is invent an id from nothing: an
- * absent or placeholder value yields `""`, and every reader's existing
- * empty-string handling stays the signal that no goal id was established.
- * Deterministic: the same input always yields the same id.
- *
- * Case-folding is load-bearing, not cosmetic. `validateGoalIdConsistency`
- * compares ids for EXACT string equality and reds the run on any difference, so
- * under the previous verbatim read two shards that each wrote `Goal-1` and
- * `goal-1` for the same goal would fail the gate — and the failure would name a
- * mismatch where no disagreement exists. Folding on the way in makes the gate's
- * strict comparison mean what it says.
- *
- * The placeholder guard is not decoration. Slugifying alone would turn the
- * prompt's own placeholder `<stable-identifier>` into the well-formed-looking
- * `stable-identifier` — MANUFACTURING an identity out of a failure to
- * substitute one, which is strictly worse than the verbatim read it replaces
- * (that at least kept the angle brackets, so a human could see it). A value
- * that is not already slug-shaped once whitespace is trimmed is a value the
- * model did not mean as an id, so it yields `""` rather than a plausible slug.
- */
-export function coerceGoalId(value) {
-    if (typeof value !== "string")
-        return "";
-    const trimmed = value.trim();
-    // Refuse anything carrying structure a goal id cannot have: angle brackets
-    // (a template placeholder), whitespace runs between words (prose), or any
-    // punctuation outside the hyphen/underscore separators we fold.
-    if (/[<>{}[\]"'`/\\.,;:!?()@#$%^&*+=|~]/u.test(trimmed))
-        return "";
-    if (/\s/u.test(trimmed) && !/^[A-Za-z0-9]+(?:[\s_-]+[A-Za-z0-9]+)+$/u.test(trimmed)) {
-        return "";
-    }
-    const slug = trimmed
-        .toLowerCase()
-        .replace(/[\s_]+/gu, "-")
-        .replace(/-+/gu, "-")
-        .replace(/^-+|-+$/gu, "");
-    return isGoalId(slug) ? slug : "";
-}
-//# sourceMappingURL=idRegistry.js.map

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

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

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

@@ -1,27 +0,0 @@
-/**
- * One vocabulary for contract-pipeline obligation kinds. Definition order
- * preserves the observable TESTABLE_OBLIGATION_KINDS iteration order; the
- * explicit priority rank preserves the load-bearing lens/severity order.
- */
-declare const OBLIGATION_KIND_DEFINITIONS: readonly [{
-    readonly kind: "invariant";
-    readonly testable: true;
-    readonly priority: 3;
-}, {
-    readonly kind: "behavioral";
-    readonly testable: true;
-    readonly priority: 2;
-}, {
-    readonly kind: "structural";
-    readonly testable: false;
-    readonly priority: 1;
-}, {
-    readonly kind: "test";
-    readonly testable: false;
-    readonly priority: 0;
-}];
-export type ObligationKind = (typeof OBLIGATION_KIND_DEFINITIONS)[number]["kind"];
-export declare const OBLIGATION_KIND_PRIORITY: readonly ObligationKind[];
-export declare const TESTABLE_OBLIGATION_KINDS: Set<string>;
-export {};
-//# sourceMappingURL=obligationKinds.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"obligationKinds.d.ts","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/obligationKinds.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;EAKvB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAElF,eAAO,MAAM,wBAAwB,EAAE,SAAS,cAAc,EAIpC,CAAC;AAE3B,eAAO,MAAM,yBAAyB,aAErC,CAAC"}

package/dist/remediate/contractPipeline/obligationKinds.js

@@ -1,18 +0,0 @@
-/**
- * One vocabulary for contract-pipeline obligation kinds. Definition order
- * preserves the observable TESTABLE_OBLIGATION_KINDS iteration order; the
- * explicit priority rank preserves the load-bearing lens/severity order.
- */
-const OBLIGATION_KIND_DEFINITIONS = [
-    { kind: "invariant", testable: true, priority: 3 },
-    { kind: "behavioral", testable: true, priority: 2 },
-    { kind: "structural", testable: false, priority: 1 },
-    { kind: "test", testable: false, priority: 0 },
-];
-export const OBLIGATION_KIND_PRIORITY = [
-    ...OBLIGATION_KIND_DEFINITIONS,
-]
-    .sort((left, right) => left.priority - right.priority)
-    .map(({ kind }) => kind);
-export const TESTABLE_OBLIGATION_KINDS = new Set(OBLIGATION_KIND_DEFINITIONS.filter(({ testable }) => testable).map(({ kind }) => kind));
-//# sourceMappingURL=obligationKinds.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"obligationKinds.js","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/obligationKinds.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,2BAA2B,GAAG;IAClC,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;IAClD,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;IACnD,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE;IACpD,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EAAE;CACtC,CAAC;AAIX,MAAM,CAAC,MAAM,wBAAwB,GAA8B;IACjE,GAAG,2BAA2B;CAC/B;KACE,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;KACrD,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;AAE3B,MAAM,CAAC,MAAM,yBAAyB,GAAG,IAAI,GAAG,CAC9C,2BAA2B,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CACvF,CAAC"}

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

@@ -1,125 +0,0 @@
-/**
- * Deterministic phase-cut derivation (remediator auto-phasing, T3).
- *
- * When `/remediate-code` is pointed at an arbitrary N-goal input (e.g. the whole
- * backlog), the independent conceptual-design critique used to reject the run as
- * "over-scoped" and the HOST had to manually re-scope to a phase at intake. That
- * is the tool's job, not the host's: given the module-dependency DAG (the
- * producer/consumer `artifact:<name>` token edges declared in the contracts'
- * inputs/outputs), the tool derives a foundations→consumers
- * phase cut MECHANICALLY — ordered tiers where every module sits one tier below
- * the modules that depend on it. The critique is then handed the derived cut, so
- * it assesses design quality WITHIN a mechanically dependency-ordered phasing
- * rather than rejecting breadth (over-scoping is already handled by construction).
- *
- * Pure + deterministic (no I/O, no Date/Math.random, stable ordering): the same
- * modules always yield the same cut. Cycle-safe — a dependency cycle cannot be
- * topologically tiered, so its members are placed together at the tier just past
- * their highest acyclic dependency (named-sorted, fail toward a LATER tier so a
- * cyclic module never front-runs a real foundation it transitively needs).
- */
-import { moduleSlugForObligationId } from "./idRegistry.js";
-/** One module + the names of the other modules it depends on (its foundations). */
-export interface PhaseCutModule {
-    name: string;
-    /** Names of modules this module needs in place first (directional: this → dep). */
-    depends_on: string[];
-}
-/** One derived phase: an ordered tier of modules that may be authored together. */
-export interface PhaseCutPhase {
-    /** 0-based tier ordinal; 0 = foundations. */
-    ordinal: number;
-    /** Stable human label for the tier. */
-    name: string;
-    /** Module names in this tier, sorted for determinism. */
-    modules: string[];
-}
-/** The derived phase cut: ordered tiers covering every module exactly once. */
-export interface PhaseCut {
-    phases: PhaseCutPhase[];
-    /** True when a dependency cycle was detected (its members were tiered together). */
-    has_cycle: boolean;
-    /** Module name → 0-based phase ordinal (foundations = 0). The downstream key. */
-    module_phase: Record<string, number>;
-}
-/**
- * Derive the ordered phase cut from a module-dependency DAG. Each module's tier is
- * the length of its longest dependency chain (foundations = 0). Edges to unknown
- * module names are ignored (a `needs` on a module not in scope is not a phase
- * constraint here). Returns one phase per occupied tier, covering every module.
- */
-export declare function derivePhaseCut(modules: PhaseCutModule[]): PhaseCut;
-/**
- * The id fragment obligation ids encode — re-exported from the id registry,
- * which owns both this and the mint that produces `OBL-<slug>-…`, so encoder and
- * decoder cannot drift. Kept exported here because this module is where the
- * node→phase decoders live and import it from.
- */
-export { moduleSlug } from "./idRegistry.js";
-/**
- * Resolve the phase ordinal for an implementation-DAG node from the obligation
- * ids it discharges. Every derived obligation id is `OBL-<moduleSlug>-<suffix>`,
- * so the owning module (hence phase) is recoverable by the EXACT join in
- * `idRegistry.moduleSlugForObligationId` — no lossy slug reversal, and no
- * longest-prefix guess (that rule resolved `OBL-auth-service-…` to `auth`
- * whenever `auth-service` was not in the slug set, silently handing the node
- * another module's phase and file scope). A node spanning modules in several
- * phases takes the MAX ordinal (fail-toward-later: it cannot land before the
- * latest module it touches is reachable). A node whose obligations match no
- * in-scope module slug — a counterexample-only node, or an obligation from a
- * module dropped from the cut — defaults to the LAST phase (integration), never
- * front-running a foundation.
- *
- * `slugToOrdinal` is the module-phase map re-keyed by `moduleSlug(name)`.
- */
-export declare function phaseOrdinalForObligations(obligationIds: readonly string[], slugToOrdinal: Map<string, number>, lastOrdinal: number): number;
-export { moduleSlugForObligationId };
-/** One producer→consumer pairing and the artifact token that links it. */
-interface ArtifactTokenEdge {
-    /** The depending module — it consumes the artifact. */
-    consumer: string;
-    /** The module it depends on — it produces the artifact. */
-    producer: string;
-    /** The normalized artifact name from the `artifact:<name>` token. */
-    artifact: string;
-}
-/**
- * Build {@link PhaseCutModule}s from finalized module contracts. A module's
- * `depends_on` derives from producer/consumer artifact-token matching over
- * `inputs`/`outputs` ALONE. Drafted `neighbor_needs` never enter this graph
- * (open-bugs.md:106): they are symmetric coordination prose whose directions
- * per-module drafting agents routinely invert, and unioning them in let prose
- * override every declared token edge — finalization drops the field instead.
- * A module that consumes from another is one tier ABOVE it. Tolerant of
- * malformed payloads: anything unparseable contributes no module/edge.
- */
-export declare function phaseCutModulesFromContracts(contractsPayload: unknown): PhaseCutModule[];
-/** One declared-graph cycle: its member modules and the token edges among them. */
-export interface ContractTokenCycle {
-    /** Cycle members, in stable input order. */
-    members: string[];
-    /** The consumer→producer token edges between cycle members. */
-    edges: ArtifactTokenEdge[];
-}
-/**
- * Detect cycles in the DECLARED module-dependency graph — the producer/consumer
- * `artifact:` token edges of a module-contracts payload (drafted or finalized;
- * finalization copies `inputs`/`outputs` verbatim, so the two graphs are equal).
- * A cycle here is a VALIDATION error at the contract boundary (open-bugs.md:106):
- * the phase cut must never be derived over a cyclic declared graph, because the
- * fail-toward-later tiering silently drops a back-edge and places token
- * consumers ahead of their producers. Members and their linking edges are
- * reported so the repair prompt can name exactly which tokens form each cycle.
- */
-export declare function detectContractTokenCycles(contractsPayload: unknown): ContractTokenCycle[];
-/**
- * Add Path-A seam-preparation edges to the contract-derived module DAG. The
- * decomposition gate has already guaranteed one preparer per required seam;
- * this projection makes every implementation module for either participating
- * work block depend on that preparer, yielding a seam-first phase followed by
- * parallel refactor modules.
- */
-export declare function applyWorkBlockSeamDependencies(modules: PhaseCutModule[], moduleDecompositionPayload: unknown, pathASeedPayload: unknown): PhaseCutModule[];
-/** Render the derived phase cut as a markdown section for the critique prompt. */
-export declare function renderPhaseCutSection(cut: PhaseCut): string;
-//# sourceMappingURL=phaseCut.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"phaseCut.d.ts","sourceRoot":"","sources":["../../../src/remediate/contractPipeline/phaseCut.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAI5D,mFAAmF;AACnF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,mFAAmF;AACnF,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,+EAA+E;AAC/E,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,oFAAoF;IACpF,SAAS,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC;AASD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,QAAQ,CAiElE;AAED;;;;;GAKG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,WAAW,EAAE,MAAM,GAClB,MAAM,CAWR;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAC;AA+BrC,0EAA0E;AAC1E,UAAU,iBAAiB;IACzB,uDAAuD;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAiDD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAAC,gBAAgB,EAAE,OAAO,GAAG,cAAc,EAAE,CAYxF;AAED,mFAAmF;AACnF,MAAM,WAAW,kBAAkB;IACjC,4CAA4C;IAC5C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,+DAA+D;IAC/D,KAAK,EAAE,iBAAiB,EAAE,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,gBAAgB,EAAE,OAAO,GAAG,kBAAkB,EAAE,CAYzF;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,cAAc,EAAE,EACzB,0BAA0B,EAAE,OAAO,EACnC,gBAAgB,EAAE,OAAO,GACxB,cAAc,EAAE,CAiElB;AAED,kFAAkF;AAClF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,CAmB3D"}