nimai-core 0.4.8 → 0.5.0

package/data/FORGE-quickref.md

@@ -0,0 +1,326 @@
+# FORGE Quick Reference
+> **You are here:** This is the operational tool — the doc an agent uses during active work.
+>
+> **The other docs in this system:**
+> - **Canonical Framework** (`FORGE-canonical.md`) — deep explanation of every concept. Go there to understand *why* something works, not just *what* to do.
+> - **Spec Template** (`FORGE-spec-template.md`) — fill-in-the-blank form for a concrete project. Go there when you have a direction and need to turn it into an agent-ready brief.
+
+---
+
+## Agent Routing: What To Do Based On The Request
+
+*Read the request and match it to a route before doing anything else.*
+
+| If the request is… | Route |
+|---|---|
+| A new idea or creative problem — no direction yet | Run **Divergence → Convergence Loop** below. Stay in this doc. |
+| A loose or vague request that needs structuring | Run **Self-Spec Agent** prompt (see below) to generate a draft spec. |
+| A specific project ready to execute | Go to **Spec Template** → fill it out → deploy. |
+| How to approach or frame something | Use **4 Layers + 5 Primitives** below. Deeper detail in Canonical doc. |
+| Reviewing, validating, or debugging existing work | Run **Failure Mode Taxonomy** red-team below. |
+| Something feels wrong mid-project | Check **Failure Mode Taxonomy** first, then check Intent Layer for drift. |
+| A concept here that needs deeper explanation | Go to **Canonical Framework** for the full treatment. |
+| Building a multi-agent or long-running system | Go to **Canonical Framework** → Execution Architecture + Extended Patterns. |
+
+**Default rule:** Start here. Go to Canonical to understand. Go to Spec Template to execute.
+
+---
+
+## The Deeper Thesis
+Agents fail not from lack of intelligence but from **underspecified control surfaces**. The four control surfaces are specification, intent, context, and prompt. Engineer all four.
+
+---
+
+## The 4 Engineering Disciplines / Control Surfaces
+
+| Discipline | Control Surface | Skip It And… |
+|---|---|---|
+| **Prompt Craft** | Sub-task trigger | Agent doesn't know what to do right now |
+| **Context Engineering** | Information environment | Agent works from noise or stale data |
+| **Intent Engineering** | Values, trade-offs, deployment purpose | Agent resolves ambiguity the wrong way |
+| **Specification Engineering** | Complete blueprint for "done" | Agent can't define done and never stops |
+
+---
+
+## The 4 Layers (in order of leverage)
+
+| Layer | Role | Anti-Pattern |
+|---|---|---|
+| **1. Specification** | Defines exact "done" state + scope | Vague goals ("improve this") |
+| **2. Intent** | Agent's deployment purpose + trade-off hierarchy | Agent doesn't know its own role |
+| **3. Context** | Curated information environment | Dumping everything you have |
+| **4. Prompt** | Fires sub-task + assigns cognitive mode | Over-engineering this layer |
+
+---
+
+## The 5 Primitives (every sub-task must pass all 5)
+
+1. **Self-Contained** — Zero questions needed to start
+2. **Constrained** — Must / Must-Not / Prefer / Escalate defined
+3. **Modular** — Under 2 hours; independently verifiable
+4. **Acceptance Criteria** — Binary, measurable (not "looks good")
+5. **Evaluation** — Built-in check before reporting complete
+
+---
+
+## Pre-Execution Decisions (set BEFORE decomposition)
+
+**Risk Tier:**
+| Tier | Validation |
+|---|---|
+| Low | Self-check only |
+| Medium | Validator pass |
+| High | Validator + Adversarial Reflection + Human gate |
+
+**Resource Governance:** Model tier · Max runtime · Cost budget · Retry limit · Cost escalation trigger
+
+---
+
+## Cognitive Modes (reasoning postures, not personas)
+
+| Mode | Use When |
+|---|---|
+| **Deterministic** | Implementation; answer is knowable |
+| **Exploratory** | Research, brainstorming, hypothesis generation |
+| **Adversarial** | Security, risk, stress-testing |
+| **Synthesis** | Integrating multiple outputs |
+| **Audit** | Validation only — do not produce |
+
+**Over-specification warning:** Constrain evaluation, not divergence. In Exploratory phases, tight constraints on generation defeat the purpose. Reserve hard constraints for Adversarial and Deterministic phases.
+
+**Mode × Risk compatibility:** Exploratory mode is a pre-commitment mode. High risk tasks should be in Deterministic or Audit by final delivery. Exploratory + High risk as a final-delivery combination is a design error.
+
+---
+
+## Divergence → Convergence Loop (brainstorming)
+
+```
+Exploratory  →  Synthesis  →  Adversarial  →  Deterministic
+  DIVERGE        CLUSTER      STRESS-TEST      FORMALIZE
+```
+Generate wide → cluster patterns → attack top candidates → execute selected direction.
+
+---
+
+## Failure Mode Taxonomy (red-team before deployment)
+
+| Failure | Cause | Fix |
+|---|---|---|
+| Scope Creep | Ambiguous boundaries | Explicit Must-Not list |
+| Hallucinated Completion | Subjective criteria | Binary acceptance criteria |
+| Intent Drift | Unclear trade-offs or role | Ranked priorities + deployment purpose |
+| Context Collapse | Too much noise | Aggressive curation; MCP for live sources |
+| Runaway Cost | No resource ceiling | Hard caps before decomposition |
+| Overconfident Output | No uncertainty surfacing | Uncertainty reporting for high-stakes tasks |
+
+*If a failure doesn't fit these categories, extend the taxonomy — log it, identify root cause, add prevention.*
+
+---
+
+## Intent = Deployment Purpose + Trade-offs
+Every agent must know: **what it is · what it isn't · who consumes its output · what to optimize for when uncertain**
+
+## Adversarial Reflection (Medium/High risk)
+Produce → steelman critique → evaluate → revise → re-validate
+
+## Uncertainty Reporting (non-deterministic domains)
+Confidence % · uncertainty drivers · what would change the answer · alternative interpretations
+
+## Escalation Contract
+WHEN to stop · WHAT to report (include confidence) · WHO decides (named + SLA) · WHAT if no response
+
+## Context Hygiene
+2k high-signal tokens > 20k low-signal tokens · MCP for live sources · specify when to re-fetch
+
+---
+
+## When To Use This Framework
+
+The overhead should be proportional to the cost of failure. Use this as your guide:
+
+| Situation | What to use |
+|---|---|
+| Task is reversible, low-stakes, under 1 hour | Routing table above + nothing else. Just start. |
+| Task is consequential or takes more than 1 hour | Quickref checklist minimum. Self-Spec agent if unsure. |
+| Task is high-risk, irreversible, or affects others | Full Spec Template + Adversarial Reflection + Validator |
+| You're not sure | Ask: "What's the cost if this goes wrong?" Scale accordingly. |
+
+**The philosophy:** This framework exists to absorb any project — coding, science, writing, business, anything — and give it the structure needed to succeed without fail. Use as much or as little as the project demands. The principles apply universally; the overhead scales with stakes.
+
+---
+
+## Solo Operator Mode
+
+If you are working alone without a team, validators, or named escalation contacts, adapt as follows:
+
+**Escalation contract:** You are the reviewer. Set a time delay instead of an SLA — *"I will not proceed on this decision for 24 hours."* Distance and time create the same circuit-break that a second person would.
+
+**Validation:** For Medium risk, run the Adversarial Reflection yourself or have a second agent session do it cold — paste the output into a fresh context with no prior history and ask it to find flaws.
+
+**High risk solo:** Add a mandatory pause before any irreversible action. Write out the decision, the alternatives you considered, and your confidence level before executing. This is your human gate.
+
+**The Self-Spec + Reviewer pipeline replaces team infrastructure** — see below.
+
+---
+
+## Self-Spec Agent + Reviewer Pipeline
+
+This is the solo operator's complete workflow. Two prompts replace an entire team process.
+
+---
+
+### Prompt 1 — Self-Spec Agent
+*Use when you have a loose idea or vague request and need it turned into a complete spec.*
+
+Paste this prompt to any capable model along with your loose request:
+
+```
+You are a Specification Engineering agent operating under the FORGE.
+
+Your job is to take the loose request below and generate a complete draft spec
+using the framework's structure. Do not execute the request — only spec it.
+
+For each section, fill in what you can infer and mark anything uncertain
+with [NEEDS HUMAN INPUT: reason].
+
+Generate:
+1. Final deliverable (precise, format, measurable quality bar)
+2. Scope boundaries (in / out)
+3. Agent deployment purpose (what it is, is not, who consumes output)
+4. Trade-off hierarchy (ranked: accuracy / speed / cost / safety / other)
+5. Constraint architecture (Must / Must-Not / Prefer / Escalate)
+6. Task decomposition (sub-tasks under 2 hours, with acceptance criteria)
+7. Risk tier (Low / Medium / High with reasoning)
+8. Cognitive mode per sub-task
+9. Context needed (what the executing agent requires)
+10. Architecture Lock details for medium/high coding specs (Persistence layer, File/object storage, External model/service + env var, API trigger flow, Entity status state machine, Auth implementation)
+11. Proposed validator prompt (what a reviewer should check)
+
+Loose request: [PASTE YOUR REQUEST HERE]
+```
+
+Review the output. Resolve all [NEEDS HUMAN INPUT] flags. Adjust anything that
+doesn't match your intent. Approved spec = your deployment brief.
+
+---
+
+### Prompt 1.5 — Spec-Quality Reviewer
+*Run this on a draft spec before approving it. The reviewing LLM checks whether the spec is agent-ready.*
+
+```
+You are the independent reviewer for this draft spec. Evaluate it now.
+You are a Specification Quality Reviewer operating under the FORGE framework.
+
+Your job is to evaluate the draft spec below for spec quality only — not implementation correctness.
+Do NOT assess any code, code diffs, or implementation output.
+
+Evaluate each dimension. Cite evidence for every verdict — a verdict without citation is treated as NO_GO.
+Classify each issue as HARD_FAIL, SOFT_FAIL, or NOTE. passed: true requires zero HARD_FAILs.
+
+1. Binary acceptance criteria — are all sub-task ACs measurable and unambiguous? Pre-checked [x] ACs are always invalid.
+2. Scope coherence — are in-scope/out-of-scope boundaries clear and non-contradictory? Terminology mismatches between conceptual and persisted representations are a HARD_FAIL.
+3. Constraint sufficiency — do Must/Must-Not/Prefer/Escalate constraints cover the key risks?
+4. Decomposition realism — can each sub-task be done within 2 hours? Sub-task dependencies must be explicit.
+5. Start-without-clarification viability — can an agent begin immediately with the context provided?
+6. Internal consistency — are terms, names, and concepts used consistently throughout?
+7. Mechanism lock — does every core flow commit to exactly ONE implementation path? Any "e.g./or/could/might/such as" in Deliverable, Scope, Constraints, or Tasks is a HARD_FAIL.
+8. Convergence declaration — does the spec include a Spec Convergence section with open_questions: 0 and ambiguities_remaining: 0? Absent, non-zero, or ready_for_build: no is a HARD_FAIL.
+9. Adversarial gap scan — does the spec include a substantively filled Edge Cases and Failure Modes section? Steelman as a builder following it exactly: what failure modes are unaddressed? Absent or placeholder-only is a HARD_FAIL for medium/high risk specs.
+10. Architecture completeness — for medium/high coding specs, does the spec include `## 1.6 Architecture Lock` with resolved fields for Persistence layer, File/object storage, External model/service + env var, API trigger flow, Entity status state machine, and Auth implementation? Missing, blank, `___`, or `TBD` is a HARD_FAIL.
+
+Always end your response with:
+## Verdict
+```json
+{"passed": <true|false>, "schema_version": "2", "issues": [{"dimension": "<name>", "severity": "<HARD_FAIL|SOFT_FAIL|NOTE>", "detail": "<cited evidence>"}]}
+```
+
+Draft spec: [PASTE DRAFT SPEC HERE]
+```
+
+The host agent parses the `## Verdict` JSON block to drive the review loop:
+- `passed: true` → proceed to implementation
+- `passed: false` → refine the spec using the `issues` list, then re-review
+- Block absent or malformed → escalate to the human
+
+Use `nimai_spec_review` to generate this prompt automatically from a spec file.
+
+When Prompt 1.5 fails, the reviewer should append a `## Builder Brief` section after the verdict with one actionable fix per issue (section to edit + concrete fix direction).
+
+---
+
+### Prompt 2 — Reviewer / Validator Prompt Generator
+*Run this after Self-Spec is approved. Paste along with the approved spec.*
+
+```
+You are a Specification Engineering agent.
+
+Given the approved spec below, generate a Reviewer Prompt — precise instructions
+for a validator agent or solo reviewer to check the executing agent's output.
+
+The Reviewer Prompt must:
+- State exactly what is being checked and why
+- List binary pass/fail criteria from the spec's acceptance criteria
+- Include Adversarial Reflection sequence if risk tier is Medium or High
+- Include uncertainty reporting requirements if domain is non-deterministic
+- Specify what PASS looks like and what FAIL triggers (revise / escalate / abort)
+- Be usable by a solo operator with no additional context
+
+Approved spec: [PASTE APPROVED SPEC HERE]
+```
+
+---
+
+### The Complete Solo Pipeline
+
+```
+Loose request
+    ↓
+Self-Spec Agent (Prompt 1) → draft spec
+    ↓
+Spec-Quality Reviewer (Prompt 1.5) → passed? → NO → refine spec → loop
+    ↓ YES
+Human reviews + resolves [NEEDS HUMAN INPUT] flags
+    ↓
+Approved spec → Reviewer Prompt Generator (Prompt 2) → validator prompt
+    ↓
+Deploy executing agent with approved spec
+    ↓
+Paste output + validator prompt into fresh agent session
+    ↓
+PASS → done  |  FAIL → revise or escalate
+```
+
+---
+
+## Pre-Deployment Checklist
+
+**Specification**
+- [ ] Deliverable precise; scope boundaries explicit
+- [ ] Sub-tasks satisfy all 5 Primitives
+- [ ] For medium/high coding specs, `## 1.6 Architecture Lock` is present and fully resolved (no blank/`___`/`TBD` fields)
+
+**Intent**
+- [ ] Each agent has explicit deployment purpose
+- [ ] Trade-off hierarchy ranked; escalation contract complete
+
+**Context**
+- [ ] Context curated; MCP for live sources; freshness strategy set
+
+**Execution** *(set before decomposition)*
+- [ ] Risk tier assigned
+- [ ] Resource Governance parameters set
+- [ ] Cognitive mode per sub-task assigned
+- [ ] Validation routes by risk tier
+- [ ] Adversarial Reflection for medium/high risk
+- [ ] Uncertainty reporting for non-deterministic domains
+
+**Meta**
+- [ ] Spec red-teamed against Failure Mode Taxonomy
+- [ ] Planner execution plan will be saved as artifact
+- [ ] Living Specification log set up (multi-session)
+- [ ] Spec Convergence section filled — `open_questions: 0`, `ambiguities_remaining: 0`, `ready_for_build: yes`
+
+---
+
+*FORGE v1.0 — Framework for Orchestrating Reliable Generative Execution*
+*System docs: Quick Reference (this doc) · Canonical Framework · Spec Template*

