@proposit/proposit-core 0.12.1 → 1.0.0

package/dist/lib/grammar/populate-from.js

@@ -0,0 +1,252 @@
+// C6: populateFromCitations / populateFromAxioms factory pattern.
+//
+// Per briefing §7 (post-handoff refinement, 2026-05-14):
+//   - Each method is a factory operating on naked-Q derivation premises.
+//   - For 0 connections: no-op (naked-Q stays).
+//   - For 1 connection: IMPLIES(supporting-var, Q).
+//   - For ≥2 connections: IMPLIES(OR(s1, …, sn), Q). In assistive mode
+//     a formula buffer is inserted between IMPLIES and OR by the
+//     post-build `engine.normalize()` call (AN-1); in permissive mode
+//     the OR sits directly under IMPLIES (Structural-valid, but a
+//     P-1 violation surfaces via validate('presentable')).
+//   - If the target derivation premise is already populated (non-naked-Q),
+//     factory returns kind='no-op' without mutating — preserves Proposit's
+//     no-changes-without-consent principle AND the Structural-only
+//     mutation throw rule. UI/caller is responsible for clearing the
+//     antecedent (via a repair primitive) before re-calling.
+//   - If no derivation premise exists for derivedClaimId: throws (entity-
+//     not-found is a legitimate Structural integrity check).
+//
+// **D2b — permissive-build + explicit normalize() pattern.** The
+// expression-tree build is incremental (`removeExpression(nakedRoot)`
+// → `addExpression(IMPLIES)` → antecedent children → consequent Q).
+// Under the post-mutation AN hook (assistive mode), AN-3 would
+// eagerly collapse 0-child operators between addExpression calls —
+// e.g., after `addExpression(IMPLIES, parent=null)` the IMPLIES has
+// zero children and AN-3 deletes it, so the next addExpression
+// trying to add a child of IMPLIES throws "Parent does not exist".
+// To avoid this, the factory switches to `permissive` for the build
+// and runs a single explicit `engine.normalize()` at the end (only
+// when the caller was originally in assistive mode). This is the
+// canonical incremental-builder pattern for the v1.0 grammar model.
+//
+// **Atomicity contract.** The factory is observed-atomic: callers
+// never see a half-populated tree. The expression-tree replacement
+// proceeds as `removeExpression(nakedRoot)` followed by sequential
+// `addExpression` calls for the populated IMPLIES/OR/var skeleton. All
+// mutations are bundled inside a single synchronous call frame; no
+// reactive listener fires between them on the post-mutation state, and
+// no other engine method runs concurrently (JS is single-threaded).
+// External observers only ever see the pre-call naked-Q state or the
+// fully populated post-call state. The intermediate "tree empty" /
+// "tree partially built" states exist transiently in memory but are
+// never observable from outside `populateFromGrounding`'s call frame.
+//
+// Return shape:
+//   { kind: 'populated' | 'no-op',
+//     state: TCoreDerivationPremise,
+//     resolved?: readonly TViolation[] }
+import { isNakedQTree } from "./naked-q.js";
+/**
+ * Run the factory for one grounding kind. Shared by
+ * `populateFromCitations` / `populateFromAxioms` — the only difference
+ * between them is which lookup is queried.
+ *
+ * @since 1.0.0
+ */
+export function populateFromGrounding(engine, derivedClaimId, lookup) {
+    const pe = findDerivationPremiseForClaim(engine, derivedClaimId);
+    if (pe === undefined) {
+        throw new Error(`populateFrom: no derivation premise found for derivedClaimId "${derivedClaimId}".`);
+    }
+    // Naked-Q precondition: the premise's expression tree must be a
+    // single variable expression at the root. Any other shape (already
+    // populated, or some other malformed state) → no-op + return the
+    // existing premise data. The premise's `type === 'derivation'` is
+    // already guaranteed by `findDerivationPremiseForClaim`, so the
+    // tree-shape-only `isNakedQTree` is the correct predicate here.
+    if (!isNakedQTree(pe)) {
+        return {
+            kind: "no-op",
+            state: pe.toPremiseData(),
+        };
+    }
+    // Collect unique supporting claim ids in source order. Connection
+    // duplicates (same supportingClaimId appearing twice) collapse to
+    // one OR child each.
+    const connections = lookup.getConnectionsForClaim(derivedClaimId);
+    const seen = new Set();
+    const supportingIds = [];
+    for (const c of connections) {
+        if (seen.has(c.supportingClaimId))
+            continue;
+        seen.add(c.supportingClaimId);
+        supportingIds.push(c.supportingClaimId);
+    }
+    if (supportingIds.length === 0) {
+        // No supports → nothing to build. Naked-Q stays.
+        return {
+            kind: "no-op",
+            state: pe.toPremiseData(),
+        };
+    }
+    // Materialize claim-bound variables for each supporting claim. The
+    // engine's `ensureClaimBoundVariable` is idempotent and resolves the
+    // current claim version from the claim library; if any of these
+    // throws CLAIM_NOT_FOUND, propagate (the caller passed a stale
+    // lookup pointing at claims that aren't in the engine's library).
+    const supportingVars = supportingIds.map((id) => engine.ensureClaimBoundVariable(id));
+    // Capture the current Q-root expression id so we can replace it
+    // atomically. After this point, mutations on `pe` rebuild the tree.
+    // From this point onward up to the final addExpression call, the
+    // tree passes through transient empty / partial states; per the
+    // atomicity comment at the top of this file those states are not
+    // externally observable.
+    const nakedRoot = pe.getRootExpression();
+    const qVariableId = nakedRoot.variableId;
+    const argId = engine.getArgument().id;
+    const argVersion = engine.getArgument().version;
+    const premiseId = pe.getId();
+    const gen = engine.idGenerator;
+    // D2b — permissive-build + explicit normalize() pattern. The
+    // incremental tree-build below (`removeExpression(nakedRoot)`,
+    // then `addExpression(IMPLIES)`, then antecedent, then Q) passes
+    // through transient states where parents have 0 children. Under
+    // the post-mutation AN hook (assistive mode), AN-3 would
+    // eagerly collapse those 0-child operators between addExpression
+    // calls, breaking the build. We disarm AN for the build by
+    // switching to permissive, then re-arm + run a single explicit
+    // `engine.normalize()` at the end to apply AN-1 (formula buffer
+    // between IMPLIES and OR) on the fully-built tree.
+    //
+    // The saved-behavior capture + try/finally is essential: if a
+    // mutation inside the build throws, the engine's behavior is
+    // restored to its pre-call value rather than left stuck in
+    // permissive mode. The `normalize()` call only runs on the
+    // success path (it's inside the try after all mutations
+    // succeeded) and only when the engine was originally in
+    // assistive mode — permissive callers want the un-normalized
+    // form per the populate-from JSDoc.
+    const savedBehavior = engine.behavior;
+    if (savedBehavior === "assistive") {
+        engine.setBehavior("permissive");
+    }
+    try {
+        // Step 1: remove the naked-Q root (cascades nothing — it's a
+        // leaf).
+        pe.removeExpression(nakedRoot.id, true);
+        // Step 2: add IMPLIES at root.
+        const impliesId = gen();
+        pe.addExpression({
+            id: impliesId,
+            argumentId: argId,
+            argumentVersion: argVersion,
+            premiseId,
+            type: "operator",
+            operator: "implies",
+            parentId: null,
+            position: 0,
+        });
+        // Step 3: add the antecedent (position 0) — either a single
+        // variable (n=1) or an OR with one child per supporting
+        // variable (n≥2). In permissive mode the OR sits directly
+        // under IMPLIES; the post-build `normalize()` runs AN-1 to
+        // insert the formula buffer when the original behavior was
+        // assistive.
+        if (supportingVars.length === 1) {
+            const sv = supportingVars[0];
+            const varExprId = gen();
+            pe.addExpression({
+                id: varExprId,
+                argumentId: argId,
+                argumentVersion: argVersion,
+                premiseId,
+                type: "variable",
+                variableId: sv.id,
+                parentId: impliesId,
+                position: 0,
+            });
+        }
+        else {
+            const orId = gen();
+            pe.addExpression({
+                id: orId,
+                argumentId: argId,
+                argumentVersion: argVersion,
+                premiseId,
+                type: "operator",
+                operator: "or",
+                parentId: impliesId,
+                position: 0,
+            });
+            for (let i = 0; i < supportingVars.length; i++) {
+                const sv = supportingVars[i];
+                const varExprId = gen();
+                pe.addExpression({
+                    id: varExprId,
+                    argumentId: argId,
+                    argumentVersion: argVersion,
+                    premiseId,
+                    type: "variable",
+                    variableId: sv.id,
+                    parentId: orId,
+                    position: i,
+                });
+            }
+        }
+        // Step 4: add the Q consequent (position 1 of IMPLIES).
+        const qExprId = gen();
+        pe.addExpression({
+            id: qExprId,
+            argumentId: argId,
+            argumentVersion: argVersion,
+            premiseId,
+            type: "variable",
+            variableId: qVariableId,
+            parentId: impliesId,
+            position: 1,
+        });
+        // Step 5: restore the original behavior and (if we switched)
+        // run the single explicit normalize() to apply AN-1 on the
+        // fully-built tree.
+        if (savedBehavior === "assistive") {
+            engine.setBehavior(savedBehavior);
+            engine.normalize();
+        }
+    }
+    catch (e) {
+        // Restore behavior on failure paths too so the engine is not
+        // left stuck in permissive mode after an unexpected mutation
+        // throw. The build is not transactional — callers expect the
+        // engine state to surface the partial build for diagnosis;
+        // only the behavior flag gets restored.
+        if (savedBehavior === "assistive") {
+            engine.setBehavior(savedBehavior);
+        }
+        throw e;
+    }
+    return {
+        kind: "populated",
+        state: pe.toPremiseData(),
+    };
+}
+/**
+ * Find the (sole) derivation premise in the engine whose
+ * `derivedClaimId` matches. Returns `undefined` if none exist. If
+ * multiple exist (an E-6 violation), returns the first — the caller's
+ * naked-Q check then determines whether the factory acts. (E-6 is
+ * resolved separately via `removeDuplicateDerivationPremises`.)
+ */
+function findDerivationPremiseForClaim(engine, derivedClaimId) {
+    for (const pe of engine.listPremises()) {
+        const data = pe.toPremiseData();
+        if (data.type !== "derivation")
+            continue;
+        if (data.derivedClaimId ===
+            derivedClaimId) {
+            return pe;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=populate-from.js.map

package/dist/lib/grammar/populate-from.js.map

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

package/dist/lib/grammar/repair.d.ts

@@ -0,0 +1,65 @@
+import type { ArgumentEngine } from "../core/argument-engine.js";
+import type { TCoreArgument, TCorePremise, TCorePropositionalExpression, TCorePropositionalVariable, TCoreClaim } from "../schemata/index.js";
+import type { TViolation } from "./types.js";
+/**
+ * Resolve E-3 (variable binding doesn't resolve) by deleting each
+ * offending variable. `engine.removeVariable()` cascades: it removes
+ * the variable record AND every variable-expression referencing it
+ * across all premises, collapsing operator parents as necessary.
+ *
+ * In `'assistive'` mode, the per-mutation AN post-hook fires after
+ * each removeVariable call. In `'permissive'`, no AN runs.
+ *
+ * @since 1.0.0
+ */
+export declare function removeUnresolvableVariables<TArg extends TCoreArgument = TCoreArgument, TPremise extends TCorePremise = TCorePremise, TExpr extends TCorePropositionalExpression = TCorePropositionalExpression, TVar extends TCorePropositionalVariable = TCorePropositionalVariable, TClaim extends TCoreClaim = TCoreClaim>(engine: ArgumentEngine<TArg, TPremise, TExpr, TVar, TClaim>): readonly TViolation[];
+/**
+ * Resolve E-1 (and/or with < 2 children) by cleaning up the orphan
+ * operators. Delegates to `engine.normalize()`'s AN-3 pass, which
+ * deletes empty operators and promotes single-child operators in a
+ * non-meaning-changing way. The primitive exists alongside normalize()
+ * so the UI can present a focused "Remove N orphan operators" action
+ * with a precise return value (which violations it resolved).
+ *
+ * `engine.normalize()` bypasses `behavior` — even in permissive mode
+ * the cleanup runs. This matches the UI flow: the user has already
+ * accepted the deletion when they clicked the repair button.
+ *
+ * @since 1.0.0
+ */
+export declare function removeOrphanOperators<TArg extends TCoreArgument = TCoreArgument, TPremise extends TCorePremise = TCorePremise, TExpr extends TCorePropositionalExpression = TCorePropositionalExpression, TVar extends TCorePropositionalVariable = TCorePropositionalVariable, TClaim extends TCoreClaim = TCoreClaim>(engine: ArgumentEngine<TArg, TPremise, TExpr, TVar, TClaim>): readonly TViolation[];
+/**
+ * Resolve E-6 (claim has > 1 derivation premise) by keeping one
+ * premise per `derivedClaimId` and deleting the others. Strategy
+ * controls which premise is kept:
+ *
+ *  - `'keep-first'` (default): keep the premise with the lexicographically
+ *    smallest id; delete the rest. Deterministic and snapshot-stable.
+ *  - `'keep-largest-antecedent'`: keep the premise whose antecedent
+ *    subtree has the most claim-bound variable expressions. Ties are
+ *    broken by lexicographic id. Useful when the user wants the more
+ *    informative derivation retained.
+ *
+ * `engine.removePremise()` cascades: it deletes the premise, its
+ * expressions, and any premise-bound variables that reference it.
+ *
+ * @since 1.0.0
+ */
+export declare function removeDuplicateDerivationPremises<TArg extends TCoreArgument = TCoreArgument, TPremise extends TCorePremise = TCorePremise, TExpr extends TCorePropositionalExpression = TCorePropositionalExpression, TVar extends TCorePropositionalVariable = TCorePropositionalVariable, TClaim extends TCoreClaim = TCoreClaim>(engine: ArgumentEngine<TArg, TPremise, TExpr, TVar, TClaim>, strategy?: "keep-first" | "keep-largest-antecedent"): readonly TViolation[];
+/**
+ * Resolve D-3 (mixed-grounding antecedent: axioms + citations in one
+ * derivation premise) by deleting every axiom-bound variable expression
+ * from the antecedent subtree, leaving citations behind. Mirrors the
+ * v1.0 migration repair (spec §9.2) for runtime use when an
+ * advanced-mode user reaches a mixed state in a permissive engine.
+ *
+ * In `'assistive'` mode, the per-mutation AN post-hook runs after each
+ * expression removal, which may collapse the resulting OR (AN-3) if
+ * fewer than two siblings remain after the deletes. In `'permissive'`
+ * the OR may end up with a single child (an E-1 / D-2 violation —
+ * follow up with `removeOrphanOperators()` if desired).
+ *
+ * @since 1.0.0
+ */
+export declare function dropAxiomsFromMixedAntecedent<TArg extends TCoreArgument = TCoreArgument, TPremise extends TCorePremise = TCorePremise, TExpr extends TCorePropositionalExpression = TCorePropositionalExpression, TVar extends TCorePropositionalVariable = TCorePropositionalVariable, TClaim extends TCoreClaim = TCoreClaim>(engine: ArgumentEngine<TArg, TPremise, TExpr, TVar, TClaim>): readonly TViolation[];
+//# sourceMappingURL=repair.d.ts.map

package/dist/lib/grammar/repair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair.d.ts","sourceRoot":"","sources":["../../../src/lib/grammar/repair.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,KAAK,EACR,aAAa,EACb,YAAY,EACZ,4BAA4B,EAC5B,0BAA0B,EAC1B,UAAU,EACb,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACvC,IAAI,SAAS,aAAa,GAAG,aAAa,EAC1C,QAAQ,SAAS,YAAY,GAAG,YAAY,EAC5C,KAAK,SAAS,4BAA4B,GAAG,4BAA4B,EACzE,IAAI,SAAS,0BAA0B,GAAG,0BAA0B,EACpE,MAAM,SAAS,UAAU,GAAG,UAAU,EAEtC,MAAM,EAAE,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,GAC5D,SAAS,UAAU,EAAE,CAavB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACjC,IAAI,SAAS,aAAa,GAAG,aAAa,EAC1C,QAAQ,SAAS,YAAY,GAAG,YAAY,EAC5C,KAAK,SAAS,4BAA4B,GAAG,4BAA4B,EACzE,IAAI,SAAS,0BAA0B,GAAG,0BAA0B,EACpE,MAAM,SAAS,UAAU,GAAG,UAAU,EAEtC,MAAM,EAAE,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,GAC5D,SAAS,UAAU,EAAE,CAOvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iCAAiC,CAC7C,IAAI,SAAS,aAAa,GAAG,aAAa,EAC1C,QAAQ,SAAS,YAAY,GAAG,YAAY,EAC5C,KAAK,SAAS,4BAA4B,GAAG,4BAA4B,EACzE,IAAI,SAAS,0BAA0B,GAAG,0BAA0B,EACpE,MAAM,SAAS,UAAU,GAAG,UAAU,EAEtC,MAAM,EAAE,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,EAC3D,QAAQ,GAAE,YAAY,GAAG,yBAAwC,GAClE,SAAS,UAAU,EAAE,CAkCvB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CACzC,IAAI,SAAS,aAAa,GAAG,aAAa,EAC1C,QAAQ,SAAS,YAAY,GAAG,YAAY,EAC5C,KAAK,SAAS,4BAA4B,GAAG,4BAA4B,EACzE,IAAI,SAAS,0BAA0B,GAAG,0BAA0B,EACpE,MAAM,SAAS,UAAU,GAAG,UAAU,EAEtC,MAAM,EAAE,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,GAC5D,SAAS,UAAU,EAAE,CA4DvB"}

package/dist/lib/grammar/repair.js

@@ -0,0 +1,251 @@
+// Targeted repair primitives per spec §7.
+//
+// Each primitive is a **user-initiated** destructive fix for a specific
+// Evaluable or Derivable violation that `normalize()` cannot resolve
+// (because resolution would change argument meaning — deleting a
+// variable, dropping a claim reference, removing a duplicate premise).
+//
+// All primitives:
+//  - Discover violations via `engine.validate(tier)` filtered by code.
+//  - Apply the repair via the engine's structural mutation primitives.
+//  - **Respect `engine.behavior`** — AN runs after each mutation in
+//    `'assistive'` mode (via the mutation's own post-hook), doesn't run
+//    in `'permissive'` mode.
+//  - Return the violations they resolved (for UX confirmation / undo
+//    messaging / "we made these N changes" feedback).
+//
+// Primitives never auto-run. The UI invokes them only after the user
+// has explicitly accepted the destructive fix.
+import { isClaimBound } from "../schemata/index.js";
+/**
+ * Resolve E-3 (variable binding doesn't resolve) by deleting each
+ * offending variable. `engine.removeVariable()` cascades: it removes
+ * the variable record AND every variable-expression referencing it
+ * across all premises, collapsing operator parents as necessary.
+ *
+ * In `'assistive'` mode, the per-mutation AN post-hook fires after
+ * each removeVariable call. In `'permissive'`, no AN runs.
+ *
+ * @since 1.0.0
+ */
+export function removeUnresolvableVariables(engine) {
+    const violations = engine
+        .validate("evaluable")
+        .filter((v) => v.code === "E-3");
+    const seen = new Set();
+    for (const v of violations) {
+        const variableId = v.variableId;
+        if (typeof variableId !== "string")
+            continue;
+        if (seen.has(variableId))
+            continue;
+        seen.add(variableId);
+        engine.removeVariable(variableId);
+    }
+    return violations;
+}
+/**
+ * Resolve E-1 (and/or with < 2 children) by cleaning up the orphan
+ * operators. Delegates to `engine.normalize()`'s AN-3 pass, which
+ * deletes empty operators and promotes single-child operators in a
+ * non-meaning-changing way. The primitive exists alongside normalize()
+ * so the UI can present a focused "Remove N orphan operators" action
+ * with a precise return value (which violations it resolved).
+ *
+ * `engine.normalize()` bypasses `behavior` — even in permissive mode
+ * the cleanup runs. This matches the UI flow: the user has already
+ * accepted the deletion when they clicked the repair button.
+ *
+ * @since 1.0.0
+ */
+export function removeOrphanOperators(engine) {
+    const violations = engine
+        .validate("evaluable")
+        .filter((v) => v.code === "E-1");
+    if (violations.length === 0)
+        return violations;
+    engine.normalize();
+    return violations;
+}
+/**
+ * Resolve E-6 (claim has > 1 derivation premise) by keeping one
+ * premise per `derivedClaimId` and deleting the others. Strategy
+ * controls which premise is kept:
+ *
+ *  - `'keep-first'` (default): keep the premise with the lexicographically
+ *    smallest id; delete the rest. Deterministic and snapshot-stable.
+ *  - `'keep-largest-antecedent'`: keep the premise whose antecedent
+ *    subtree has the most claim-bound variable expressions. Ties are
+ *    broken by lexicographic id. Useful when the user wants the more
+ *    informative derivation retained.
+ *
+ * `engine.removePremise()` cascades: it deletes the premise, its
+ * expressions, and any premise-bound variables that reference it.
+ *
+ * @since 1.0.0
+ */
+export function removeDuplicateDerivationPremises(engine, strategy = "keep-first") {
+    const violations = engine
+        .validate("evaluable")
+        .filter((v) => v.code === "E-6");
+    if (violations.length === 0)
+        return violations;
+    // E-6 reports every member of a >1-group; collect distinct premise
+    // ids per claimId.
+    const byClaim = new Map();
+    for (const v of violations) {
+        const claimId = v.claimId;
+        const premiseId = v.premiseId;
+        if (typeof claimId !== "string" || typeof premiseId !== "string") {
+            continue;
+        }
+        const set = byClaim.get(claimId) ?? new Set();
+        set.add(premiseId);
+        byClaim.set(claimId, set);
+    }
+    for (const [, premiseIdSet] of byClaim) {
+        const premiseIds = [...premiseIdSet];
+        let keep;
+        if (strategy === "keep-largest-antecedent") {
+            keep = pickLargestAntecedent(engine, premiseIds);
+        }
+        else {
+            keep = [...premiseIds].sort()[0];
+        }
+        for (const id of premiseIds) {
+            if (id === keep)
+                continue;
+            engine.removePremise(id);
+        }
+    }
+    return violations;
+}
+/**
+ * Resolve D-3 (mixed-grounding antecedent: axioms + citations in one
+ * derivation premise) by deleting every axiom-bound variable expression
+ * from the antecedent subtree, leaving citations behind. Mirrors the
+ * v1.0 migration repair (spec §9.2) for runtime use when an
+ * advanced-mode user reaches a mixed state in a permissive engine.
+ *
+ * In `'assistive'` mode, the per-mutation AN post-hook runs after each
+ * expression removal, which may collapse the resulting OR (AN-3) if
+ * fewer than two siblings remain after the deletes. In `'permissive'`
+ * the OR may end up with a single child (an E-1 / D-2 violation —
+ * follow up with `removeOrphanOperators()` if desired).
+ *
+ * @since 1.0.0
+ */
+export function dropAxiomsFromMixedAntecedent(engine) {
+    const violations = engine
+        .validate("derivable")
+        .filter((v) => v.code === "D-3");
+    if (violations.length === 0)
+        return violations;
+    // For each D-3 violation, walk the offending antecedent subtree
+    // and delete every variable expression whose backing claim is
+    // axiomatic. Claim type is resolved via the engine's claim library
+    // through `engine.getClaim(id, version)`.
+    for (const v of violations) {
+        const premiseId = v.premiseId;
+        const antecedentExprId = v.expressionId;
+        if (typeof premiseId !== "string" ||
+            typeof antecedentExprId !== "string") {
+            continue;
+        }
+        const pe = engine.listPremises().find((p) => p.getId() === premiseId);
+        if (pe === undefined)
+            continue;
+        const exprs = pe.getExpressions();
+        const childMap = new Map();
+        for (const e of exprs) {
+            if (e.parentId === null)
+                continue;
+            const list = childMap.get(e.parentId) ?? [];
+            list.push(e);
+            childMap.set(e.parentId, list);
+        }
+        // DFS the antecedent subtree; collect variable expressions whose
+        // backing claim resolves to type === 'axiomatic'.
+        const toRemove = [];
+        const stack = [antecedentExprId];
+        while (stack.length > 0) {
+            const cursor = stack.pop();
+            const cursorExpr = exprs.find((e) => e.id === cursor);
+            if (cursorExpr?.type === "variable") {
+                const variable = engine.getVariable(cursorExpr.variableId);
+                if (variable !== undefined && isClaimBound(variable)) {
+                    const claim = lookupClaim(engine, variable.claimId, variable.claimVersion);
+                    if (claim?.type === "axiomatic") {
+                        toRemove.push(cursorExpr.id);
+                    }
+                }
+            }
+            const kids = childMap.get(cursor) ?? [];
+            for (const k of kids)
+                stack.push(k.id);
+        }
+        // Delete the axiom-bound variable expressions. Use deleteSubtree
+        // = false because a variable expression is a leaf.
+        for (const exprId of toRemove) {
+            pe.removeExpression(exprId, false);
+        }
+    }
+    return violations;
+}
+/**
+ * Pick the premise (from `premiseIds`) whose antecedent subtree
+ * contains the most claim-bound variable expressions. Ties broken
+ * lexicographically by id for determinism.
+ */
+function pickLargestAntecedent(engine, premiseIds) {
+    let best;
+    let bestSize = -1;
+    const sortedIds = [...premiseIds].sort();
+    for (const id of sortedIds) {
+        const pe = engine.listPremises().find((p) => p.getId() === id);
+        if (pe === undefined)
+            continue;
+        const exprs = pe.getExpressions();
+        const root = exprs.find((e) => e.parentId === null);
+        let antecedentSize = 0;
+        if (root?.type === "operator" &&
+            (root.operator === "implies" || root.operator === "iff")) {
+            // Count variable expressions whose ancestor chain reaches the
+            // position-0 child of the implies/iff root.
+            const antecedent = exprs.find((e) => e.parentId === root.id && e.position === 0);
+            if (antecedent !== undefined) {
+                const stack = [antecedent.id];
+                while (stack.length > 0) {
+                    const cursor = stack.pop();
+                    const cursorExpr = exprs.find((e) => e.id === cursor);
+                    if (cursorExpr?.type === "variable") {
+                        antecedentSize++;
+                    }
+                    for (const c of exprs) {
+                        if (c.parentId === cursor)
+                            stack.push(c.id);
+                    }
+                }
+            }
+        }
+        if (antecedentSize > bestSize) {
+            bestSize = antecedentSize;
+            best = id;
+        }
+    }
+    return best ?? sortedIds[0];
+}
+/**
+ * Resolve a claim record by `(id, version)` from the engine's claim
+ * library. We piggyback on `engine.validate('evaluable')`'s context
+ * construction — which already does this lookup — by walking variables
+ * to find one bound to `claimId/claimVersion` and reaching for the
+ * resolved claim via the validator-context shape.
+ *
+ * Simpler approach: a future `engine.getClaim(id, version)` accessor
+ * would clean this up. For v1.0 we route through the public surface.
+ */
+function lookupClaim(engine, claimId, claimVersion) {
+    return engine.getClaim(claimId, claimVersion);
+}
+//# sourceMappingURL=repair.js.map

package/dist/lib/grammar/repair.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair.js","sourceRoot":"","sources":["../../../src/lib/grammar/repair.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,EAAE;AACF,wEAAwE;AACxE,qEAAqE;AACrE,iEAAiE;AACjE,uEAAuE;AACvE,EAAE;AACF,kBAAkB;AAClB,uEAAuE;AACvE,uEAAuE;AACvE,oEAAoE;AACpE,wEAAwE;AACxE,6BAA6B;AAC7B,qEAAqE;AACrE,sDAAsD;AACtD,EAAE;AACF,qEAAqE;AACrE,+CAA+C;AAU/C,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAGnD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2BAA2B,CAOvC,MAA2D;IAE3D,MAAM,UAAU,GAAG,MAAM;SACpB,QAAQ,CAAC,WAAW,CAAC;SACrB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,CAAA;IACpC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAA;IAC9B,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QACzB,MAAM,UAAU,GAAG,CAAC,CAAC,UAAU,CAAA;QAC/B,IAAI,OAAO,UAAU,KAAK,QAAQ;YAAE,SAAQ;QAC5C,IAAI,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC;YAAE,SAAQ;QAClC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;QACpB,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAA;IACrC,CAAC;IACD,OAAO,UAAU,CAAA;AACrB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,qBAAqB,CAOjC,MAA2D;IAE3D,MAAM,UAAU,GAAG,MAAM;SACpB,QAAQ,CAAC,WAAW,CAAC;SACrB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,CAAA;IACpC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,UAAU,CAAA;IAC9C,MAAM,CAAC,SAAS,EAAE,CAAA;IAClB,OAAO,UAAU,CAAA;AACrB,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,iCAAiC,CAO7C,MAA2D,EAC3D,WAAqD,YAAY;IAEjE,MAAM,UAAU,GAAG,MAAM;SACpB,QAAQ,CAAC,WAAW,CAAC;SACrB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,CAAA;IACpC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,UAAU,CAAA;IAE9C,mEAAmE;IACnE,mBAAmB;IACnB,MAAM,OAAO,GAAG,IAAI,GAAG,EAAuB,CAAA;IAC9C,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QACzB,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,CAAA;QACzB,MAAM,SAAS,GAAG,CAAC,CAAC,SAAS,CAAA;QAC7B,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;YAC/D,SAAQ;QACZ,CAAC;QACD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,GAAG,EAAU,CAAA;QACrD,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;QAClB,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,CAAA;IAC7B,CAAC;IAED,KAAK,MAAM,CAAC,EAAE,YAAY,CAAC,IAAI,OAAO,EAAE,CAAC;QACrC,MAAM,UAAU,GAAG,CAAC,GAAG,YAAY,CAAC,CAAA;QACpC,IAAI,IAAY,CAAA;QAChB,IAAI,QAAQ,KAAK,yBAAyB,EAAE,CAAC;YACzC,IAAI,GAAG,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;QACpD,CAAC;aAAM,CAAC;YACJ,IAAI,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;QACpC,CAAC;QACD,KAAK,MAAM,EAAE,IAAI,UAAU,EAAE,CAAC;YAC1B,IAAI,EAAE,KAAK,IAAI;gBAAE,SAAQ;YACzB,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,CAAA;QAC5B,CAAC;IACL,CAAC;IACD,OAAO,UAAU,CAAA;AACrB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,6BAA6B,CAOzC,MAA2D;IAE3D,MAAM,UAAU,GAAG,MAAM;SACpB,QAAQ,CAAC,WAAW,CAAC;SACrB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAC,CAAA;IACpC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,UAAU,CAAA;IAE9C,gEAAgE;IAChE,8DAA8D;IAC9D,mEAAmE;IACnE,0CAA0C;IAC1C,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QACzB,MAAM,SAAS,GAAG,CAAC,CAAC,SAAS,CAAA;QAC7B,MAAM,gBAAgB,GAAG,CAAC,CAAC,YAAY,CAAA;QACvC,IACI,OAAO,SAAS,KAAK,QAAQ;YAC7B,OAAO,gBAAgB,KAAK,QAAQ,EACtC,CAAC;YACC,SAAQ;QACZ,CAAC;QACD,MAAM,EAAE,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,SAAS,CAAC,CAAA;QACrE,IAAI,EAAE,KAAK,SAAS;YAAE,SAAQ;QAC9B,MAAM,KAAK,GAAG,EAAE,CAAC,cAAc,EAAE,CAAA;QACjC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA0C,CAAA;QAClE,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACpB,IAAI,CAAC,CAAC,QAAQ,KAAK,IAAI;gBAAE,SAAQ;YACjC,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAA;YAC3C,IAAI,CAAC,IAAI,CAAC,CAA4C,CAAC,CAAA;YACvD,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;QAClC,CAAC;QACD,iEAAiE;QACjE,kDAAkD;QAClD,MAAM,QAAQ,GAAa,EAAE,CAAA;QAC7B,MAAM,KAAK,GAAa,CAAC,gBAAgB,CAAC,CAAA;QAC1C,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,EAAG,CAAA;YAC3B,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,CAAA;YACrD,IAAI,UAAU,EAAE,IAAI,KAAK,UAAU,EAAE,CAAC;gBAClC,MAAM,QAAQ,GAAG,MAAM,CAAC,WAAW,CAAC,UAAU,CAAC,UAAU,CAAC,CAAA;gBAC1D,IAAI,QAAQ,KAAK,SAAS,IAAI,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACnD,MAAM,KAAK,GAAG,WAAW,CACrB,MAAM,EACN,QAAQ,CAAC,OAAO,EAChB,QAAQ,CAAC,YAAY,CACxB,CAAA;oBACD,IAAI,KAAK,EAAE,IAAI,KAAK,WAAW,EAAE,CAAC;wBAC9B,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;oBAChC,CAAC;gBACL,CAAC;YACL,CAAC;YACD,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,CAAA;YACvC,KAAK,MAAM,CAAC,IAAI,IAAI;gBAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;QAC1C,CAAC;QACD,iEAAiE;QACjE,mDAAmD;QACnD,KAAK,MAAM,MAAM,IAAI,QAAQ,EAAE,CAAC;YAC5B,EAAE,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QACtC,CAAC;IACL,CAAC;IAED,OAAO,UAAU,CAAA;AACrB,CAAC;AAED;;;;GAIG;AACH,SAAS,qBAAqB,CAO1B,MAA2D,EAC3D,UAA6B;IAE7B,IAAI,IAAwB,CAAA;IAC5B,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAA;IACjB,MAAM,SAAS,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,IAAI,EAAE,CAAA;IACxC,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;QACzB,MAAM,EAAE,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAA;QAC9D,IAAI,EAAE,KAAK,SAAS;YAAE,SAAQ;QAC9B,MAAM,KAAK,GAAG,EAAE,CAAC,cAAc,EAAE,CAAA;QACjC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAA;QACnD,IAAI,cAAc,GAAG,CAAC,CAAA;QACtB,IACI,IAAI,EAAE,IAAI,KAAK,UAAU;YACzB,CAAC,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,CAAC,EAC1D,CAAC;YACC,8DAA8D;YAC9D,4CAA4C;YAC5C,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CACzB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CACpD,CAAA;YACD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;gBAC3B,MAAM,KAAK,GAAa,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;gBACvC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACtB,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,EAAG,CAAA;oBAC3B,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,CAAA;oBACrD,IAAI,UAAU,EAAE,IAAI,KAAK,UAAU,EAAE,CAAC;wBAClC,cAAc,EAAE,CAAA;oBACpB,CAAC;oBACD,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;wBACpB,IAAI,CAAC,CAAC,QAAQ,KAAK,MAAM;4BAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;oBAC/C,CAAC;gBACL,CAAC;YACL,CAAC;QACL,CAAC;QACD,IAAI,cAAc,GAAG,QAAQ,EAAE,CAAC;YAC5B,QAAQ,GAAG,cAAc,CAAA;YACzB,IAAI,GAAG,EAAE,CAAA;QACb,CAAC;IACL,CAAC;IACD,OAAO,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC,CAAA;AAC/B,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,WAAW,CAOhB,MAA2D,EAC3D,OAAe,EACf,YAAoB;IAEpB,OAAO,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAA2B,CAAA;AAC3E,CAAC"}

package/dist/lib/grammar/types.d.ts

@@ -0,0 +1,17 @@
+import Type, { type Static } from "typebox";
+export declare const GrammarTierSchema: Type.TUnion<[Type.TLiteral<"structural">, Type.TLiteral<"evaluable">, Type.TLiteral<"derivable">, Type.TLiteral<"presentable">]>;
+export type TGrammarTier = Static<typeof GrammarTierSchema>;
+export declare const GrammarRuleCodeSchema: Type.TUnion<[Type.TLiteral<"S-1">, Type.TLiteral<"S-2">, Type.TLiteral<"S-3">, Type.TLiteral<"S-4">, Type.TLiteral<"S-5">, Type.TLiteral<"S-6">, Type.TLiteral<"S-7">, Type.TLiteral<"S-8">, Type.TLiteral<"S-9">, Type.TLiteral<"S-10">, Type.TLiteral<"S-11">, Type.TLiteral<"S-12">, Type.TLiteral<"S-13">, Type.TLiteral<"S-14">, Type.TLiteral<"E-1">, Type.TLiteral<"E-3">, Type.TLiteral<"E-4">, Type.TLiteral<"E-5">, Type.TLiteral<"E-6">, Type.TLiteral<"E-7">, Type.TLiteral<"D-1">, Type.TLiteral<"D-2">, Type.TLiteral<"D-3">, Type.TLiteral<"D-4">, Type.TLiteral<"D-5">, Type.TLiteral<"D-6">, Type.TLiteral<"P-1">, Type.TLiteral<"P-2">, Type.TLiteral<"P-3">, Type.TLiteral<"P-4">, Type.TLiteral<"P-5">]>;
+export type TGrammarRuleCode = Static<typeof GrammarRuleCodeSchema>;
+export declare const ViolationSchema: Type.TObject<{
+    tier: Type.TUnion<[Type.TLiteral<"structural">, Type.TLiteral<"evaluable">, Type.TLiteral<"derivable">, Type.TLiteral<"presentable">]>;
+    code: Type.TUnion<[Type.TLiteral<"S-1">, Type.TLiteral<"S-2">, Type.TLiteral<"S-3">, Type.TLiteral<"S-4">, Type.TLiteral<"S-5">, Type.TLiteral<"S-6">, Type.TLiteral<"S-7">, Type.TLiteral<"S-8">, Type.TLiteral<"S-9">, Type.TLiteral<"S-10">, Type.TLiteral<"S-11">, Type.TLiteral<"S-12">, Type.TLiteral<"S-13">, Type.TLiteral<"S-14">, Type.TLiteral<"E-1">, Type.TLiteral<"E-3">, Type.TLiteral<"E-4">, Type.TLiteral<"E-5">, Type.TLiteral<"E-6">, Type.TLiteral<"E-7">, Type.TLiteral<"D-1">, Type.TLiteral<"D-2">, Type.TLiteral<"D-3">, Type.TLiteral<"D-4">, Type.TLiteral<"D-5">, Type.TLiteral<"D-6">, Type.TLiteral<"P-1">, Type.TLiteral<"P-2">, Type.TLiteral<"P-3">, Type.TLiteral<"P-4">, Type.TLiteral<"P-5">]>;
+    message: Type.TString;
+    argumentId: Type.TOptional<Type.TString>;
+    premiseId: Type.TOptional<Type.TString>;
+    expressionId: Type.TOptional<Type.TString>;
+    variableId: Type.TOptional<Type.TString>;
+    claimId: Type.TOptional<Type.TString>;
+}>;
+export type TViolation = Static<typeof ViolationSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/grammar/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/grammar/types.ts"],"names":[],"mappings":"AAmBA,OAAO,IAAI,EAAE,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAI3C,eAAO,MAAM,iBAAiB,kIAK5B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAI3D,eAAO,MAAM,qBAAqB,8rBAoChC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAUnE,eAAO,MAAM,eAAe;;;;;;;;;EAY3B,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,eAAe,CAAC,CAAA"}