nimai-core 0.4.8 → 0.5.0

package/dist/prompts.js

@@ -1,54 +1,98 @@
 "use strict";
 /**
- * FORGE prompt builders — pure string functions, no IO, no LLM calls.
- * These live in @nimai/core so any package can import them without
- * depending on @nimai/mcp internals.
+ * Nimai prompt builders — pure string functions, no IO, no LLM calls.
+ * These live in nimai-core so any package can import them without
+ * depending on nimai-mcp internals.
+ *
+ * Template texts are passed in by callers (MCP server, CLI spec command)
+ * which load them via template.ts. prompts.ts stays pure (no fs/IO).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildPrompt1 = buildPrompt1;
+exports.buildSpecProtocol = buildSpecProtocol;
 exports.buildPrompt15 = buildPrompt15;
 exports.buildPrompt2 = buildPrompt2;
 /**
- * FORGE Prompt 1 — Self-Spec Agent (from FORGE-quickref.md).
- * Returns the populated prompt ready to hand to a host model.
+ * Nimai Spec Protocol — PHASE 1 through PHASE 4.
+ * Returns the protocol prompt the host model runs to turn a loose request
+ * into a graded, build-ready spec.
+ *
+ * Callers load liteTemplate and fullTemplate via loadTierTemplate() from template.ts
+ * and pass them here. The [EMBED] placeholder is replaced with both template texts.
+ *
+ * Signature: buildSpecProtocol(request, repoPath, liteTemplate, fullTemplate)
  */