package/data/nimai-spec-full.md

@@ -0,0 +1,63 @@
+# Spec: [title]
+
+## Deliverable
+*What exists when this is done. Name the artifact, not the activity.*
+
+- Artifact:
+- Format:
+- Quality bar (measurable — a number, a passing command, a checkable property):
+
+## Scope
+**In scope:**
+-
+
+**Out of scope (will not be built — be explicit, this is what prevents drift):**
+-
+
+## Task Decomposition
+*Each sub-task completable in under 2 hours, with its own binary acceptance criteria. State dependencies between sub-tasks explicitly.*
+
+| # | Sub-task | Depends on | Acceptance criteria | How it is checked |
+|---|---|---|---|---|
+| 1 | | — | | |
+
+## Mechanism Decisions
+*One block per core choice. A builder must never have to pick an approach mid-build.*
+
+**Decision: [short name]**
+- Chosen: [exactly one approach]
+- Rejected: [the alternatives considered]
+- Why: [one sentence]
+
+## Architecture Lock
+*Resolve every line. "TBD" and blanks mean the spec is not ready. Write "none" where a field genuinely does not apply, with a reason.*
+
+- Persistence layer:
+- File/object storage:
+- External services + env vars:
+- API/trigger flow:
+- Entity states and transitions:
+- Auth:
+
+## Change Surface
+*Every existing file this work touches, classified. The builder may not touch anything outside this table.*
+*Greenfield project? Replace the table with the single line: "Greenfield — no existing code to change."*
+
+| Path | Verb (DELETE / REWRITE / EDIT / KEEP) | Why |
+|---|---|---|
+| | | |
+
+## Edge Cases and Failure Modes
+*What will the builder hit mid-execution that the sections above do not answer? An empty list here is a red flag, not a green one.*
+
+-
+-
+
+## Spec Convergence
+*Non-zero counts mean this spec is not ready. Fix the spec, not the numbers.*
+
+open_questions: 0
+ambiguities_remaining: 0
+ready_for_build: yes
+
+<!-- nimai-spec tier=full -->

package/data/nimai-spec-lite.md

@@ -0,0 +1,39 @@
+# Spec: [title]
+
+## Deliverable
+*What exists when this is done. Name the artifact, not the activity.*
+
+- Artifact:
+- Format:
+- Quality bar (measurable — a number, a passing command, a checkable property):
+
+## Scope
+**In scope:**
+-
+
+**Out of scope (will not be built — be explicit, this is what prevents drift):**
+-
+
+## Acceptance Criteria
+*Binary and checkable. Leave every box unchecked — they are checked by the reviewer, not the author.*
+
+Done when ALL of these are true:
+- [ ]
+- [ ]
+
+## Mechanism Decisions
+*One block per core choice. A builder must never have to pick an approach mid-build.*
+
+**Decision: [short name]**
+- Chosen: [exactly one approach]
+- Rejected: [the alternatives considered]
+- Why: [one sentence]
+
+## Spec Convergence
+*Non-zero counts mean this spec is not ready. Fix the spec, not the numbers.*
+
+open_questions: 0
+ambiguities_remaining: 0
+ready_for_build: yes
+
+<!-- nimai-spec tier=lite -->

package/dist/forge-root.d.ts

@@ -0,0 +1,2 @@
+export declare const FORGE_ROOT: string;
+//# sourceMappingURL=forge-root.d.ts.map