-function buildPrompt1(request, contextSummary) {
-    return `You are a Specification Engineering agent operating under the FORGE.
-
-**What you are:** A spec drafter. Your sole output is a complete FORGE spec document.
-**What you are not:** An implementation agent. Do not write code, choose final tech stack, or execute the request.
-**Who consumes your output:** An implementation agent that will build from this spec without asking clarifying questions. Every unresolved decision you leave will become an invention by that agent — two builders given the same spec must produce compatible systems.
-
-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.
-
-**On architecture:** Do not invent architecture beyond what the repo context below reveals. If an architectural decision is required but cannot be answered from the provided context, mark it \`[NEEDS HUMAN INPUT: reason]\`. For greenfield repos with no prior context, state explicit MVP-level assumptions and document them as assumptions — do not present them as facts.
-
-**If you have RepoPrompt available:** Before filling the spec, call RepoPrompt's discovery or read tool on the repo to get full architectural context (existing schemas, data models, tech stack, patterns). Use the output to populate Section 3 (Context Layer) accurately and to inform Section 1.6 (Architecture Lock) with real decisions rather than assumptions.
-
-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. Proposed validator prompt (what a reviewer should check)
-
---- REPO CONTEXT ---
-${contextSummary || '(no repo context extracted — if you have RepoPrompt, call it now before filling the spec)'}
---- END CONTEXT ---
-
-Loose request: ${request}`;
+function buildSpecProtocol(request, repoPath, liteTemplate, fullTemplate) {
+    const embedBlock = `--- LITE TIER TEMPLATE ---\n${liteTemplate}\n--- FULL TIER TEMPLATE ---\n${fullTemplate}`;
+    return `You are running the Nimai spec protocol. Your job is to turn the request
+below into a graded, build-ready spec. You are drafting a contract, not
+implementing it — write no application code during this protocol.
+
+Request: ${request}
+Repository: ${repoPath}
+
+Run the four phases in order. Do not skip a phase; say which phase you
+are in as you work.
+
+PHASE 1 — EXPLORE
+Use your own tools to learn the ground truth before asking the user
+anything:
+- Read the manifest and build files (package.json or equivalent) for
+  stack, dependencies, and scripts.
+- Read the README and any schema, model, or type definition files.
+- Search the code for anything related to the request.
+- Look for existing specs (files ending with a nimai-spec marker
+  comment) — they show conventions already in force.
+If the repository is empty or this is a new project, note "greenfield"
+and move on. Ask the user nothing during this phase.
+
+PHASE 2 — INTERVIEW
+Write 5–8 clarifying questions SPECIFIC to this request and this
+repository — never generic ones. Good questions force a decision the
+user does not realize they have not made:
+- Who uses this, and what do they see first?
+- When [specific failure you can foresee] happens, what is the right
+  behavior?
+- The request could mean [interpretation A] or [interpretation B] —
+  which one?
+- What is explicitly NOT part of this?
+- How will you know it works — what would you check by hand?
+Skip any question the request already answers. Ask all questions in one
+message and wait for the answers.
+
+Then choose the tier and tell the user which and why:
+- lite — small or low-risk work; the one-page spec.
+- full — work that is medium/high risk, touches existing code, or has
+  architectural consequences; adds decomposition, architecture lock,
+  change surface, and edge cases.
+When unsure, choose full.
+
+PHASE 3 — DRAFT
+Fill the tier template below completely. Rules:
+- Every Mechanism Decision commits to exactly ONE approach. If you
+  cannot decide from the interview answers, ask — do not assume.
+- Acceptance criteria are binary and left unchecked.
+- full tier in an existing repository: the Change Surface table lists
+  every file the work touches; the builder may not go outside it.
+- No placeholder text or blank required fields may remain.
+Save the spec to specs/<short-name>.md with the tier marker as the
+final line of the file.
+
+PHASE 4 — GATE
+1. Run nimai_validate on the spec (CLI: nimai validate <path>). Fix
+   structural issues and re-run until it passes.
+2. Run nimai_review with target "spec" (CLI: nimai review <path>
+   --target spec). Hand the returned reviewer prompt to a FRESH agent
+   session — not this one. The drafter must not grade its own draft.
+3. Read the reviewer's verdict (the last fenced JSON block). If it has
+   HARD_FAIL issues: fix the spec, then return to step 1.
+4. When the verdict passes, tell the user: "purification complete —
+   the spec is build-ready", and where it is saved. Your job ends here
+   — building is a separate session with a separate agent.
+
+${embedBlock}`;
 }
 /**
- * FORGE Prompt 1.5 — Spec-Quality Reviewer.
+ * Nimai Prompt 1.5 — Spec-Quality Reviewer.
  * Returns a prompt for a reviewing LLM to evaluate whether a draft spec is
  * executable by an agent without requiring clarifying questions.
  *
@@ -62,9 +106,19 @@ Loose request: ${request}`;
  */
 function buildPrompt15(specContent) {
     return `You are the independent reviewer for this draft spec. Evaluate it now.
-You are a Specification Quality Reviewer operating under the FORGE framework.
+You are a senior engineer doing a full gap audit operating as a Specification Quality Reviewer under the Nimai framework.
+Be exacting: every gap you catch now is one the builder never hits.
+Be strict about the spec and kind to its author — report impurities as findings, not judgments.
+
+Your primary mission: find every gap, ambiguity, and implementation blocker in this spec.
+Steelman the spec as the builder who will implement it: what will you hit mid-execution that the spec does not answer?
+What assumptions are baked in but undeclared? What would make two competent builders produce incompatible systems?
+
+The 10 dimensions below are your **minimum checklist** — you MUST cover all of them, but do not stop there.
+After checking all 10 dimensions, run a full gap audit for any issues not already caught by the named dimensions.
+
+**Evidence requirement:** Every FAIL issue MUST include an exact quoted snippet from the spec (verbatim inline code or blockquote) that demonstrates the problem. An assertion without a quoted evidence snippet is invalid — do not issue a FAIL without one.
 
-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.
 
 ## What to check
@@ -74,16 +128,16 @@ A verdict without citation is treated as NO_GO — do not assert PASS without ev
 
 **Dimensions:**
 
-1. **Binary acceptance criteria** — are all sub-task ACs measurable and unambiguous? Are any ACs pre-checked (- [x]) in the draft, which is always invalid? If Section 1.1 defines a quantitative quality bar, Section 1.4 must include at least one AC that directly enforces that bar (same metric family and threshold intent). Otherwise, FAIL.
-2. **Scope coherence** — are in-scope and out-of-scope boundaries clearly stated and non-contradictory? Check for conflicts between conceptual terminology (e.g., state names, entity names used in descriptions) and persisted/modelled representations (e.g., enums, schemas, data shapes). Any mismatch is 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 completed within the stated 2-hour limit by a skilled agent? Check that sub-task dependencies are stated explicitly (if task B requires task A's output, that must be documented). If Section 1.1 defines a benchmark/dataset path, at least one sub-task must explicitly own creating or curating that benchmark artifact.
+1. **Binary acceptance criteria** — are all sub-task ACs measurable and unambiguous? Are any ACs pre-checked (- [x]) in the draft, which is always invalid? If the Deliverable section defines a quantitative quality bar, the Acceptance Criteria section must include at least one AC that directly enforces that bar (same metric family and threshold intent). Otherwise, FAIL.
+2. **Scope coherence** — are in-scope and out-of-scope boundaries in the Scope section clearly stated and non-contradictory? Check for conflicts between conceptual terminology (e.g., state names, entity names used in descriptions) and persisted/modelled representations (e.g., enums, schemas, data shapes). Any mismatch is a HARD_FAIL.
+3. **Constraint sufficiency** — does the Scope Out-of-scope list cover the key risks? Check that the must-not constraints are explicit and complete enough to prevent the most likely forms of scope creep and builder drift for this specific request.
+4. **Decomposition realism** — can each sub-task be completed within 2 hours by a skilled agent? Check that sub-task dependencies are stated explicitly (if task B requires task A's output, that must be documented). If the Deliverable section defines a benchmark/dataset path, at least one sub-task must explicitly own creating or curating that benchmark artifact.
 5. **Start-without-clarification viability** — can an agent begin immediately with the context provided, without asking the human for more information?
-6. **Internal consistency** — are terms, names, and concepts used consistently throughout the spec? Flag any case where the same entity is described differently in different sections (e.g., "webhook event" in scope, "push notification" in ACs — are these the same thing?). Treat data-type/precision mismatches as consistency defects (e.g., float vs decimal/cents representation). Also FAIL if obvious template artifact text remains (example guidance that should have been replaced by project-specific content).
-7. **Mechanism lock** — does every core flow (data pipeline, primary algorithm, key architecture choice) commit to exactly ONE implementation approach? Scan for "e.g.", "or", "could", "might", "such as" in Deliverable, Scope, Constraints, and Task decomposition sections. If any of these offer multiple options without making an explicit decision, that is a HARD_FAIL — a spec that leaves the mechanism unresolved forces the builder to choose architecture, creating drift in multi-builder workflows. Additional lock checks: (a) external service lock requires concrete vendor/model (env var names alone are not sufficient), (b) auth lock requires token/session type plus expiry policy, (c) endpoint lists without request/response field shapes are SOFT_FAIL.
+6. **Internal consistency** — are terms, names, and concepts used consistently throughout the spec? Flag any case where the same entity is described differently in different sections (e.g., "webhook event" in Scope, "push notification" in Acceptance Criteria — are these the same thing?). Treat data-type/precision mismatches as consistency defects (e.g., float vs decimal/cents representation). Also FAIL if obvious template artifact text remains (example guidance that should have been replaced by project-specific content).
+7. **Mechanism lock** — does every core flow (data pipeline, primary algorithm, key architecture choice) commit to exactly ONE implementation approach? Scan for "e.g.", "or", "could", "might", "such as" in Deliverable, Scope, Mechanism Decisions, and Task Decomposition sections. If any of these offer multiple options without making an explicit decision, that is a HARD_FAIL — a spec that leaves the mechanism unresolved forces the builder to choose architecture, creating drift in multi-builder workflows. Additional lock checks: (a) external service lock requires concrete vendor/model (env var names alone are not sufficient), (b) auth lock requires token/session type plus expiry policy, (c) endpoint lists without request/response field shapes are SOFT_FAIL. Option-language scan: flag any "could use X or Y", "such as X or Y", or "(e.g., X or Y)" in Mechanism Decisions that does not commit to a single choice. Unresolved-threshold scan: flag any comparison of the form "if X >= threshold" or "score < threshold" where "threshold" is not replaced by a concrete numeric value.
 8. **Convergence declaration** — does the spec include a \`## Spec Convergence\` section with \`open_questions: 0\` and \`ambiguities_remaining: 0\`? If the section is absent, or either value is non-zero, or \`ready_for_build\` is "no", that is a HARD_FAIL. This is the formal GO gate — a spec with declared open questions is not agent-ready regardless of how well the other sections are written.
-9. **Adversarial gap scan** — does the spec include an \`## Edge Cases and Failure Modes\` section that is substantively filled? Steelman the spec as a builder who will follow it exactly: what will you hit mid-execution that the spec does not answer? What implicit assumption is baked in but undeclared? What failure mode from the FORGE taxonomy (scope creep, hallucinated completion, intent drift, context collapse, runaway cost, overconfident output) does the spec not address? For mobile/capture flows, explicitly check offline/no-network behavior at capture time and retry/sync handling. An absent or blank section is a HARD_FAIL for medium/high risk specs. Placeholder-only content (\`___\`) is treated as absent.
-10. **Architecture completeness** — for medium/high coding specs, does the spec include \`## 1.6 Architecture Lock\` with all required fields resolved: Persistence layer, File/object storage, External model/service + env var, API trigger flow, Entity status state machine, Auth implementation? Any missing field, blank placeholder, or \`TBD\` is a HARD_FAIL. For low/unknown/non-coding specs, this is NOTE-only advisory.
+9. **Adversarial gap scan** — does the spec include an \`## Edge Cases and Failure Modes\` section that is substantively filled? Steelman the spec as a builder who will follow it exactly: what will you hit mid-execution that the spec does not answer? What implicit assumption is baked in but undeclared? What failure mode from the Nimai taxonomy (scope creep, hallucinated completion, intent drift, context collapse, runaway cost, overconfident output) does the spec not address? For mobile/capture flows, explicitly check offline/no-network behavior at capture time and retry/sync handling. An absent or blank section is a HARD_FAIL for full-tier specs. Placeholder-only content (\`___\`) is treated as absent.
+10. **Architecture completeness** — for full-tier coding specs, does the spec include \`## Architecture Lock\` with all required fields resolved: Persistence layer, File/object storage, External services + env vars, API/trigger flow, Entity states and transitions, Auth? Any missing field, blank placeholder, or \`TBD\` is a HARD_FAIL. For lite-tier or non-coding specs, this is NOTE-only advisory. Also check the \`## Change Surface\` section for full-tier specs in existing repositories: the table must list every file the work touches; an empty table or missing section for a brownfield spec is a HARD_FAIL. Module-rule contradiction scan: if an Architecture Lock section declares a strict import chain (e.g., A → B → C → D) and a module boundary line says a layer "may call" a target not in its direct successor set, that is a HARD_FAIL.
 
 ## Severity classification
 
@@ -118,7 +172,7 @@ If this is a re-review (you were given the builder's fix summary):
 - Re-evaluate each previously-failed dimension directly against the current spec content.
 - Your evidence citation must quote or reference the specific text in the spec that shows the fix was applied.
 - If the fix is present, mark that dimension PASS. If it is absent or incomplete, mark it FAIL.
-- You are only authorized to evaluate the 10 dimensions defined above. Do not invent new dimensions, process gates, or required sections not in the FORGE spec template.
+- You are only authorized to evaluate the 10 dimensions defined above. Do not invent new dimensions, process gates, or required sections not in the Nimai spec template.
 
 ## Important
 
@@ -160,8 +214,9 @@ Write one actionable fix instruction per issue, in order. Each line must include
 ${specContent}`;
 }
 /**
- * FORGE Prompt 2 — Reviewer / Validator Prompt Generator (from FORGE-quickref.md).
+ * Nimai Prompt 2 — Implementation Reviewer Prompt Generator.
  * Returns the populated reviewer prompt derived from an approved spec.
+ * Used for reviewing an implementation against the spec (target=implementation).
  */
 function buildPrompt2(specContent) {
     return `You are a Specification Engineering agent.

package/dist/prompts.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../src/prompts.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;AAMH,oCAkCC;AAeD,sCAkGC;AAMD,oCAgBC;AA7KD;;;GAGG;AACH,SAAgB,YAAY,CAAC,OAAe,EAAE,cAAsB;IAClE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BP,cAAc,IAAI,2FAA2F;;;iBAG9F,OAAO,EAAE,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAAC,WAAmB;IAC/C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgGP,WAAW,EAAE,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAAC,WAAmB;IAC9C,OAAO;;;;;;;;;;;;;;EAcP,WAAW,EAAE,CAAC;AAChB,CAAC"}
+{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../src/prompts.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAYH,8CA2EC;AAeD,sCA4GC;AAOD,oCAgBC;AAvOD;;;;;;;;;GASG;AACH,SAAgB,iBAAiB,CAC/B,OAAe,EACf,QAAgB,EAChB,YAAoB,EACpB,YAAoB;IAEpB,MAAM,UAAU,GAAG,+BAA+B,YAAY,iCAAiC,YAAY,EAAE,CAAC;IAE9G,OAAO;;;;WAIE,OAAO;cACJ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DpB,UAAU,EAAE,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,aAAa,CAAC,WAAmB;IAC/C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0GP,WAAW,EAAE,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,WAAmB;IAC9C,OAAO;;;;;;;;;;;;;;EAcP,WAAW,EAAE,CAAC;AAChB,CAAC"}

package/dist/template.d.ts

@@ -1,4 +1,15 @@
-import { ForgeTemplate, ForgeSection } from './types';
+import { ForgeTemplate, ForgeSection, Tier } from './types';
 export declare function loadTemplate(filePath: string): ForgeTemplate;
+/**
+ * Parse the tier from the nimai-spec marker comment in the spec content.
+ * When multiple markers appear (e.g., a spec quoting template text), the LAST marker wins.
+ * Bare "<!-- nimai-spec -->" (no tier) defaults to "full" for backward compatibility with v0.4 specs.
+ */
+export declare function parseTierFromMarker(content: string): Tier;
+/**
+ * Load one of the two shipped tier templates (lite or full) from the data/ directory.
+ * Returns the raw template text.
+ */
+export declare function loadTierTemplate(tier: Tier): string;
 export declare function parseSections(content: string): ForgeSection[];
 //# sourceMappingURL=template.d.ts.map

package/dist/template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../src/template.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAItD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,CAQ5D;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CA0B7D"}
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../src/template.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAO5D,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,CAQ5D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAMzD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAOnD;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CA0B7D"}

package/dist/template.js

@@ -34,9 +34,15 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadTemplate = loadTemplate;
+exports.parseTierFromMarker = parseTierFromMarker;
+exports.loadTierTemplate = loadTierTemplate;
 exports.parseSections = parseSections;
 const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const forge_root_1 = require("./forge-root");
 const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+// Matches the nimai-spec marker with optional tier attribute
+const NIMAI_MARKER_RE = /<!--\s*nimai-spec(?:\s+tier=(lite|full))?\s*-->/;
 function loadTemplate(filePath) {
     let raw;
     try {
@@ -47,6 +53,32 @@ function loadTemplate(filePath) {
     }
     return { raw, sections: parseSections(raw) };
 }
+/**
+ * Parse the tier from the nimai-spec marker comment in the spec content.
+ * When multiple markers appear (e.g., a spec quoting template text), the LAST marker wins.
+ * Bare "<!-- nimai-spec -->" (no tier) defaults to "full" for backward compatibility with v0.4 specs.
+ */
+function parseTierFromMarker(content) {
+    const matches = [...content.matchAll(/<!--\s*nimai-spec(?:\s+tier=(lite|full))?\s*-->/g)];
+    if (matches.length === 0)
+        return 'full';
+    const last = matches[matches.length - 1];
+    const tier = last[1]; // undefined if bare marker
+    return tier === 'lite' ? 'lite' : 'full';
+}
+/**
+ * Load one of the two shipped tier templates (lite or full) from the data/ directory.
+ * Returns the raw template text.
+ */
+function loadTierTemplate(tier) {
+    const templatePath = path.join(forge_root_1.FORGE_ROOT, `nimai-spec-${tier}.md`);
+    try {
+        return fs.readFileSync(templatePath, 'utf-8');
+    }
+    catch (err) {
+        throw new Error(`Cannot read ${tier} tier template at "${templatePath}": ${err.message}`);
+    }
+}
 function parseSections(content) {
     const lines = content.split('\n');
     const sections = [];

package/dist/template.js.map

@@ -1 +1 @@
-{"version":3,"file":"template.js","sourceRoot":"","sources":["../src/template.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,oCAQC;AAED,sCA0BC;AAzCD,uCAAyB;AAGzB,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAEvC,SAAgB,YAAY,CAAC,QAAgB;IAC3C,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC3C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,4BAA4B,QAAQ,MAAO,GAA6B,CAAC,OAAO,EAAE,CAAC,CAAC;IACtG,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;AAC/C,CAAC;AAED,SAAgB,aAAa,CAAC,OAAe;IAC3C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,QAAQ,GAAmB,EAAE,CAAC;IACpC,IAAI,OAAO,GAAwB,IAAI,CAAC;IACxC,MAAM,YAAY,GAAa,EAAE,CAAC;IAElC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,CAAC,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;gBACjD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACvB,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;YAC1B,CAAC;YACD,OAAO,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;QAC9E,CAAC;aAAM,IAAI,OAAO,EAAE,CAAC;YACnB,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IAED,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,CAAC,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;QACjD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}
+{"version":3,"file":"template.js","sourceRoot":"","sources":["../src/template.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -1,9 +1,9 @@
-export type LintIssueType = 'blank_field' | 'needs_human_input' | 'missing_section' | 'missing_module_boundary' | 'missing_interface_contract' | 'missing_non_goals' | 'missing_change_surface' | 'missing_dependency_direction' | 'pre_checked_ac' | 'missing_marker' | 'unresolved_mechanism' | 'missing_mechanism_decision' | 'ambiguous_chosen_approach' | 'missing_convergence_section' | 'unresolved_convergence' | 'missing_edge_cases' | 'missing_architecture_lock';
+export type LintIssueType = 'blank_field' | 'needs_human_input' | 'missing_required_section' | 'pre_checked_ac' | 'missing_marker' | 'blank_placeholder' | 'unresolved_convergence' | 'missing_convergence_section';
 export interface LintIssue {
     line: number;
     type: LintIssueType;
     message: string;
-    /** Advisory issues are warnings only — nimai validate exits 0 unless --strict-architecture */
+    /** Advisory issues are warnings only — nimai validate exits 0 unless they are the only issues */
     advisory?: boolean;
 }
 export interface ForgeSection {
@@ -15,9 +15,5 @@ export interface ForgeTemplate {
     raw: string;
     sections: ForgeSection[];
 }
-export interface ContextItem {
-    file: string;
-    snippet: string;
-    relevance: number;
-}
+export type Tier = 'lite' | 'full';
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GACrB,aAAa,GACb,mBAAmB,GACnB,iBAAiB,GACjB,yBAAyB,GACzB,4BAA4B,GAC5B,mBAAmB,GACnB,wBAAwB,GACxB,8BAA8B,GAC9B,gBAAgB,GAChB,gBAAgB,GAChB,sBAAsB,GACtB,4BAA4B,GAC5B,2BAA2B,GAC3B,6BAA6B,GAC7B,wBAAwB,GACxB,oBAAoB,GACpB,2BAA2B,CAAC;AAEhC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GACrB,aAAa,GACb,mBAAmB,GACnB,0BAA0B,GAC1B,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,wBAAwB,GACxB,6BAA6B,CAAC;AAElC,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,iGAAiG;IACjG,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nimai-core",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "Nimai core library — template loading, lint engine, context extraction. No LLM dependencies.",
   "keywords": [
     "nimai",
@@ -19,7 +19,8 @@
     "directory": "packages/core"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "data/"
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/clarification.d.ts

@@ -1,22 +0,0 @@
-/**
- * Rule-based clarification heuristics for nimai_spec.
- *
- * These are pure functions — no IO, no LLM calls.
- * Trigger `clarifications_needed` when any heuristic fires.
- */
-export interface ClarificationResult {
-    needed: boolean;
-    reasons: string[];
-    questions: string[];
-}
-/**
- * Evaluate whether a spec request needs clarification before drafting.
- *
- * Heuristics (any one firing triggers clarification):
- * 1. Request is under 10 words
- * 2. Zero repo files matched by context extractor
- * 3. No domain nouns or action verbs detected
- * 4. Conflicting stack hints (two competing tech choices in same category)
- */
-export declare function detectClarifications(request: string, contextFileCount: number): ClarificationResult;
-//# sourceMappingURL=clarification.d.ts.map

package/dist/clarification.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clarification.d.ts","sourceRoot":"","sources":["../src/clarification.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAuEH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,GACvB,mBAAmB,CA+BrB"}

package/dist/clarification.js

@@ -1,106 +0,0 @@
-"use strict";
-/**
- * Rule-based clarification heuristics for nimai_spec.
- *
- * These are pure functions — no IO, no LLM calls.
- * Trigger `clarifications_needed` when any heuristic fires.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectClarifications = detectClarifications;
-// ─── Domain noun / action vocab ───────────────────────────────────────────────
-/**
- * Minimum set of technical domain nouns and action verbs that indicate the
- * request describes a real engineering task. If the request contains none of
- * these, it is likely too vague to spec reliably.
- */
-const DOMAIN_TOKENS = new Set([
-    // Action verbs
-    'add', 'build', 'create', 'implement', 'fix', 'refactor', 'update', 'migrate',
-    'design', 'integrate', 'deploy', 'remove', 'generate', 'optimize', 'extend',
-    'replace', 'extract', 'expose', 'wire', 'scaffold', 'test', 'benchmark',
-    // Technical nouns
-    'api', 'service', 'component', 'model', 'module', 'database', 'endpoint',
-    'interface', 'schema', 'type', 'function', 'class', 'route', 'handler',
-    'middleware', 'auth', 'token', 'config', 'cli', 'ui', 'hook', 'store',
-    'query', 'mutation', 'event', 'queue', 'cache', 'index', 'migration',
-    'server', 'client', 'backend', 'frontend', 'test', 'spec', 'pipeline',
-    'workflow', 'adapter', 'plugin', 'sdk', 'contract', 'validator', 'parser',
-]);
-/**
- * Returns true if the request contains at least one recognizable domain token.
- */
-function hasDomainNoun(request) {
-    const words = request.toLowerCase().match(/\b[a-z]+\b/g) ?? [];
-    return words.some(w => DOMAIN_TOKENS.has(w));
-}
-// ─── Conflicting stack detection ──────────────────────────────────────────────
-/** Groups of mutually-competing technology choices. Two items from the same group = conflict. */
-const STACK_GROUPS = [
-    // Programming languages — any two in the same request signals ambiguous stack
-    [
-        'python', 'ruby', 'java', 'golang', 'rust', 'kotlin', 'swift', 'scala',
-        'php', 'elixir', 'csharp', 'typescript', 'javascript',
-    ],
-    // JS UI frameworks
-    ['react', 'vue', 'angular', 'svelte'],
-    // CSS frameworks
-    ['tailwind', 'bootstrap'],
-    // Relational databases
-    ['postgresql', 'postgres', 'mysql', 'sqlite'],
-    // NoSQL databases
-    ['mongodb', 'dynamodb', 'firestore', 'cassandra'],
-    // JS test frameworks
-    ['jest', 'vitest', 'jasmine'],
-];
-/**
- * Returns true if the request mentions ≥2 items from the same competing stack group,
- * indicating an ambiguous or conflicting technology choice.
- */
-function hasConflictingStack(request) {
-    const lower = request.toLowerCase();
-    for (const group of STACK_GROUPS) {
-        const hits = group.filter(tech => {
-            // Match as whole word or compound (e.g. "typescript", "vue.js")
-            const pattern = new RegExp(`\\b${tech.replace(/[-.]/g, '[-.\\s]?')}\\b`, 'i');
-            return pattern.test(lower);
-        });
-        if (hits.length >= 2)
-            return true;
-    }
-    return false;
-}
-/**
- * Evaluate whether a spec request needs clarification before drafting.
- *
- * Heuristics (any one firing triggers clarification):
- * 1. Request is under 10 words
- * 2. Zero repo files matched by context extractor
- * 3. No domain nouns or action verbs detected
- * 4. Conflicting stack hints (two competing tech choices in same category)
- */
-function detectClarifications(request, contextFileCount) {
-    const reasons = [];
-    const wordCount = request.trim().split(/\s+/).length;
-    if (wordCount < 10) {
-        reasons.push(`request is too short (${wordCount} words — add more context)`);
-    }
-    if (contextFileCount === 0) {
-        reasons.push('no relevant repo files matched — is the repo path correct, or is this a new project?');
-    }
-    if (!hasDomainNoun(request)) {
-        reasons.push('no recognizable domain nouns or action verbs found — describe what should be built or changed');
-    }
-    if (hasConflictingStack(request)) {
-        reasons.push('conflicting technology stack hints detected — clarify which stack applies or separate into distinct tasks');
-    }
-    const needed = reasons.length > 0;
-    const questions = needed
-        ? [
-            'What is the primary goal or outcome you want to achieve?',
-            'Which specific files, components, or systems should be modified?',
-            'Are there constraints, dependencies, or requirements we should be aware of?',
-        ]
-        : [];
-    return { needed, reasons, questions };
-}
-//# sourceMappingURL=clarification.js.map

package/dist/clarification.js.map

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

package/dist/context.d.ts

@@ -1,3 +0,0 @@
-import { ContextItem } from './types';
-export declare function extractContext(repoPath: string, request: string): ContextItem[];
-//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA4DtC,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CAiB/E"}