package/dist/forge-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-root.d.ts","sourceRoot":"","sources":["../src/forge-root.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,UAAU,QAAkB,CAAC"}

package/dist/forge-root.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORGE_ROOT = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Locate the FORGE docs root by walking up from __dirname until we find
+ * FORGE-quickref.md. Works regardless of where the package is installed.
+ */
+function findForgeRoot() {
+    // 1. Check bundled data/ directory (works when installed via npm)
+    const bundled = path.join(__dirname, '..', 'data');
+    if (fs.existsSync(path.join(bundled, 'FORGE-quickref.md')))
+        return bundled;
+    // 2. Walk up from __dirname (works in monorepo dev)
+    let dir = __dirname;
+    for (let i = 0; i < 10; i++) {
+        if (fs.existsSync(path.join(dir, 'FORGE-quickref.md')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error('Cannot locate FORGE-quickref.md. Ensure the FORGE docs are present at the repo root.');
+}
+exports.FORGE_ROOT = findForgeRoot();
+//# sourceMappingURL=forge-root.js.map

package/dist/forge-root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-root.js","sourceRoot":"","sources":["../src/forge-root.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAyB;AACzB,2CAA6B;AAE7B;;;GAGG;AACH,SAAS,aAAa;IACpB,kEAAkE;IAClE,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACnD,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC;QAAE,OAAO,OAAO,CAAC;IAE3E,oDAAoD;IACpD,IAAI,GAAG,GAAG,SAAS,CAAC;IACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5B,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,mBAAmB,CAAC,CAAC;YAAE,OAAO,GAAG,CAAC;QACnE,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,MAAM,KAAK,GAAG;YAAE,MAAM;QAC1B,GAAG,GAAG,MAAM,CAAC;IACf,CAAC;IACD,MAAM,IAAI,KAAK,CACb,sFAAsF,CACvF,CAAC;AACJ,CAAC;AAEY,QAAA,UAAU,GAAG,aAAa,EAAE,CAAC"}

package/dist/index.d.ts

@@ -1,9 +1,8 @@
 export * from './types';
 export * from './template';
 export * from './lint';
-export * from './context';
 export * from './prompts';
-export * from './clarification';
 export * from './discovery';
 export * from './verdict';
+export * from './forge-root';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -17,9 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./template"), exports);
 __exportStar(require("./lint"), exports);
-__exportStar(require("./context"), exports);
 __exportStar(require("./prompts"), exports);
-__exportStar(require("./clarification"), exports);
 __exportStar(require("./discovery"), exports);
 __exportStar(require("./verdict"), exports);
+__exportStar(require("./forge-root"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,6CAA2B;AAC3B,yCAAuB;AACvB,4CAA0B;AAC1B,4CAA0B;AAC1B,kDAAgC;AAChC,8CAA4B;AAC5B,4CAA0B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,6CAA2B;AAC3B,yCAAuB;AACvB,4CAA0B;AAC1B,8CAA4B;AAC5B,4CAA0B;AAC1B,+CAA6B"}

package/dist/lint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../src/lint.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAiB,MAAM,SAAS,CAAC;AAsGnD,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAQtD;AAsBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAmFxD"}
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../src/lint.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAiB,MAAM,SAAS,CAAC;AA6GnD,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAQtD;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAkDxD"}