@noir-ai/workflow 1.0.0-beta.1 → 1.2.0-beta.1

package/dist/index.d.ts

@@ -6,10 +6,36 @@ type Phase = (typeof PHASES)[number];
 declare const STATES: readonly ["draft", "clarifying", "specified", "planned", "executing", "verifying", "done", "blocked", "abandoned"];
 type WorkflowState = (typeof STATES)[number];
 type Mode = 'full' | 'quick';
-interface GateResult {
+/**
+ * Task classification — drives the soft, escapable gate predicates (slice P:
+ * the PRD recommendation at the spec gate). Mirrors the user-facing
+ * `prd.mandatoryFor` enum in @noir-ai/core's `NoirConfigSchema` (declared
+ * LOCALLY here so workflow has no core-cycle concern; the two literals stay in
+ * sync by tests). `undefined` (the default for legacy tasks) ⇒ no soft gate
+ * fires — additive, fully backward-compatible.
+ */
+declare const TASK_CLASSES: readonly ["feature", "epic", "enhancement", "bugfix", "spike", "quick-task", "refactor"];
+type TaskClass = (typeof TASK_CLASSES)[number];
+/**
+ * Input shape for {@link recordGate} — what CALLERS pass. Omits `at` (the
+ * recorder stamps it from `Date.now()` so the audit reflects when the gate
+ * actually fired, not when the caller constructed the object). Split out of
+ * {@link GateResult} (debt-batch A / W3): callers used to pass a throwaway
+ * `at: 0` that recordGate overrode — this shape makes the override implicit.
+ */
+interface GateResultInput {
     phase: Phase;
     decision: 'approved' | 'forced' | 'skipped';
     reason?: string;
+}
+/**
+ * A recorded gate decision — the AUTHORITATIVE shape stored in the
+ * `audit:<taskId>` KV (the SOT per S4 spec §5 / §11 OQ-5) and surfaced via
+ * `task.history` (a derived view the engine regenerates from the audit KV).
+ * `at` is always present here; callers that want to RECORD a gate pass
+ * {@link GateResultInput} (no `at`) to {@link recordGate}.
+ */
+interface GateResult extends GateResultInput {
     at: number;
 }
 interface TaskState {
@@ -19,12 +45,43 @@ interface TaskState {
     state: WorkflowState;
     phase: Phase;
     mode: Mode;
+    /**
+     * DERIVED view of the gate audit for this task, regenerated from the
+     * authoritative `audit:<taskId>` KV (S4 spec §11 OQ-5) by the engine on
+     * every write and every status read. Kept on the TaskState so consumers
+     * (CLI `task status`, the daemon `workflow_status` tool, MCP clients) can
+     * read the gate history from the persisted TaskState without a second KV
+     * lookup. Never edited directly outside the engine — derive via
+     * {@link readGateHistory}.
+     */
     history: GateResult[];
+    /** Task classification (slice P). `undefined` ⇒ no soft PRD gate fires. */
+    taskClass?: TaskClass;
     jumpEntry?: Phase;
     /** Reason captured by `setBlocked` (admin escape; set directly, not via FSM). */
     blockReason?: string;
     updatedAt: number;
 }
+/**
+ * The gate-config slice the engine consumes (debt-batch A / P4). Mirrors the
+ * user-facing `prd:` block from @noir-ai/core's `NoirConfigSchema` — declared
+ * locally (with a `readonly` array) so workflow has no core-cycle concern; the
+ * daemon / CLI bridges NoirConfig → this shape at construction time. Every
+ * field has a sane default, so an unspecified `gateConfig` (the legacy
+ * constructor call) resolves to "feature/epic trigger the PRD recommendation".
+ */
+interface WorkflowGateConfig {
+    /**
+     * PRD soft-gate config. `mandatoryFor` lists the task classes for which a
+     * missing PRD artifact (at the moment of entering the spec phase, in full
+     * mode) is surfaced as an observable, escapable recommendation on the spec
+     * gate. The advance still proceeds — `--force <reason>` is the explicit
+     * override path; quick mode + unlisted classes skip the check entirely.
+     */
+    prd: {
+        mandatoryFor: readonly TaskClass[];
+    };
+}
 
 /**
  * Write intake artifact to .noir/intake/<taskId>.md
@@ -35,6 +92,13 @@ declare function writeIntake(root: string, taskId: string, content: string): voi
  * Creates markdown with frontmatter and body
  */
 declare function writeSpec(root: string, taskId: string, slug: string, body: string): void;
+/**
+ * Write PRD artifact to .noir/prd/<taskId>-<slug>.md
+ * Pre-SDD product document; the spec @imports it (prdRef). No FSM change.
+ */
+declare function writePrd(root: string, taskId: string, slug: string, body: string): void;
+/** Read a PRD artifact, or null if absent. */
+declare function readPrd(root: string, taskId: string, slug: string): string | null;
 /**
  * Write plan artifact to .noir/plans/<taskId>-<slug>.md
  */
@@ -63,7 +127,10 @@ interface AdvanceOpts {
      * Pass a gate without satisfying its criteria. Requires a non-empty `reason`
      * (validated here, in the engine — `recordGate` is policy-free). The landing
      * gate, if any, is recorded with `decision: 'forced'`. Mutually exclusive
-     * with {@link skip}.
+     * with {@link skip}. This is ALSO the explicit-override path for the soft
+     * PRD recommendation (debt-batch A / P4): supplying `--force <reason>` at the
+     * spec gate of a mandatoryFor task with no PRD records `forced` with the
+     * user's reason instead of the recommendation note.
      */
     force?: {
         reason?: string;
@@ -72,7 +139,9 @@ interface AdvanceOpts {
      * Jump directly to a phase, bypassing the FSM (the escape hatch for blocked /
      * out-of-order resumption). The landing is recorded as `jumpEntry` on the
      * TaskState; a landing gate-state (specified/planned/done) still records its
-     * gate so the observable-checkpoint invariant holds.
+     * gate so the observable-checkpoint invariant holds. A no-op jump (target
+     * equal to the current phase) returns the task unchanged without re-recording
+     * any gate (W3 guard — the prior behavior double-stamped the audit).
      */
     to?: Phase;
     /**
@@ -94,7 +163,8 @@ interface AdvanceOpts {
  * Policy that did not belong in T1/T2 lives here:
  *   • `--force` requires a non-empty reason (validated before any gate write),
  *   • `blocked` / `abandoned` have no incoming FSM edges and are set directly,
- *   • `opts.to` jumps past FSM edges and is recorded via `jumpEntry`.
+ *   • `opts.to` jumps past FSM edges and is recorded via `jumpEntry`,
+ *   • (P4) the soft PRD recommendation at the spec gate for mandatoryFor tasks.
  *
  * Modes (Full/Quick) and cross-session resume are T5; MCP tools are T6 — the
  * engine stays mode-agnostic here and only stores `mode` on the TaskState.
@@ -109,6 +179,7 @@ declare class WorkflowEngine {
      */
     readonly root: string;
     private readonly projectId;
+    private readonly gateConfig;
     constructor(store: Store, 
     /**
      * Project root — the engine is constructed with it so modes (quickPath
@@ -116,13 +187,26 @@ declare class WorkflowEngine {
      * (checkpoint/audit export) are self-contained. Public so the modes module
      * can pass it to {@link ArtifactWriter}.
      */
-    root: string, projectId: ProjectId);
+    root: string, projectId: ProjectId, 
+    /**
+     * Gate-config slice (debt-batch A / P4). Optional — the legacy 3-arg call
+     * shape (every existing consumer) resolves to {@link DEFAULT_GATE_CONFIG}
+     * (PRD recommendation fires for feature/epic). The daemon / CLI bridge
+     * passes the resolved `prd.mandatoryFor` from NoirConfig so user overrides
+     * take effect; tests pass an explicit shape to pin behavior.
+     */
+    gateConfig?: WorkflowGateConfig);
     /**
      * Create a new task at draft/intake, persist it, and point `workflow:active`
      * at it. Re-starting an existing taskId overwrites it (intentional — the KV is
      * the source of truth, not a journal).
+     *
+     * `taskClass` (debt-batch A / P4) is optional and additive — legacy callers
+     * (and existing tests) omit it; the soft PRD gate then never fires for the
+     * task (consistent with the "additive, no-op when absent" rule). New callers
+     * that want the recommendation pass `'feature'` / `'epic'` / etc.
      */
-    startTask(taskId: string, slug: string, mode: Mode): Promise<TaskState>;
+    startTask(taskId: string, slug: string, mode: Mode, taskClass?: TaskClass): Promise<TaskState>;
     /**
      * Advance `taskId` to its next phase, or jump with `opts.to`.
      *
@@ -131,8 +215,25 @@ declare class WorkflowEngine {
      * reason) when `opts.force` is supplied, or `skipped` when `opts.skip` is
      * supplied (quick mode). `force` and `skip` are mutually exclusive. Jumps
      * bypass the FSM and additionally stamp `jumpEntry`.
+     *
+     * Single source of truth (W1): the gate is written ONCE to the audit KV via
+     * {@link recordGate}, and `task.history` is RE-DERIVED from that KV. No
+     * second write, no second timestamp — the S4 sub-ms drift is gone.
      */
     advance(taskId: string, opts?: AdvanceOpts): Promise<TaskState>;
+    /**
+     * Compute the soft PRD-recommendation message (P4), or `null` when the
+     * recommendation does NOT apply. The recommendation applies when ALL of:
+     *   • the gate landing now is the spec gate (entering `specified`), AND
+     *   • the task is in full mode (quick mode skips — quickPath writes a stub), AND
+     *   • the task has a `taskClass` listed in `gateConfig.prd.mandatoryFor`, AND
+     *   • no PRD artifact exists at `.noir/prd/<id>-<slug>.md` (readPrd), AND
+     *   • the user did NOT supply --force (force is the explicit-override path).
+     *
+     * Returns the observable note (audited on the spec gate's `reason`) so a
+     * downstream consumer (CLI status, workflow_status MCP tool) can surface it.
+     */
+    private prdRecommendation;
     /** Read the persisted TaskState, or null if the task is unknown. */
     status(taskId: string): TaskState | null;
     /**
@@ -143,14 +244,27 @@ declare class WorkflowEngine {
      */
     activeTaskId(): string | null;
     /**
-     * Re-flush the current state to KV. In T4 every advance already persists, so
-     * this is the explicit "mark a checkpoint" hook (bumps `updatedAt`); T5
-     * deepens it to flush artifacts + audit export for cross-session resume.
+     * Re-flush the current state to KV + flush the gate audit export to
+     * `.noir/audit/<taskId>.json`. W2 (debt-batch A): the prior implementation
+     * only bumped `updatedAt`, which every advance already does — vestigial.
+     * Cross-session resume (`resumeTask`) reads `workflow:<id>` straight from the
+     * KV and consumes nothing from this method; the S4 ledger noted the write was
+     * dead. The fix is to WIRE the checkpoint to a real cross-tool artifact
+     * flush: the audit JSON on disk (the S4 spec §11 OQ-5 "export to
+     * `.noir/audit/<taskId>.json`" that {@link writeAuditExport} already
+     * implemented but nothing called). The MCP `checkpoint { action:'save' }`
+     * tool stays the public surface; its save now leaves a human-inspectable
+     * audit JSON alongside the KV.
      */
     checkpoint(taskId: string): Promise<void>;
     /**
      * Set state directly to `blocked` (no FSM edge — the admin escape). The reason
      * is captured on the TaskState for surfacing in `noir.workflow_status`.
+     *
+     * W3: a SUPPLIED reason must be non-empty after trimming (mirrors the
+     * `--force` policy). `setBlocked(id)` with no reason stays valid — it clears
+     * no field and just flips state. A whitespace-only reason is rejected as
+     * malformed (consistent with `--force`'s whitespace rejection).
      */
     setBlocked(taskId: string, reason?: string): Promise<TaskState>;
     /** Set state directly to `abandoned` (terminal; no FSM edge). */
@@ -176,17 +290,36 @@ declare function gateFor(phase: Phase): WorkflowState | null;
 /**
  * Append a gate decision to the task's audit log in the store KV.
  *
- * The audit lives at `audit:<taskId>` as a `GateResult[]` and is the source of
- * truth for every gate outcome (the `.noir/audit/` export is a later helper).
+ * The audit lives at `audit:<taskId>` as a `GateResult[]` and is the
+ * AUTHORITATIVE record for every gate outcome (S4 spec §5 / §11 OQ-5 — "audit
+ * in store KV as source of truth + export to `.noir/audit/<taskId>.json`").
+ * The {@link TaskState.history} field is a DERIVED view, regenerated from this
+ * KV by the engine — never edited directly. This collapses the S4 dual source
+ * of truth (debt-batch A / W1): one write, one timestamp, one read-back.
+ *
  * This is the "quiet observable checkpoint": an `approved`, `forced`, or
  * `skipped` decision is always recorded — never silently dropped — and `forced`
  * carries a `reason`.
  *
  * `at` is stamped here (`Date.now()`) rather than trusted from the caller, so
- * the audit reflects when the gate actually fired. The write is append-only:
+ * the audit reflects when the gate actually fired (single timestamp — the W3
+ * sub-ms drift between the engine's history stamp and the audit KV stamp is
+ * gone, because there is no longer a second stamp). The write is append-only:
  * prior entries are read and preserved (never overwritten).
  */
-declare function recordGate(store: Store, taskId: string, result: GateResult): void;
+declare function recordGate(store: Store, taskId: string, result: GateResultInput): GateResult;
+/**
+ * Read the authoritative gate audit for `taskId` from the store KV. Returns an
+ * empty array when no gate has fired yet (a fresh task) — never `null`, so
+ * callers can spread/index without a separate undefined check.
+ *
+ * The engine uses this to regenerate {@link TaskState.history} (the derived
+ * view) on every advance and every status read; downstream consumers
+ * (`buildWorkflowStatus`, the CLI `task status`) read `task.history` and so get
+ * the derived-from-KV value indirectly — the audit KV remains the SOT they all
+ * ultimately derive from.
+ */
+declare function readGateHistory(store: Store, taskId: string): GateResult[];
 
 /**
  * Default spec body written by {@link runQuick}. Quick mode is "discipline
@@ -237,4 +370,4 @@ declare function applyTransition(from: WorkflowState, to: WorkflowState): Workfl
 declare function stateForPhase(p: Phase): WorkflowState;
 declare function nextPhase(state: WorkflowState): Phase | null;
 
-export { type AdvanceOpts, type GateResult, type Mode, PHASES, type Phase, QUICK_SPEC_STUB, type QuickOpts, STATES, type TaskState, WorkflowEngine, type WorkflowState, applyTransition, canTransition, gateFor, nextPhase, recordGate, resumeTask, runQuick, stateForPhase, writeAuditExport, writeChangelogStub, writeDecisionStub, writeIntake, writePlan, writeSpec, writeTask };
+export { type AdvanceOpts, type GateResult, type GateResultInput, type Mode, PHASES, type Phase, QUICK_SPEC_STUB, type QuickOpts, STATES, TASK_CLASSES, type TaskClass, type TaskState, WorkflowEngine, type WorkflowGateConfig, type WorkflowState, applyTransition, canTransition, gateFor, nextPhase, readGateHistory, readPrd, recordGate, resumeTask, runQuick, stateForPhase, writeAuditExport, writeChangelogStub, writeDecisionStub, writeIntake, writePlan, writePrd, writeSpec, writeTask };

package/dist/index.js

@@ -20,6 +20,23 @@ slug: ${slug}
 ${body}`;
   writeFileSync(file, content, "utf-8");
 }
+function writePrd(root, taskId, slug, body) {
+  const dir = paths.prdDir(root);
+  const file = paths.prdFile(root, taskId, slug);
+  mkdirSync(dir, { recursive: true });
+  const content = `---
+taskId: ${taskId}
+slug: ${slug}
+---
+
+${body}`;
+  writeFileSync(file, content, "utf-8");
+}
+function readPrd(root, taskId, slug) {
+  const file = paths.prdFile(root, taskId, slug);
+  if (!existsSync(file)) return null;
+  return readFileSync(file, "utf-8");
+}
 function writePlan(root, taskId, slug, body) {
   const dir = paths.plansDir(root);
   const file = paths.planFile(root, taskId, slug);
@@ -97,7 +114,12 @@ function gateFor(phase) {
 function recordGate(store, taskId, result) {
   const key = `audit:${taskId}`;
   const prior = store.getState(key) ?? [];
-  store.setState(key, [...prior, { ...result, at: Date.now() }]);
+  const recorded = { ...result, at: Date.now() };
+  store.setState(key, [...prior, recorded]);
+  return recorded;
+}
+function readGateHistory(store, taskId) {
+  return store.getState(`audit:${taskId}`) ?? [];
 }
 
 // src/types.ts
@@ -121,6 +143,15 @@ var STATES = [
   "blocked",
   "abandoned"
 ];
+var TASK_CLASSES = [
+  "feature",
+  "epic",
+  "enhancement",
+  "bugfix",
+  "spike",
+  "quick-task",
+  "refactor"
+];
 
 // src/state-machine.ts
 var TRANSITIONS = {
@@ -177,6 +208,9 @@ function nextPhase(state) {
 // src/engine.ts
 var ACTIVE_KEY = "workflow:active";
 var GATE_PHASES = ["spec", "plan", "verify"];
+var DEFAULT_GATE_CONFIG = {
+  prd: { mandatoryFor: ["feature", "epic"] }
+};
 function gatePhaseForState(state) {
   for (const p of GATE_PHASES) {
     if (gateFor(p) === state) return p;
@@ -184,20 +218,27 @@ function gatePhaseForState(state) {
   return null;
 }
 var WorkflowEngine = class {
-  constructor(store, root, projectId) {
+  constructor(store, root, projectId, gateConfig) {
     this.store = store;
     this.root = root;
     this.projectId = projectId;
+    this.gateConfig = gateConfig ?? DEFAULT_GATE_CONFIG;
   }
   store;
   root;
   projectId;
+  gateConfig;
   /**
    * Create a new task at draft/intake, persist it, and point `workflow:active`
    * at it. Re-starting an existing taskId overwrites it (intentional — the KV is
    * the source of truth, not a journal).
+   *
+   * `taskClass` (debt-batch A / P4) is optional and additive — legacy callers
+   * (and existing tests) omit it; the soft PRD gate then never fires for the
+   * task (consistent with the "additive, no-op when absent" rule). New callers
+   * that want the recommendation pass `'feature'` / `'epic'` / etc.
    */
-  async startTask(taskId, slug, mode) {
+  async startTask(taskId, slug, mode, taskClass) {
     const task = {
       taskId,
       slug,
@@ -206,6 +247,7 @@ var WorkflowEngine = class {
       phase: "intake",
       mode,
       history: [],
+      ...taskClass !== void 0 ? { taskClass } : {},
       updatedAt: Date.now()
     };
     this.persist(task);
@@ -220,6 +262,10 @@ var WorkflowEngine = class {
    * reason) when `opts.force` is supplied, or `skipped` when `opts.skip` is
    * supplied (quick mode). `force` and `skip` are mutually exclusive. Jumps
    * bypass the FSM and additionally stamp `jumpEntry`.
+   *
+   * Single source of truth (W1): the gate is written ONCE to the audit KV via
+   * {@link recordGate}, and `task.history` is RE-DERIVED from that KV. No
+   * second write, no second timestamp — the S4 sub-ms drift is gone.
    */
   async advance(taskId, opts) {
     const task = this.requireTask(taskId);
@@ -231,6 +277,9 @@ var WorkflowEngine = class {
     }
     const jump = opts?.to !== void 0;
     const targetPhase = jump ? opts?.to : this.nextPhaseOf(task);
+    if (jump && targetPhase === task.phase) {
+      return task;
+    }
     const targetState = stateForPhase(targetPhase);
     if (!jump) {
       applyTransition(task.state, targetState);
@@ -238,15 +287,17 @@ var WorkflowEngine = class {
     const gatePhase = gatePhaseForState(targetState);
     if (gatePhase !== null) {
       const decision = opts?.force ? "forced" : opts?.skip ? "skipped" : "approved";
-      const gate = {
+      const prdHint = this.prdRecommendation(task, gatePhase, opts);
+      const input = {
         phase: gatePhase,
         decision,
-        // exactOptionalPropertyTypes is false; spread reason only when forced.
-        ...opts?.force ? { reason: opts.force.reason } : {},
-        at: Date.now()
+        // exactOptionalPropertyTypes is false; spread reason only when present.
+        // Force-path wins over the soft hint (a user who forces is explicitly
+        // accepting the recommendation; their reason is the override signal).
+        ...opts?.force ? { reason: opts.force.reason } : prdHint !== null ? { reason: prdHint } : {}
       };
-      recordGate(this.store, taskId, gate);
-      task.history.push(gate);
+      recordGate(this.store, taskId, input);
+      task.history = readGateHistory(this.store, taskId);
     }
     task.state = targetState;
     task.phase = targetPhase;
@@ -255,9 +306,34 @@ var WorkflowEngine = class {
     this.persist(task);
     return task;
   }
+  /**
+   * Compute the soft PRD-recommendation message (P4), or `null` when the
+   * recommendation does NOT apply. The recommendation applies when ALL of:
+   *   • the gate landing now is the spec gate (entering `specified`), AND
+   *   • the task is in full mode (quick mode skips — quickPath writes a stub), AND
+   *   • the task has a `taskClass` listed in `gateConfig.prd.mandatoryFor`, AND
+   *   • no PRD artifact exists at `.noir/prd/<id>-<slug>.md` (readPrd), AND
+   *   • the user did NOT supply --force (force is the explicit-override path).
+   *
+   * Returns the observable note (audited on the spec gate's `reason`) so a
+   * downstream consumer (CLI status, workflow_status MCP tool) can surface it.
+   */
+  prdRecommendation(task, gatePhase, opts) {
+    if (gatePhase !== "spec") return null;
+    if (task.mode === "quick") return null;
+    const taskClass = task.taskClass;
+    if (taskClass === void 0) return null;
+    if (!this.gateConfig.prd.mandatoryFor.includes(taskClass)) return null;
+    if (opts?.force) return null;
+    if (readPrd(this.root, task.taskId, task.slug) !== null) return null;
+    return `PRD recommended for ${taskClass} \u2014 provide one (noir-prd) or --force <reason> to skip`;
+  }
   /** Read the persisted TaskState, or null if the task is unknown. */
   status(taskId) {
-    return this.store.getState(workflowKey(taskId));
+    const task = this.store.getState(workflowKey(taskId));
+    if (!task) return null;
+    task.history = readGateHistory(this.store, taskId);
+    return task;
   }
   /**
    * The taskId of the most-recently-started task (`workflow:active` in the
@@ -269,24 +345,44 @@ var WorkflowEngine = class {
     return this.store.getState(ACTIVE_KEY);
   }
   /**
-   * Re-flush the current state to KV. In T4 every advance already persists, so
-   * this is the explicit "mark a checkpoint" hook (bumps `updatedAt`); T5
-   * deepens it to flush artifacts + audit export for cross-session resume.
+   * Re-flush the current state to KV + flush the gate audit export to
+   * `.noir/audit/<taskId>.json`. W2 (debt-batch A): the prior implementation
+   * only bumped `updatedAt`, which every advance already does — vestigial.
+   * Cross-session resume (`resumeTask`) reads `workflow:<id>` straight from the
+   * KV and consumes nothing from this method; the S4 ledger noted the write was
+   * dead. The fix is to WIRE the checkpoint to a real cross-tool artifact
+   * flush: the audit JSON on disk (the S4 spec §11 OQ-5 "export to
+   * `.noir/audit/<taskId>.json`" that {@link writeAuditExport} already
+   * implemented but nothing called). The MCP `checkpoint { action:'save' }`
+   * tool stays the public surface; its save now leaves a human-inspectable
+   * audit JSON alongside the KV.
    */
   async checkpoint(taskId) {
     const task = this.store.getState(workflowKey(taskId));
     if (!task) throw new Error(`Unknown task: ${taskId}`);
     task.updatedAt = Date.now();
     this.persist(task);
+    writeAuditExport(this.root, taskId, readGateHistory(this.store, taskId));
   }
   /**
    * Set state directly to `blocked` (no FSM edge — the admin escape). The reason
    * is captured on the TaskState for surfacing in `noir.workflow_status`.
+   *
+   * W3: a SUPPLIED reason must be non-empty after trimming (mirrors the
+   * `--force` policy). `setBlocked(id)` with no reason stays valid — it clears
+   * no field and just flips state. A whitespace-only reason is rejected as
+   * malformed (consistent with `--force`'s whitespace rejection).
    */
   async setBlocked(taskId, reason) {
     const task = this.requireTask(taskId);
+    if (reason !== void 0) {
+      const trimmed = reason.trim();
+      if (trimmed.length === 0) {
+        throw new Error("setBlocked reason must be non-empty (or omitted to leave unset)");
+      }
+      task.blockReason = trimmed;
+    }
     task.state = "blocked";
-    if (reason) task.blockReason = reason;
     task.updatedAt = Date.now();
     this.persist(task);
     return task;
@@ -343,11 +439,14 @@ export {
   PHASES,
   QUICK_SPEC_STUB,
   STATES,
+  TASK_CLASSES,
   WorkflowEngine,
   applyTransition,
   canTransition,
   gateFor,
   nextPhase,
+  readGateHistory,
+  readPrd,
   recordGate,
   resumeTask,
   runQuick,
@@ -357,6 +456,7 @@ export {
   writeDecisionStub,
   writeIntake,
   writePlan,
+  writePrd,
   writeSpec,
   writeTask
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/artifacts.ts","../src/gates.ts","../src/types.ts","../src/state-machine.ts","../src/engine.ts","../src/modes.ts"],"sourcesContent":["import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { paths } from '@noir-ai/core';\nimport type { GateResult } from './types.js';\n\n/**\n * Write intake artifact to .noir/intake/<taskId>.md\n */\nexport function writeIntake(root: string, taskId: string, content: string): void {\n  const dir = join(root, '.noir', 'intake');\n  const file = join(dir, `${taskId}.md`);\n\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write spec artifact to .noir/specs/<taskId>-<slug>.md\n * Creates markdown with frontmatter and body\n */\nexport function writeSpec(root: string, taskId: string, slug: string, body: string): void {\n  const dir = paths.specsDir(root);\n  const file = paths.specFile(root, taskId, slug);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `---\ntaskId: ${taskId}\nslug: ${slug}\n---\n\n${body}`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write plan artifact to .noir/plans/<taskId>-<slug>.md\n */\nexport function writePlan(root: string, taskId: string, slug: string, body: string): void {\n  const dir = paths.plansDir(root);\n  const file = paths.planFile(root, taskId, slug);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `---\ntaskId: ${taskId}\nslug: ${slug}\n---\n\n${body}`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write task artifact to .noir/tasks/<taskId>-<taskName>.md\n */\nexport function writeTask(root: string, taskId: string, taskName: string, body: string): void {\n  const dir = paths.tasksDir(root);\n  const file = paths.taskFile(root, taskId, taskName);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `---\ntaskId: ${taskId}\ntask: ${taskName}\n---\n\n${body}`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write decision stub to .noir/decisions/<n>.md\n */\nexport function writeDecisionStub(root: string, n: number, title: string): void {\n  const dir = paths.decisionsDir(root);\n  const file = paths.decisionFile(root, n);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `# ${title}\n\n*Decision record ${n}*\n\n<!-- Status: pending -->\n`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write changelog stub entry to .noir/CHANGELOG.md\n */\nexport function writeChangelogStub(root: string, entry: string): void {\n  const file = join(root, '.noir', 'CHANGELOG.md');\n\n  // Create directory if it doesn't exist\n  mkdirSync(join(root, '.noir'), { recursive: true });\n\n  let content: string;\n  if (existsSync(file)) {\n    // Append: read existing content and add the new entry on its own line,\n    // preserving the header and all prior entries.\n    const existing = readFileSync(file, 'utf-8');\n    const prefix = existing.endsWith('\\n') ? existing : `${existing}\\n`;\n    content = `${prefix}${entry}\\n`;\n  } else {\n    content = `# Changelog\n\n${entry}\n`;\n  }\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write audit export to .noir/audit/<taskId>.json\n * Exports GateResult array as JSON\n */\nexport function writeAuditExport(root: string, taskId: string, results: GateResult[]): void {\n  const dir = paths.auditDir(root);\n  const file = paths.auditFile(root, taskId);\n\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(file, JSON.stringify(results, null, 2), 'utf-8');\n}\n","import type { Store } from '@noir-ai/store';\nimport type { GateResult, Phase, WorkflowState } from './types.js';\n\n/**\n * The workflow state a phase's gate guards entry into (Noir §9.1 observable\n * checkpoint). A gate fires when its phase completes:\n *   spec-gate   → entering `specified`\n *   plan-gate   → entering `planned`\n *   verify-gate → entering `done`\n *\n * Phases without a gate (intake / clarify / execute / document) return `null`.\n * This is distinct from {@link stateForPhase}: `stateForPhase('verify')` is the\n * in-progress `verifying`, while `gateFor('verify')` is the state the verify\n * gate admits you into (`done`).\n */\nexport function gateFor(phase: Phase): WorkflowState | null {\n  switch (phase) {\n    case 'spec':\n      return 'specified';\n    case 'plan':\n      return 'planned';\n    case 'verify':\n      return 'done';\n    default:\n      return null;\n  }\n}\n\n/**\n * Append a gate decision to the task's audit log in the store KV.\n *\n * The audit lives at `audit:<taskId>` as a `GateResult[]` and is the source of\n * truth for every gate outcome (the `.noir/audit/` export is a later helper).\n * This is the \"quiet observable checkpoint\": an `approved`, `forced`, or\n * `skipped` decision is always recorded — never silently dropped — and `forced`\n * carries a `reason`.\n *\n * `at` is stamped here (`Date.now()`) rather than trusted from the caller, so\n * the audit reflects when the gate actually fired. The write is append-only:\n * prior entries are read and preserved (never overwritten).\n */\nexport function recordGate(store: Store, taskId: string, result: GateResult): void {\n  const key = `audit:${taskId}`;\n  const prior = store.getState<GateResult[]>(key) ?? [];\n  store.setState<GateResult[]>(key, [...prior, { ...result, at: Date.now() }]);\n}\n","import type { ProjectId } from '@noir-ai/core';\n\nexport const PHASES = [\n  'intake',\n  'clarify',\n  'spec',\n  'plan',\n  'execute',\n  'verify',\n  'document',\n] as const;\nexport type Phase = (typeof PHASES)[number];\n\nexport const STATES = [\n  'draft',\n  'clarifying',\n  'specified',\n  'planned',\n  'executing',\n  'verifying',\n  'done',\n  'blocked',\n  'abandoned',\n] as const;\nexport type WorkflowState = (typeof STATES)[number];\n\nexport type Mode = 'full' | 'quick';\n\nexport interface GateResult {\n  phase: Phase;\n  decision: 'approved' | 'forced' | 'skipped';\n  reason?: string;\n  at: number;\n}\n\nexport interface TaskState {\n  taskId: string;\n  slug: string;\n  projectId: ProjectId;\n  state: WorkflowState;\n  phase: Phase;\n  mode: Mode;\n  history: GateResult[]; // gate decisions (audit in-process view)\n  jumpEntry?: Phase; // recorded if a jump-to-phase happened\n  /** Reason captured by `setBlocked` (admin escape; set directly, not via FSM). */\n  blockReason?: string;\n  updatedAt: number;\n}\n","import type { Phase, WorkflowState } from './types.js';\n\n// Re-export the phase/state vocabularies so consumers can import the entire FSM\n// surface from one module (the test imports PHASES/STATES from here).\nexport { PHASES, STATES } from './types.js';\n\n// Legal state transitions (happy path + terminal). Gates (spec/plan/verify) are\n// modeled as the transition INTO specified/planned/done — the engine records a\n// GateResult at that point (see gates.ts).\nconst TRANSITIONS: Record<WorkflowState, WorkflowState[]> = {\n  draft: ['clarifying'],\n  clarifying: ['specified'],\n  specified: ['planned'],\n  planned: ['executing'],\n  executing: ['verifying'],\n  verifying: ['done'],\n  done: [],\n  blocked: ['draft', 'clarifying', 'specified', 'planned', 'executing', 'verifying'],\n  abandoned: [],\n};\n\nexport function canTransition(from: WorkflowState, to: WorkflowState): boolean {\n  return (TRANSITIONS[from] ?? []).includes(to);\n}\n\nexport function applyTransition(from: WorkflowState, to: WorkflowState): WorkflowState {\n  if (!canTransition(from, to)) {\n    const hint =\n      to === 'planned'\n        ? ' (the spec gate must be passed first)'\n        : to === 'executing'\n          ? ' (the plan gate must be passed first)'\n          : to === 'done'\n            ? ' (the verify gate must be passed first)'\n            : '';\n    throw new Error(`Illegal transition ${from} → ${to}${hint}`);\n  }\n  return to;\n}\n\n// Phase <-> state mapping for the engine.\nexport function stateForPhase(p: Phase): WorkflowState {\n  switch (p) {\n    case 'intake':\n      return 'draft';\n    case 'clarify':\n      return 'clarifying';\n    case 'spec':\n      return 'specified';\n    case 'plan':\n      return 'planned';\n    case 'execute':\n      return 'executing';\n    case 'verify':\n      return 'verifying';\n    case 'document':\n      return 'done';\n  }\n}\n\nexport function nextPhase(state: WorkflowState): Phase | null {\n  const map: Partial<Record<WorkflowState, Phase>> = {\n    draft: 'clarify',\n    clarifying: 'spec',\n    specified: 'plan',\n    planned: 'execute',\n    executing: 'verify',\n    verifying: 'document',\n  };\n  return map[state] ?? null;\n}\n","import type { ProjectId } from '@noir-ai/core';\nimport type { Store } from '@noir-ai/store';\nimport { gateFor, recordGate } from './gates.js';\nimport { applyTransition, nextPhase, stateForPhase } from './state-machine.js';\nimport type { GateResult, Mode, Phase, TaskState, WorkflowState } from './types.js';\n\n/**\n * Store KV layout (single source of truth for machine state):\n *   workflow:active   → taskId of the most recently started task\n *   workflow:<taskId> → TaskState (JSON)\n * Audit decisions live at `audit:<taskId>` (see {@link recordGate}).\n */\nconst ACTIVE_KEY = 'workflow:active';\nconst GATE_PHASES = ['spec', 'plan', 'verify'] as const satisfies ReadonlyArray<Phase>;\n\n/** Options for {@link WorkflowEngine.advance}. */\nexport interface AdvanceOpts {\n  /**\n   * Pass a gate without satisfying its criteria. Requires a non-empty `reason`\n   * (validated here, in the engine — `recordGate` is policy-free). The landing\n   * gate, if any, is recorded with `decision: 'forced'`. Mutually exclusive\n   * with {@link skip}.\n   */\n  force?: { reason?: string };\n  /**\n   * Jump directly to a phase, bypassing the FSM (the escape hatch for blocked /\n   * out-of-order resumption). The landing is recorded as `jumpEntry` on the\n   * TaskState; a landing gate-state (specified/planned/done) still records its\n   * gate so the observable-checkpoint invariant holds.\n   */\n  to?: Phase;\n  /**\n   * Quick-mode: record the landing gate (if any) as `decision: 'skipped'`\n   * instead of `approved`. The gate is still RECORDED — never silently dropped\n   * (Noir §9.1 observable-checkpoint invariant) — only the decision changes.\n   * Mutually exclusive with {@link force}.\n   */\n  skip?: true;\n}\n\n/**\n * The phase whose gate admits entry into `state` (the inverse of {@link gateFor}).\n *\n * The verify gate fires on entering `done` — but `done` is `stateForPhase('document')`,\n * so the target *phase* of that transition is `document`, not `verify`. The gate\n * must therefore be looked up from the target *state*, not the target phase.\n */\nfunction gatePhaseForState(state: WorkflowState): Phase | null {\n  for (const p of GATE_PHASES) {\n    if (gateFor(p) === state) return p;\n  }\n  return null;\n}\n\n/**\n * WorkflowEngine — drives an SDD task through its lifecycle.\n *\n * The engine is a thin orchestrator over three T1–T3 primitives:\n *   • the hand-rolled FSM ({@link applyTransition}) for legal forward moves,\n *   • {@link recordGate} for observable checkpoint audit, and\n *   • the store KV for persisted {@link TaskState}.\n *\n * Policy that did not belong in T1/T2 lives here:\n *   • `--force` requires a non-empty reason (validated before any gate write),\n *   • `blocked` / `abandoned` have no incoming FSM edges and are set directly,\n *   • `opts.to` jumps past FSM edges and is recorded via `jumpEntry`.\n *\n * Modes (Full/Quick) and cross-session resume are T5; MCP tools are T6 — the\n * engine stays mode-agnostic here and only stores `mode` on the TaskState.\n */\nexport class WorkflowEngine {\n  constructor(\n    private readonly store: Store,\n    /**\n     * Project root — the engine is constructed with it so modes (quickPath\n     * writes a spec stub via {@link writeSpec}) and future artifact flushes\n     * (checkpoint/audit export) are self-contained. Public so the modes module\n     * can pass it to {@link ArtifactWriter}.\n     */\n    readonly root: string,\n    private readonly projectId: ProjectId,\n  ) {}\n\n  /**\n   * Create a new task at draft/intake, persist it, and point `workflow:active`\n   * at it. Re-starting an existing taskId overwrites it (intentional — the KV is\n   * the source of truth, not a journal).\n   */\n  async startTask(taskId: string, slug: string, mode: Mode): Promise<TaskState> {\n    const task: TaskState = {\n      taskId,\n      slug,\n      projectId: this.projectId,\n      state: 'draft',\n      phase: 'intake',\n      mode,\n      history: [],\n      updatedAt: Date.now(),\n    };\n    this.persist(task);\n    this.store.setState<string>(ACTIVE_KEY, taskId);\n    return task;\n  }\n\n  /**\n   * Advance `taskId` to its next phase, or jump with `opts.to`.\n   *\n   * At a gate-landing state (entering `specified` / `planned` / `done`) a\n   * {@link GateResult} is recorded — `approved` by default, `forced` (with the\n   * reason) when `opts.force` is supplied, or `skipped` when `opts.skip` is\n   * supplied (quick mode). `force` and `skip` are mutually exclusive. Jumps\n   * bypass the FSM and additionally stamp `jumpEntry`.\n   */\n  async advance(taskId: string, opts?: AdvanceOpts): Promise<TaskState> {\n    const task = this.requireTask(taskId);\n\n    // Policy: --force and skip are mutually exclusive gate decisions (a gate\n    // can't be both forced AND skipped). Validated BEFORE any gate write so a\n    // bad combination never leaves a partial audit trail behind.\n    if (opts?.force && opts?.skip) {\n      throw new Error('cannot combine --force and skip');\n    }\n    // Policy: --force requires a non-empty reason.\n    if (opts?.force && !opts.force.reason?.trim()) {\n      throw new Error('--force requires a reason');\n    }\n\n    const jump = opts?.to !== undefined;\n    const targetPhase: Phase = jump ? (opts?.to as Phase) : this.nextPhaseOf(task);\n\n    const targetState = stateForPhase(targetPhase);\n    if (!jump) {\n      // applyTransition surfaces the FSM's gate hint on illegal moves.\n      applyTransition(task.state, targetState);\n    }\n\n    // Observable checkpoint: entering specified/planned/done always records a\n    // gate — looked up from the target STATE (see gatePhaseForState).\n    const gatePhase = gatePhaseForState(targetState);\n    if (gatePhase !== null) {\n      const decision = opts?.force ? 'forced' : opts?.skip ? 'skipped' : 'approved';\n      const gate: GateResult = {\n        phase: gatePhase,\n        decision,\n        // exactOptionalPropertyTypes is false; spread reason only when forced.\n        ...(opts?.force ? { reason: opts.force.reason } : {}),\n        at: Date.now(),\n      };\n      recordGate(this.store, taskId, gate);\n      task.history.push(gate);\n    }\n\n    task.state = targetState;\n    task.phase = targetPhase;\n    if (jump) task.jumpEntry = targetPhase;\n    task.updatedAt = Date.now();\n\n    this.persist(task);\n    return task;\n  }\n\n  /** Read the persisted TaskState, or null if the task is unknown. */\n  status(taskId: string): TaskState | null {\n    return this.store.getState<TaskState>(workflowKey(taskId));\n  }\n\n  /**\n   * The taskId of the most-recently-started task (`workflow:active` in the\n   * store KV), or `null` when no task has been started yet. Lets the MCP\n   * `workflow_status` / `checkpoint` tools omit `taskId` and operate on the\n   * active task.\n   */\n  activeTaskId(): string | null {\n    return this.store.getState<string>(ACTIVE_KEY);\n  }\n\n  /**\n   * Re-flush the current state to KV. In T4 every advance already persists, so\n   * this is the explicit \"mark a checkpoint\" hook (bumps `updatedAt`); T5\n   * deepens it to flush artifacts + audit export for cross-session resume.\n   */\n  async checkpoint(taskId: string): Promise<void> {\n    const task = this.store.getState<TaskState>(workflowKey(taskId));\n    if (!task) throw new Error(`Unknown task: ${taskId}`);\n    task.updatedAt = Date.now();\n    this.persist(task);\n  }\n\n  /**\n   * Set state directly to `blocked` (no FSM edge — the admin escape). The reason\n   * is captured on the TaskState for surfacing in `noir.workflow_status`.\n   */\n  async setBlocked(taskId: string, reason?: string): Promise<TaskState> {\n    const task = this.requireTask(taskId);\n    task.state = 'blocked';\n    if (reason) task.blockReason = reason;\n    task.updatedAt = Date.now();\n    this.persist(task);\n    return task;\n  }\n\n  /** Set state directly to `abandoned` (terminal; no FSM edge). */\n  async abandon(taskId: string): Promise<TaskState> {\n    const task = this.requireTask(taskId);\n    task.state = 'abandoned';\n    task.updatedAt = Date.now();\n    this.persist(task);\n    return task;\n  }\n\n  private nextPhaseOf(task: TaskState): Phase {\n    const next = nextPhase(task.state);\n    if (next === null) {\n      throw new Error(`No next phase from state ${task.state}`);\n    }\n    return next;\n  }\n\n  private requireTask(taskId: string): TaskState {\n    const task = this.store.getState<TaskState>(workflowKey(taskId));\n    if (!task) throw new Error(`Unknown task: ${taskId}`);\n    return task;\n  }\n\n  private persist(task: TaskState): void {\n    this.store.setState<TaskState>(workflowKey(task.taskId), task);\n  }\n}\n\nfunction workflowKey(taskId: string): string {\n  return `workflow:${taskId}`;\n}\n","import type { Store } from '@noir-ai/store';\nimport { writeSpec } from './artifacts.js';\nimport type { WorkflowEngine } from './engine.js';\nimport type { TaskState, WorkflowState } from './types.js';\n\n/**\n * Default spec body written by {@link runQuick}. Quick mode is \"discipline\n * lite\": the spec is stubbed (the spec + plan gates are skipped), but a real\n * spec file still lands on disk so later phases (and humans) have something to\n * read. Exported so callers/tests can assert on the canonical stub text.\n */\nexport const QUICK_SPEC_STUB = '<quick-mode stub spec>';\n\n/** Options for {@link runQuick}. */\nexport interface QuickOpts {\n  /**\n   * Override the stub spec body (defaults to {@link QUICK_SPEC_STUB}). Useful\n   * when a quick task already has a one-line description worth persisting.\n   */\n  specBody?: string;\n}\n\n/**\n * Quick mode — the fast path for small / spike tasks.\n *\n * Writes a stub spec to `.noir/specs/<taskId>-<slug>.md` (via\n * {@link writeSpec}) and fast-forwards the task from `draft` to `executing`,\n * recording the spec and plan gates as `decision: 'skipped'`. The verify gate\n * is intentionally LEFT alone — it still fires as `approved` when the task\n * later reaches `done`, providing the one real checkpoint (discipline lite).\n *\n * The task must already be started (`engine.startTask(..., 'quick')`); this\n * function reads the slug from the persisted TaskState. Skipped gates are\n * RECORDED (Noir §9.1 observable-checkpoint invariant), never silently dropped\n * — the audit KV and `history` both carry the `skipped` entries.\n */\nexport async function runQuick(\n  engine: WorkflowEngine,\n  taskId: string,\n  opts?: QuickOpts,\n): Promise<TaskState> {\n  const task = engine.status(taskId);\n  if (!task) throw new Error(`Unknown task: ${taskId}`);\n\n  // Flush the stub spec first so the artifact exists before any gate fires.\n  writeSpec(engine.root, taskId, task.slug, opts?.specBody ?? QUICK_SPEC_STUB);\n\n  // draft → clarifying → specified (spec gate SKIPPED) → planned (plan gate\n  // SKIPPED) → executing. Verify is left for the normal flow (runs as approved).\n  await engine.advance(taskId); // draft → clarifying (no gate)\n  await engine.advance(taskId, { skip: true }); // → specified (spec gate skipped)\n  await engine.advance(taskId, { skip: true }); // → planned (plan gate skipped)\n  return engine.advance(taskId); // → executing (no gate) — land here\n}\n\n/** Terminal states with nothing left to resume. `blocked` is NOT terminal. */\nconst TERMINAL_STATES: ReadonlySet<WorkflowState> = new Set<WorkflowState>(['done', 'abandoned']);\n\n/**\n * Reconstruct the in-flight TaskState across a session break.\n *\n * Reads `workflow:active` from the store KV → the most-recently-started\n * taskId (T4 semantics; v1 is one-task-per-project) → the persisted\n * `workflow:<taskId>` TaskState. Returns `null` when there is no active task,\n * the task record is missing, or the active task is terminal (`done` /\n * `abandoned` — nothing to resume). A `blocked` task IS resumable.\n *\n * Uses only the public {@link Store} API, so a freshly-`openStore`'d handle\n * against the same on-disk DB is sufficient (no live engine required).\n */\nexport async function resumeTask(store: Store): Promise<TaskState | null> {\n  const activeId = store.getState<string>('workflow:active');\n  if (!activeId) return null;\n\n  const task = store.getState<TaskState>(`workflow:${activeId}`);\n  if (!task) return null;\n  if (TERMINAL_STATES.has(task.state)) return null;\n\n  return task;\n}\n"],"mappings":";AAAA,SAAS,YAAY,WAAW,cAAc,qBAAqB;AACnE,SAAS,YAAY;AACrB,SAAS,aAAa;AAMf,SAAS,YAAY,MAAc,QAAgB,SAAuB;AAC/E,QAAM,MAAM,KAAK,MAAM,SAAS,QAAQ;AACxC,QAAM,OAAO,KAAK,KAAK,GAAG,MAAM,KAAK;AAErC,YAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AAClC,gBAAc,MAAM,SAAS,OAAO;AACtC;AAMO,SAAS,UAAU,MAAc,QAAgB,MAAc,MAAoB;AACxF,QAAM,MAAM,MAAM,SAAS,IAAI;AAC/B,QAAM,OAAO,MAAM,SAAS,MAAM,QAAQ,IAAI;AAE9C,YAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AAElC,QAAM,UAAU;AAAA,UACR,MAAM;AAAA,QACR,IAAI;AAAA;AAAA;AAAA,EAGV,IAAI;AAEJ,gBAAc,MAAM,SAAS,OAAO;AACtC;AAKO,SAAS,UAAU,MAAc,QAAgB,MAAc,MAAoB;AACxF,QAAM,MAAM,MAAM,SAAS,IAAI;AAC/B,QAAM,OAAO,MAAM,SAAS,MAAM,QAAQ,IAAI;AAE9C,YAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AAElC,QAAM,UAAU;AAAA,UACR,MAAM;AAAA,QACR,IAAI;AAAA;AAAA;AAAA,EAGV,IAAI;AAEJ,gBAAc,MAAM,SAAS,OAAO;AACtC;AAKO,SAAS,UAAU,MAAc,QAAgB,UAAkB,MAAoB;AAC5F,QAAM,MAAM,MAAM,SAAS,IAAI;AAC/B,QAAM,OAAO,MAAM,SAAS,MAAM,QAAQ,QAAQ;AAElD,YAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AAElC,QAAM,UAAU;AAAA,UACR,MAAM;AAAA,QACR,QAAQ;AAAA;AAAA;AAAA,EAGd,IAAI;AAEJ,gBAAc,MAAM,SAAS,OAAO;AACtC;AAKO,SAAS,kBAAkB,MAAc,GAAW,OAAqB;AAC9E,QAAM,MAAM,MAAM,aAAa,IAAI;AACnC,QAAM,OAAO,MAAM,aAAa,MAAM,CAAC;AAEvC,YAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AAElC,QAAM,UAAU,KAAK,KAAK;AAAA;AAAA,mBAET,CAAC;AAAA;AAAA;AAAA;AAKlB,gBAAc,MAAM,SAAS,OAAO;AACtC;AAKO,SAAS,mBAAmB,MAAc,OAAqB;AACpE,QAAM,OAAO,KAAK,MAAM,SAAS,cAAc;AAG/C,YAAU,KAAK,MAAM,OAAO,GAAG,EAAE,WAAW,KAAK,CAAC;AAElD,MAAI;AACJ,MAAI,WAAW,IAAI,GAAG;AAGpB,UAAM,WAAW,aAAa,MAAM,OAAO;AAC3C,UAAM,SAAS,SAAS,SAAS,IAAI,IAAI,WAAW,GAAG,QAAQ;AAAA;AAC/D,cAAU,GAAG,MAAM,GAAG,KAAK;AAAA;AAAA,EAC7B,OAAO;AACL,cAAU;AAAA;AAAA,EAEZ,KAAK;AAAA;AAAA,EAEL;AAEA,gBAAc,MAAM,SAAS,OAAO;AACtC;AAMO,SAAS,iBAAiB,MAAc,QAAgB,SAA6B;AAC1F,QAAM,MAAM,MAAM,SAAS,IAAI;AAC/B,QAAM,OAAO,MAAM,UAAU,MAAM,MAAM;AAEzC,YAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AAClC,gBAAc,MAAM,KAAK,UAAU,SAAS,MAAM,CAAC,GAAG,OAAO;AAC/D;;;AClHO,SAAS,QAAQ,OAAoC;AAC1D,UAAQ,OAAO;AAAA,IACb,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT;AACE,aAAO;AAAA,EACX;AACF;AAeO,SAAS,WAAW,OAAc,QAAgB,QAA0B;AACjF,QAAM,MAAM,SAAS,MAAM;AAC3B,QAAM,QAAQ,MAAM,SAAuB,GAAG,KAAK,CAAC;AACpD,QAAM,SAAuB,KAAK,CAAC,GAAG,OAAO,EAAE,GAAG,QAAQ,IAAI,KAAK,IAAI,EAAE,CAAC,CAAC;AAC7E;;;AC3CO,IAAM,SAAS;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAGO,IAAM,SAAS;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;;;ACdA,IAAM,cAAsD;AAAA,EAC1D,OAAO,CAAC,YAAY;AAAA,EACpB,YAAY,CAAC,WAAW;AAAA,EACxB,WAAW,CAAC,SAAS;AAAA,EACrB,SAAS,CAAC,WAAW;AAAA,EACrB,WAAW,CAAC,WAAW;AAAA,EACvB,WAAW,CAAC,MAAM;AAAA,EAClB,MAAM,CAAC;AAAA,EACP,SAAS,CAAC,SAAS,cAAc,aAAa,WAAW,aAAa,WAAW;AAAA,EACjF,WAAW,CAAC;AACd;AAEO,SAAS,cAAc,MAAqB,IAA4B;AAC7E,UAAQ,YAAY,IAAI,KAAK,CAAC,GAAG,SAAS,EAAE;AAC9C;AAEO,SAAS,gBAAgB,MAAqB,IAAkC;AACrF,MAAI,CAAC,cAAc,MAAM,EAAE,GAAG;AAC5B,UAAM,OACJ,OAAO,YACH,0CACA,OAAO,cACL,0CACA,OAAO,SACL,4CACA;AACV,UAAM,IAAI,MAAM,sBAAsB,IAAI,WAAM,EAAE,GAAG,IAAI,EAAE;AAAA,EAC7D;AACA,SAAO;AACT;AAGO,SAAS,cAAc,GAAyB;AACrD,UAAQ,GAAG;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,EACX;AACF;AAEO,SAAS,UAAU,OAAoC;AAC5D,QAAM,MAA6C;AAAA,IACjD,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,WAAW;AAAA,IACX,SAAS;AAAA,IACT,WAAW;AAAA,IACX,WAAW;AAAA,EACb;AACA,SAAO,IAAI,KAAK,KAAK;AACvB;;;AC1DA,IAAM,aAAa;AACnB,IAAM,cAAc,CAAC,QAAQ,QAAQ,QAAQ;AAkC7C,SAAS,kBAAkB,OAAoC;AAC7D,aAAW,KAAK,aAAa;AAC3B,QAAI,QAAQ,CAAC,MAAM,MAAO,QAAO;AAAA,EACnC;AACA,SAAO;AACT;AAkBO,IAAM,iBAAN,MAAqB;AAAA,EAC1B,YACmB,OAOR,MACQ,WACjB;AATiB;AAOR;AACQ;AAAA,EAChB;AAAA,EATgB;AAAA,EAOR;AAAA,EACQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQnB,MAAM,UAAU,QAAgB,MAAc,MAAgC;AAC5E,UAAM,OAAkB;AAAA,MACtB;AAAA,MACA;AAAA,MACA,WAAW,KAAK;AAAA,MAChB,OAAO;AAAA,MACP,OAAO;AAAA,MACP;AAAA,MACA,SAAS,CAAC;AAAA,MACV,WAAW,KAAK,IAAI;AAAA,IACtB;AACA,SAAK,QAAQ,IAAI;AACjB,SAAK,MAAM,SAAiB,YAAY,MAAM;AAC9C,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAM,QAAQ,QAAgB,MAAwC;AACpE,UAAM,OAAO,KAAK,YAAY,MAAM;AAKpC,QAAI,MAAM,SAAS,MAAM,MAAM;AAC7B,YAAM,IAAI,MAAM,iCAAiC;AAAA,IACnD;AAEA,QAAI,MAAM,SAAS,CAAC,KAAK,MAAM,QAAQ,KAAK,GAAG;AAC7C,YAAM,IAAI,MAAM,2BAA2B;AAAA,IAC7C;AAEA,UAAM,OAAO,MAAM,OAAO;AAC1B,UAAM,cAAqB,OAAQ,MAAM,KAAe,KAAK,YAAY,IAAI;AAE7E,UAAM,cAAc,cAAc,WAAW;AAC7C,QAAI,CAAC,MAAM;AAET,sBAAgB,KAAK,OAAO,WAAW;AAAA,IACzC;AAIA,UAAM,YAAY,kBAAkB,WAAW;AAC/C,QAAI,cAAc,MAAM;AACtB,YAAM,WAAW,MAAM,QAAQ,WAAW,MAAM,OAAO,YAAY;AACnE,YAAM,OAAmB;AAAA,QACvB,OAAO;AAAA,QACP;AAAA;AAAA,QAEA,GAAI,MAAM,QAAQ,EAAE,QAAQ,KAAK,MAAM,OAAO,IAAI,CAAC;AAAA,QACnD,IAAI,KAAK,IAAI;AAAA,MACf;AACA,iBAAW,KAAK,OAAO,QAAQ,IAAI;AACnC,WAAK,QAAQ,KAAK,IAAI;AAAA,IACxB;AAEA,SAAK,QAAQ;AACb,SAAK,QAAQ;AACb,QAAI,KAAM,MAAK,YAAY;AAC3B,SAAK,YAAY,KAAK,IAAI;AAE1B,SAAK,QAAQ,IAAI;AACjB,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,QAAkC;AACvC,WAAO,KAAK,MAAM,SAAoB,YAAY,MAAM,CAAC;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,eAA8B;AAC5B,WAAO,KAAK,MAAM,SAAiB,UAAU;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,WAAW,QAA+B;AAC9C,UAAM,OAAO,KAAK,MAAM,SAAoB,YAAY,MAAM,CAAC;AAC/D,QAAI,CAAC,KAAM,OAAM,IAAI,MAAM,iBAAiB,MAAM,EAAE;AACpD,SAAK,YAAY,KAAK,IAAI;AAC1B,SAAK,QAAQ,IAAI;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,WAAW,QAAgB,QAAqC;AACpE,UAAM,OAAO,KAAK,YAAY,MAAM;AACpC,SAAK,QAAQ;AACb,QAAI,OAAQ,MAAK,cAAc;AAC/B,SAAK,YAAY,KAAK,IAAI;AAC1B,SAAK,QAAQ,IAAI;AACjB,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,MAAM,QAAQ,QAAoC;AAChD,UAAM,OAAO,KAAK,YAAY,MAAM;AACpC,SAAK,QAAQ;AACb,SAAK,YAAY,KAAK,IAAI;AAC1B,SAAK,QAAQ,IAAI;AACjB,WAAO;AAAA,EACT;AAAA,EAEQ,YAAY,MAAwB;AAC1C,UAAM,OAAO,UAAU,KAAK,KAAK;AACjC,QAAI,SAAS,MAAM;AACjB,YAAM,IAAI,MAAM,4BAA4B,KAAK,KAAK,EAAE;AAAA,IAC1D;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,YAAY,QAA2B;AAC7C,UAAM,OAAO,KAAK,MAAM,SAAoB,YAAY,MAAM,CAAC;AAC/D,QAAI,CAAC,KAAM,OAAM,IAAI,MAAM,iBAAiB,MAAM,EAAE;AACpD,WAAO;AAAA,EACT;AAAA,EAEQ,QAAQ,MAAuB;AACrC,SAAK,MAAM,SAAoB,YAAY,KAAK,MAAM,GAAG,IAAI;AAAA,EAC/D;AACF;AAEA,SAAS,YAAY,QAAwB;AAC3C,SAAO,YAAY,MAAM;AAC3B;;;AC5NO,IAAM,kBAAkB;AAyB/B,eAAsB,SACpB,QACA,QACA,MACoB;AACpB,QAAM,OAAO,OAAO,OAAO,MAAM;AACjC,MAAI,CAAC,KAAM,OAAM,IAAI,MAAM,iBAAiB,MAAM,EAAE;AAGpD,YAAU,OAAO,MAAM,QAAQ,KAAK,MAAM,MAAM,YAAY,eAAe;AAI3E,QAAM,OAAO,QAAQ,MAAM;AAC3B,QAAM,OAAO,QAAQ,QAAQ,EAAE,MAAM,KAAK,CAAC;AAC3C,QAAM,OAAO,QAAQ,QAAQ,EAAE,MAAM,KAAK,CAAC;AAC3C,SAAO,OAAO,QAAQ,MAAM;AAC9B;AAGA,IAAM,kBAA8C,oBAAI,IAAmB,CAAC,QAAQ,WAAW,CAAC;AAchG,eAAsB,WAAW,OAAyC;AACxE,QAAM,WAAW,MAAM,SAAiB,iBAAiB;AACzD,MAAI,CAAC,SAAU,QAAO;AAEtB,QAAM,OAAO,MAAM,SAAoB,YAAY,QAAQ,EAAE;AAC7D,MAAI,CAAC,KAAM,QAAO;AAClB,MAAI,gBAAgB,IAAI,KAAK,KAAK,EAAG,QAAO;AAE5C,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/artifacts.ts","../src/gates.ts","../src/types.ts","../src/state-machine.ts","../src/engine.ts","../src/modes.ts"],"sourcesContent":["import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { paths } from '@noir-ai/core';\nimport type { GateResult } from './types.js';\n\n/**\n * Write intake artifact to .noir/intake/<taskId>.md\n */\nexport function writeIntake(root: string, taskId: string, content: string): void {\n  const dir = join(root, '.noir', 'intake');\n  const file = join(dir, `${taskId}.md`);\n\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write spec artifact to .noir/specs/<taskId>-<slug>.md\n * Creates markdown with frontmatter and body\n */\nexport function writeSpec(root: string, taskId: string, slug: string, body: string): void {\n  const dir = paths.specsDir(root);\n  const file = paths.specFile(root, taskId, slug);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `---\ntaskId: ${taskId}\nslug: ${slug}\n---\n\n${body}`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write PRD artifact to .noir/prd/<taskId>-<slug>.md\n * Pre-SDD product document; the spec @imports it (prdRef). No FSM change.\n */\nexport function writePrd(root: string, taskId: string, slug: string, body: string): void {\n  const dir = paths.prdDir(root);\n  const file = paths.prdFile(root, taskId, slug);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `---\ntaskId: ${taskId}\nslug: ${slug}\n---\n\n${body}`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/** Read a PRD artifact, or null if absent. */\nexport function readPrd(root: string, taskId: string, slug: string): string | null {\n  const file = paths.prdFile(root, taskId, slug);\n  if (!existsSync(file)) return null;\n  return readFileSync(file, 'utf-8');\n}\n\n/**\n * Write plan artifact to .noir/plans/<taskId>-<slug>.md\n */\nexport function writePlan(root: string, taskId: string, slug: string, body: string): void {\n  const dir = paths.plansDir(root);\n  const file = paths.planFile(root, taskId, slug);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `---\ntaskId: ${taskId}\nslug: ${slug}\n---\n\n${body}`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write task artifact to .noir/tasks/<taskId>-<taskName>.md\n */\nexport function writeTask(root: string, taskId: string, taskName: string, body: string): void {\n  const dir = paths.tasksDir(root);\n  const file = paths.taskFile(root, taskId, taskName);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `---\ntaskId: ${taskId}\ntask: ${taskName}\n---\n\n${body}`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write decision stub to .noir/decisions/<n>.md\n */\nexport function writeDecisionStub(root: string, n: number, title: string): void {\n  const dir = paths.decisionsDir(root);\n  const file = paths.decisionFile(root, n);\n\n  mkdirSync(dir, { recursive: true });\n\n  const content = `# ${title}\n\n*Decision record ${n}*\n\n<!-- Status: pending -->\n`;\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write changelog stub entry to .noir/CHANGELOG.md\n */\nexport function writeChangelogStub(root: string, entry: string): void {\n  const file = join(root, '.noir', 'CHANGELOG.md');\n\n  // Create directory if it doesn't exist\n  mkdirSync(join(root, '.noir'), { recursive: true });\n\n  let content: string;\n  if (existsSync(file)) {\n    // Append: read existing content and add the new entry on its own line,\n    // preserving the header and all prior entries.\n    const existing = readFileSync(file, 'utf-8');\n    const prefix = existing.endsWith('\\n') ? existing : `${existing}\\n`;\n    content = `${prefix}${entry}\\n`;\n  } else {\n    content = `# Changelog\n\n${entry}\n`;\n  }\n\n  writeFileSync(file, content, 'utf-8');\n}\n\n/**\n * Write audit export to .noir/audit/<taskId>.json\n * Exports GateResult array as JSON\n */\nexport function writeAuditExport(root: string, taskId: string, results: GateResult[]): void {\n  const dir = paths.auditDir(root);\n  const file = paths.auditFile(root, taskId);\n\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(file, JSON.stringify(results, null, 2), 'utf-8');\n}\n","import type { Store } from '@noir-ai/store';\nimport type { GateResult, GateResultInput, Phase, WorkflowState } from './types.js';\n\n/**\n * The workflow state a phase's gate guards entry into (Noir §9.1 observable\n * checkpoint). A gate fires when its phase completes:\n *   spec-gate   → entering `specified`\n *   plan-gate   → entering `planned`\n *   verify-gate → entering `done`\n *\n * Phases without a gate (intake / clarify / execute / document) return `null`.\n * This is distinct from {@link stateForPhase}: `stateForPhase('verify')` is the\n * in-progress `verifying`, while `gateFor('verify')` is the state the verify\n * gate admits you into (`done`).\n */\nexport function gateFor(phase: Phase): WorkflowState | null {\n  switch (phase) {\n    case 'spec':\n      return 'specified';\n    case 'plan':\n      return 'planned';\n    case 'verify':\n      return 'done';\n    default:\n      return null;\n  }\n}\n\n/**\n * Append a gate decision to the task's audit log in the store KV.\n *\n * The audit lives at `audit:<taskId>` as a `GateResult[]` and is the\n * AUTHORITATIVE record for every gate outcome (S4 spec §5 / §11 OQ-5 — \"audit\n * in store KV as source of truth + export to `.noir/audit/<taskId>.json`\").\n * The {@link TaskState.history} field is a DERIVED view, regenerated from this\n * KV by the engine — never edited directly. This collapses the S4 dual source\n * of truth (debt-batch A / W1): one write, one timestamp, one read-back.\n *\n * This is the \"quiet observable checkpoint\": an `approved`, `forced`, or\n * `skipped` decision is always recorded — never silently dropped — and `forced`\n * carries a `reason`.\n *\n * `at` is stamped here (`Date.now()`) rather than trusted from the caller, so\n * the audit reflects when the gate actually fired (single timestamp — the W3\n * sub-ms drift between the engine's history stamp and the audit KV stamp is\n * gone, because there is no longer a second stamp). The write is append-only:\n * prior entries are read and preserved (never overwritten).\n */\nexport function recordGate(store: Store, taskId: string, result: GateResultInput): GateResult {\n  const key = `audit:${taskId}`;\n  const prior = store.getState<GateResult[]>(key) ?? [];\n  const recorded: GateResult = { ...result, at: Date.now() };\n  store.setState<GateResult[]>(key, [...prior, recorded]);\n  return recorded;\n}\n\n/**\n * Read the authoritative gate audit for `taskId` from the store KV. Returns an\n * empty array when no gate has fired yet (a fresh task) — never `null`, so\n * callers can spread/index without a separate undefined check.\n *\n * The engine uses this to regenerate {@link TaskState.history} (the derived\n * view) on every advance and every status read; downstream consumers\n * (`buildWorkflowStatus`, the CLI `task status`) read `task.history` and so get\n * the derived-from-KV value indirectly — the audit KV remains the SOT they all\n * ultimately derive from.\n */\nexport function readGateHistory(store: Store, taskId: string): GateResult[] {\n  return store.getState<GateResult[]>(`audit:${taskId}`) ?? [];\n}\n","import type { ProjectId } from '@noir-ai/core';\n\nexport const PHASES = [\n  'intake',\n  'clarify',\n  'spec',\n  'plan',\n  'execute',\n  'verify',\n  'document',\n] as const;\nexport type Phase = (typeof PHASES)[number];\n\nexport const STATES = [\n  'draft',\n  'clarifying',\n  'specified',\n  'planned',\n  'executing',\n  'verifying',\n  'done',\n  'blocked',\n  'abandoned',\n] as const;\nexport type WorkflowState = (typeof STATES)[number];\n\nexport type Mode = 'full' | 'quick';\n\n/**\n * Task classification — drives the soft, escapable gate predicates (slice P:\n * the PRD recommendation at the spec gate). Mirrors the user-facing\n * `prd.mandatoryFor` enum in @noir-ai/core's `NoirConfigSchema` (declared\n * LOCALLY here so workflow has no core-cycle concern; the two literals stay in\n * sync by tests). `undefined` (the default for legacy tasks) ⇒ no soft gate\n * fires — additive, fully backward-compatible.\n */\nexport const TASK_CLASSES = [\n  'feature',\n  'epic',\n  'enhancement',\n  'bugfix',\n  'spike',\n  'quick-task',\n  'refactor',\n] as const;\nexport type TaskClass = (typeof TASK_CLASSES)[number];\n\n/**\n * Input shape for {@link recordGate} — what CALLERS pass. Omits `at` (the\n * recorder stamps it from `Date.now()` so the audit reflects when the gate\n * actually fired, not when the caller constructed the object). Split out of\n * {@link GateResult} (debt-batch A / W3): callers used to pass a throwaway\n * `at: 0` that recordGate overrode — this shape makes the override implicit.\n */\nexport interface GateResultInput {\n  phase: Phase;\n  decision: 'approved' | 'forced' | 'skipped';\n  reason?: string;\n}\n\n/**\n * A recorded gate decision — the AUTHORITATIVE shape stored in the\n * `audit:<taskId>` KV (the SOT per S4 spec §5 / §11 OQ-5) and surfaced via\n * `task.history` (a derived view the engine regenerates from the audit KV).\n * `at` is always present here; callers that want to RECORD a gate pass\n * {@link GateResultInput} (no `at`) to {@link recordGate}.\n */\nexport interface GateResult extends GateResultInput {\n  at: number;\n}\n\nexport interface TaskState {\n  taskId: string;\n  slug: string;\n  projectId: ProjectId;\n  state: WorkflowState;\n  phase: Phase;\n  mode: Mode;\n  /**\n   * DERIVED view of the gate audit for this task, regenerated from the\n   * authoritative `audit:<taskId>` KV (S4 spec §11 OQ-5) by the engine on\n   * every write and every status read. Kept on the TaskState so consumers\n   * (CLI `task status`, the daemon `workflow_status` tool, MCP clients) can\n   * read the gate history from the persisted TaskState without a second KV\n   * lookup. Never edited directly outside the engine — derive via\n   * {@link readGateHistory}.\n   */\n  history: GateResult[];\n  /** Task classification (slice P). `undefined` ⇒ no soft PRD gate fires. */\n  taskClass?: TaskClass;\n  jumpEntry?: Phase; // recorded if a jump-to-phase happened\n  /** Reason captured by `setBlocked` (admin escape; set directly, not via FSM). */\n  blockReason?: string;\n  updatedAt: number;\n}\n\n/**\n * The gate-config slice the engine consumes (debt-batch A / P4). Mirrors the\n * user-facing `prd:` block from @noir-ai/core's `NoirConfigSchema` — declared\n * locally (with a `readonly` array) so workflow has no core-cycle concern; the\n * daemon / CLI bridges NoirConfig → this shape at construction time. Every\n * field has a sane default, so an unspecified `gateConfig` (the legacy\n * constructor call) resolves to \"feature/epic trigger the PRD recommendation\".\n */\nexport interface WorkflowGateConfig {\n  /**\n   * PRD soft-gate config. `mandatoryFor` lists the task classes for which a\n   * missing PRD artifact (at the moment of entering the spec phase, in full\n   * mode) is surfaced as an observable, escapable recommendation on the spec\n   * gate. The advance still proceeds — `--force <reason>` is the explicit\n   * override path; quick mode + unlisted classes skip the check entirely.\n   */\n  prd: {\n    mandatoryFor: readonly TaskClass[];\n  };\n}\n","import type { Phase, WorkflowState } from './types.js';\n\n// Re-export the phase/state vocabularies so consumers can import the entire FSM\n// surface from one module (the test imports PHASES/STATES from here).\nexport { PHASES, STATES } from './types.js';\n\n// Legal state transitions (happy path + terminal). Gates (spec/plan/verify) are\n// modeled as the transition INTO specified/planned/done — the engine records a\n// GateResult at that point (see gates.ts).\nconst TRANSITIONS: Record<WorkflowState, WorkflowState[]> = {\n  draft: ['clarifying'],\n  clarifying: ['specified'],\n  specified: ['planned'],\n  planned: ['executing'],\n  executing: ['verifying'],\n  verifying: ['done'],\n  done: [],\n  blocked: ['draft', 'clarifying', 'specified', 'planned', 'executing', 'verifying'],\n  abandoned: [],\n};\n\nexport function canTransition(from: WorkflowState, to: WorkflowState): boolean {\n  return (TRANSITIONS[from] ?? []).includes(to);\n}\n\nexport function applyTransition(from: WorkflowState, to: WorkflowState): WorkflowState {\n  if (!canTransition(from, to)) {\n    const hint =\n      to === 'planned'\n        ? ' (the spec gate must be passed first)'\n        : to === 'executing'\n          ? ' (the plan gate must be passed first)'\n          : to === 'done'\n            ? ' (the verify gate must be passed first)'\n            : '';\n    throw new Error(`Illegal transition ${from} → ${to}${hint}`);\n  }\n  return to;\n}\n\n// Phase <-> state mapping for the engine.\nexport function stateForPhase(p: Phase): WorkflowState {\n  switch (p) {\n    case 'intake':\n      return 'draft';\n    case 'clarify':\n      return 'clarifying';\n    case 'spec':\n      return 'specified';\n    case 'plan':\n      return 'planned';\n    case 'execute':\n      return 'executing';\n    case 'verify':\n      return 'verifying';\n    case 'document':\n      return 'done';\n  }\n}\n\nexport function nextPhase(state: WorkflowState): Phase | null {\n  const map: Partial<Record<WorkflowState, Phase>> = {\n    draft: 'clarify',\n    clarifying: 'spec',\n    specified: 'plan',\n    planned: 'execute',\n    executing: 'verify',\n    verifying: 'document',\n  };\n  return map[state] ?? null;\n}\n","import type { ProjectId } from '@noir-ai/core';\nimport type { Store } from '@noir-ai/store';\nimport { readPrd, writeAuditExport } from './artifacts.js';\nimport { gateFor, readGateHistory, recordGate } from './gates.js';\nimport { applyTransition, nextPhase, stateForPhase } from './state-machine.js';\nimport type {\n  GateResult,\n  GateResultInput,\n  Mode,\n  Phase,\n  TaskClass,\n  TaskState,\n  WorkflowGateConfig,\n  WorkflowState,\n} from './types.js';\n\n/**\n * Store KV layout. The TaskState lives at `workflow:<taskId>`; the gate audit\n * lives at `audit:<taskId>` and is the AUTHORITATIVE record for every gate\n * outcome (S4 spec §11 OQ-5). `task.history` on the TaskState is a DERIVED view\n * the engine regenerates from the audit KV (debt-batch A / W1 collapse) so\n * there is a single write, single timestamp, single read-back — no drift.\n */\nconst ACTIVE_KEY = 'workflow:active';\nconst GATE_PHASES = ['spec', 'plan', 'verify'] as const satisfies ReadonlyArray<Phase>;\n\n/**\n * Default gate config — used when the engine is constructed without an explicit\n * {@link WorkflowGateConfig} (the legacy 3-arg call shape every existing\n * consumer uses). Mirrors @noir-ai/core's `prd.mandatoryFor` default so the\n * soft PRD recommendation fires for feature/epic tasks out of the box.\n */\nconst DEFAULT_GATE_CONFIG: WorkflowGateConfig = {\n  prd: { mandatoryFor: ['feature', 'epic'] },\n};\n\n/** Options for {@link WorkflowEngine.advance}. */\nexport interface AdvanceOpts {\n  /**\n   * Pass a gate without satisfying its criteria. Requires a non-empty `reason`\n   * (validated here, in the engine — `recordGate` is policy-free). The landing\n   * gate, if any, is recorded with `decision: 'forced'`. Mutually exclusive\n   * with {@link skip}. This is ALSO the explicit-override path for the soft\n   * PRD recommendation (debt-batch A / P4): supplying `--force <reason>` at the\n   * spec gate of a mandatoryFor task with no PRD records `forced` with the\n   * user's reason instead of the recommendation note.\n   */\n  force?: { reason?: string };\n  /**\n   * Jump directly to a phase, bypassing the FSM (the escape hatch for blocked /\n   * out-of-order resumption). The landing is recorded as `jumpEntry` on the\n   * TaskState; a landing gate-state (specified/planned/done) still records its\n   * gate so the observable-checkpoint invariant holds. A no-op jump (target\n   * equal to the current phase) returns the task unchanged without re-recording\n   * any gate (W3 guard — the prior behavior double-stamped the audit).\n   */\n  to?: Phase;\n  /**\n   * Quick-mode: record the landing gate (if any) as `decision: 'skipped'`\n   * instead of `approved`. The gate is still RECORDED — never silently dropped\n   * (Noir §9.1 observable-checkpoint invariant) — only the decision changes.\n   * Mutually exclusive with {@link force}.\n   */\n  skip?: true;\n}\n\n/**\n * The phase whose gate admits entry into `state` (the inverse of {@link gateFor}).\n *\n * The verify gate fires on entering `done` — but `done` is `stateForPhase('document')`,\n * so the target *phase* of that transition is `document`, not `verify`. The gate\n * must therefore be looked up from the target *state*, not the target phase.\n */\nfunction gatePhaseForState(state: WorkflowState): Phase | null {\n  for (const p of GATE_PHASES) {\n    if (gateFor(p) === state) return p;\n  }\n  return null;\n}\n\n/**\n * WorkflowEngine — drives an SDD task through its lifecycle.\n *\n * The engine is a thin orchestrator over three T1–T3 primitives:\n *   • the hand-rolled FSM ({@link applyTransition}) for legal forward moves,\n *   • {@link recordGate} for observable checkpoint audit, and\n *   • the store KV for persisted {@link TaskState}.\n *\n * Policy that did not belong in T1/T2 lives here:\n *   • `--force` requires a non-empty reason (validated before any gate write),\n *   • `blocked` / `abandoned` have no incoming FSM edges and are set directly,\n *   • `opts.to` jumps past FSM edges and is recorded via `jumpEntry`,\n *   • (P4) the soft PRD recommendation at the spec gate for mandatoryFor tasks.\n *\n * Modes (Full/Quick) and cross-session resume are T5; MCP tools are T6 — the\n * engine stays mode-agnostic here and only stores `mode` on the TaskState.\n */\nexport class WorkflowEngine {\n  private readonly gateConfig: WorkflowGateConfig;\n\n  constructor(\n    private readonly store: Store,\n    /**\n     * Project root — the engine is constructed with it so modes (quickPath\n     * writes a spec stub via {@link writeSpec}) and future artifact flushes\n     * (checkpoint/audit export) are self-contained. Public so the modes module\n     * can pass it to {@link ArtifactWriter}.\n     */\n    readonly root: string,\n    private readonly projectId: ProjectId,\n    /**\n     * Gate-config slice (debt-batch A / P4). Optional — the legacy 3-arg call\n     * shape (every existing consumer) resolves to {@link DEFAULT_GATE_CONFIG}\n     * (PRD recommendation fires for feature/epic). The daemon / CLI bridge\n     * passes the resolved `prd.mandatoryFor` from NoirConfig so user overrides\n     * take effect; tests pass an explicit shape to pin behavior.\n     */\n    gateConfig?: WorkflowGateConfig,\n  ) {\n    this.gateConfig = gateConfig ?? DEFAULT_GATE_CONFIG;\n  }\n\n  /**\n   * Create a new task at draft/intake, persist it, and point `workflow:active`\n   * at it. Re-starting an existing taskId overwrites it (intentional — the KV is\n   * the source of truth, not a journal).\n   *\n   * `taskClass` (debt-batch A / P4) is optional and additive — legacy callers\n   * (and existing tests) omit it; the soft PRD gate then never fires for the\n   * task (consistent with the \"additive, no-op when absent\" rule). New callers\n   * that want the recommendation pass `'feature'` / `'epic'` / etc.\n   */\n  async startTask(\n    taskId: string,\n    slug: string,\n    mode: Mode,\n    taskClass?: TaskClass,\n  ): Promise<TaskState> {\n    const task: TaskState = {\n      taskId,\n      slug,\n      projectId: this.projectId,\n      state: 'draft',\n      phase: 'intake',\n      mode,\n      history: [],\n      ...(taskClass !== undefined ? { taskClass } : {}),\n      updatedAt: Date.now(),\n    };\n    this.persist(task);\n    this.store.setState<string>(ACTIVE_KEY, taskId);\n    return task;\n  }\n\n  /**\n   * Advance `taskId` to its next phase, or jump with `opts.to`.\n   *\n   * At a gate-landing state (entering `specified` / `planned` / `done`) a\n   * {@link GateResult} is recorded — `approved` by default, `forced` (with the\n   * reason) when `opts.force` is supplied, or `skipped` when `opts.skip` is\n   * supplied (quick mode). `force` and `skip` are mutually exclusive. Jumps\n   * bypass the FSM and additionally stamp `jumpEntry`.\n   *\n   * Single source of truth (W1): the gate is written ONCE to the audit KV via\n   * {@link recordGate}, and `task.history` is RE-DERIVED from that KV. No\n   * second write, no second timestamp — the S4 sub-ms drift is gone.\n   */\n  async advance(taskId: string, opts?: AdvanceOpts): Promise<TaskState> {\n    const task = this.requireTask(taskId);\n\n    // Policy: --force and skip are mutually exclusive gate decisions (a gate\n    // can't be both forced AND skipped). Validated BEFORE any gate write so a\n    // bad combination never leaves a partial audit trail behind.\n    if (opts?.force && opts?.skip) {\n      throw new Error('cannot combine --force and skip');\n    }\n    // Policy: --force requires a non-empty reason.\n    if (opts?.force && !opts.force.reason?.trim()) {\n      throw new Error('--force requires a reason');\n    }\n\n    const jump = opts?.to !== undefined;\n    const targetPhase: Phase = jump ? (opts?.to as Phase) : this.nextPhaseOf(task);\n\n    // W3 guard: a jump to the CURRENT phase is a no-op. Previously the engine\n    // re-stamped the audit (the landing gate fired again), producing a spurious\n    // duplicate entry. Return the task unchanged — no gate, no state change.\n    if (jump && targetPhase === task.phase) {\n      return task;\n    }\n\n    const targetState = stateForPhase(targetPhase);\n    if (!jump) {\n      // applyTransition surfaces the FSM's gate hint on illegal moves.\n      applyTransition(task.state, targetState);\n    }\n\n    // Observable checkpoint: entering specified/planned/done always records a\n    // gate — looked up from the target STATE (see gatePhaseForState).\n    const gatePhase = gatePhaseForState(targetState);\n    if (gatePhase !== null) {\n      const decision = opts?.force ? 'forced' : opts?.skip ? 'skipped' : 'approved';\n      // P4 soft PRD recommendation: when entering `specified` (the spec gate),\n      // the task is mandatoryFor-eligible, no PRD artifact exists, and the user\n      // did NOT supply --force, fold a recommendation note into the recorded\n      // gate's `reason`. The advance STILL PROCEEDS — this is the \"quiet\n      // observable nudge\" doctrine (§9.1): never a hard block, never silently\n      // dropped. Quick-mode + unlisted taskClasses skip the check entirely;\n      // --force records `forced` with the user's reason (the explicit override).\n      const prdHint = this.prdRecommendation(task, gatePhase, opts);\n      const input: GateResultInput = {\n        phase: gatePhase,\n        decision,\n        // exactOptionalPropertyTypes is false; spread reason only when present.\n        // Force-path wins over the soft hint (a user who forces is explicitly\n        // accepting the recommendation; their reason is the override signal).\n        ...(opts?.force\n          ? { reason: opts.force.reason }\n          : prdHint !== null\n            ? { reason: prdHint }\n            : {}),\n      };\n      // W1: record ONCE to the authoritative audit KV; derive history from it.\n      recordGate(this.store, taskId, input);\n      task.history = readGateHistory(this.store, taskId);\n    }\n\n    task.state = targetState;\n    task.phase = targetPhase;\n    if (jump) task.jumpEntry = targetPhase;\n    task.updatedAt = Date.now();\n\n    this.persist(task);\n    return task;\n  }\n\n  /**\n   * Compute the soft PRD-recommendation message (P4), or `null` when the\n   * recommendation does NOT apply. The recommendation applies when ALL of:\n   *   • the gate landing now is the spec gate (entering `specified`), AND\n   *   • the task is in full mode (quick mode skips — quickPath writes a stub), AND\n   *   • the task has a `taskClass` listed in `gateConfig.prd.mandatoryFor`, AND\n   *   • no PRD artifact exists at `.noir/prd/<id>-<slug>.md` (readPrd), AND\n   *   • the user did NOT supply --force (force is the explicit-override path).\n   *\n   * Returns the observable note (audited on the spec gate's `reason`) so a\n   * downstream consumer (CLI status, workflow_status MCP tool) can surface it.\n   */\n  private prdRecommendation(task: TaskState, gatePhase: Phase, opts?: AdvanceOpts): string | null {\n    if (gatePhase !== 'spec') return null;\n    if (task.mode === 'quick') return null;\n    const taskClass = task.taskClass;\n    if (taskClass === undefined) return null;\n    if (!this.gateConfig.prd.mandatoryFor.includes(taskClass)) return null;\n    if (opts?.force) return null; // explicit override — user's reason wins\n    if (readPrd(this.root, task.taskId, task.slug) !== null) return null;\n    return `PRD recommended for ${taskClass} — provide one (noir-prd) or --force <reason> to skip`;\n  }\n\n  /** Read the persisted TaskState, or null if the task is unknown. */\n  status(taskId: string): TaskState | null {\n    const task = this.store.getState<TaskState>(workflowKey(taskId));\n    if (!task) return null;\n    // W1: re-derive history from the authoritative audit KV on every read, so\n    // consumers see any externally-mutated audit (e.g. a manual KV write or a\n    // future audit-import path) without waiting for the next advance.\n    task.history = readGateHistory(this.store, taskId);\n    return task;\n  }\n\n  /**\n   * The taskId of the most-recently-started task (`workflow:active` in the\n   * store KV), or `null` when no task has been started yet. Lets the MCP\n   * `workflow_status` / `checkpoint` tools omit `taskId` and operate on the\n   * active task.\n   */\n  activeTaskId(): string | null {\n    return this.store.getState<string>(ACTIVE_KEY);\n  }\n\n  /**\n   * Re-flush the current state to KV + flush the gate audit export to\n   * `.noir/audit/<taskId>.json`. W2 (debt-batch A): the prior implementation\n   * only bumped `updatedAt`, which every advance already does — vestigial.\n   * Cross-session resume (`resumeTask`) reads `workflow:<id>` straight from the\n   * KV and consumes nothing from this method; the S4 ledger noted the write was\n   * dead. The fix is to WIRE the checkpoint to a real cross-tool artifact\n   * flush: the audit JSON on disk (the S4 spec §11 OQ-5 \"export to\n   * `.noir/audit/<taskId>.json`\" that {@link writeAuditExport} already\n   * implemented but nothing called). The MCP `checkpoint { action:'save' }`\n   * tool stays the public surface; its save now leaves a human-inspectable\n   * audit JSON alongside the KV.\n   */\n  async checkpoint(taskId: string): Promise<void> {\n    const task = this.store.getState<TaskState>(workflowKey(taskId));\n    if (!task) throw new Error(`Unknown task: ${taskId}`);\n    task.updatedAt = Date.now();\n    this.persist(task);\n    // Flush the authoritative audit KV to disk for cross-tool inspection. The\n    // audit is read straight from the KV (the SOT) so the JSON matches what\n    // `status()` would report as `task.history`.\n    writeAuditExport(this.root, taskId, readGateHistory(this.store, taskId));\n  }\n\n  /**\n   * Set state directly to `blocked` (no FSM edge — the admin escape). The reason\n   * is captured on the TaskState for surfacing in `noir.workflow_status`.\n   *\n   * W3: a SUPPLIED reason must be non-empty after trimming (mirrors the\n   * `--force` policy). `setBlocked(id)` with no reason stays valid — it clears\n   * no field and just flips state. A whitespace-only reason is rejected as\n   * malformed (consistent with `--force`'s whitespace rejection).\n   */\n  async setBlocked(taskId: string, reason?: string): Promise<TaskState> {\n    const task = this.requireTask(taskId);\n    if (reason !== undefined) {\n      const trimmed = reason.trim();\n      if (trimmed.length === 0) {\n        throw new Error('setBlocked reason must be non-empty (or omitted to leave unset)');\n      }\n      task.blockReason = trimmed;\n    }\n    task.state = 'blocked';\n    task.updatedAt = Date.now();\n    this.persist(task);\n    return task;\n  }\n\n  /** Set state directly to `abandoned` (terminal; no FSM edge). */\n  async abandon(taskId: string): Promise<TaskState> {\n    const task = this.requireTask(taskId);\n    task.state = 'abandoned';\n    task.updatedAt = Date.now();\n    this.persist(task);\n    return task;\n  }\n\n  private nextPhaseOf(task: TaskState): Phase {\n    const next = nextPhase(task.state);\n    if (next === null) {\n      throw new Error(`No next phase from state ${task.state}`);\n    }\n    return next;\n  }\n\n  private requireTask(taskId: string): TaskState {\n    const task = this.store.getState<TaskState>(workflowKey(taskId));\n    if (!task) throw new Error(`Unknown task: ${taskId}`);\n    return task;\n  }\n\n  private persist(task: TaskState): void {\n    this.store.setState<TaskState>(workflowKey(task.taskId), task);\n  }\n}\n\nfunction workflowKey(taskId: string): string {\n  return `workflow:${taskId}`;\n}\n","import type { Store } from '@noir-ai/store';\nimport { writeSpec } from './artifacts.js';\nimport type { WorkflowEngine } from './engine.js';\nimport type { TaskState, WorkflowState } from './types.js';\n\n/**\n * Default spec body written by {@link runQuick}. Quick mode is \"discipline\n * lite\": the spec is stubbed (the spec + plan gates are skipped), but a real\n * spec file still lands on disk so later phases (and humans) have something to\n * read. Exported so callers/tests can assert on the canonical stub text.\n */\nexport const QUICK_SPEC_STUB = '<quick-mode stub spec>';\n\n/** Options for {@link runQuick}. */\nexport interface QuickOpts {\n  /**\n   * Override the stub spec body (defaults to {@link QUICK_SPEC_STUB}). Useful\n   * when a quick task already has a one-line description worth persisting.\n   */\n  specBody?: string;\n}\n\n/**\n * Quick mode — the fast path for small / spike tasks.\n *\n * Writes a stub spec to `.noir/specs/<taskId>-<slug>.md` (via\n * {@link writeSpec}) and fast-forwards the task from `draft` to `executing`,\n * recording the spec and plan gates as `decision: 'skipped'`. The verify gate\n * is intentionally LEFT alone — it still fires as `approved` when the task\n * later reaches `done`, providing the one real checkpoint (discipline lite).\n *\n * The task must already be started (`engine.startTask(..., 'quick')`); this\n * function reads the slug from the persisted TaskState. Skipped gates are\n * RECORDED (Noir §9.1 observable-checkpoint invariant), never silently dropped\n * — the audit KV and `history` both carry the `skipped` entries.\n */\nexport async function runQuick(\n  engine: WorkflowEngine,\n  taskId: string,\n  opts?: QuickOpts,\n): Promise<TaskState> {\n  const task = engine.status(taskId);\n  if (!task) throw new Error(`Unknown task: ${taskId}`);\n\n  // Flush the stub spec first so the artifact exists before any gate fires.\n  writeSpec(engine.root, taskId, task.slug, opts?.specBody ?? QUICK_SPEC_STUB);\n\n  // draft → clarifying → specified (spec gate SKIPPED) → planned (plan gate\n  // SKIPPED) → executing. Verify is left for the normal flow (runs as approved).\n  await engine.advance(taskId); // draft → clarifying (no gate)\n  await engine.advance(taskId, { skip: true }); // → specified (spec gate skipped)\n  await engine.advance(taskId, { skip: true }); // → planned (plan gate skipped)\n  return engine.advance(taskId); // → executing (no gate) — land here\n}\n\n/** Terminal states with nothing left to resume. `blocked` is NOT terminal. */\nconst TERMINAL_STATES: ReadonlySet<WorkflowState> = new Set<WorkflowState>(['done', 'abandoned']);\n\n/**\n * Reconstruct the in-flight TaskState across a session break.\n *\n * Reads `workflow:active` from the store KV → the most-recently-started\n * taskId (T4 semantics; v1 is one-task-per-project) → the persisted\n * `workflow:<taskId>` TaskState. Returns `null` when there is no active task,\n * the task record is missing, or the active task is terminal (`done` /\n * `abandoned` — nothing to resume). A `blocked` task IS resumable.\n *\n * Uses only the public {@link Store} API, so a freshly-`openStore`'d handle\n * against the same on-disk DB is sufficient (no live engine required).\n */\nexport async function resumeTask(store: Store): Promise<TaskState | null> {\n  const activeId = store.getState<string>('workflow:active');\n  if (!activeId) return null;\n\n  const task = store.getState<TaskState>(`workflow:${activeId}`);\n  if (!task) return null;\n  if (TERMINAL_STATES.has(task.state)) return null;\n\n  return task;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noir-ai/workflow",
-  "version": "1.0.0-beta.1",
+  "version": "1.2.0-beta.1",
   "description": "Noir workflow — the spec-driven lifecycle engine (intake → document) with observable, escapable gates.",
   "license": "MIT",
   "author": "agaaaptr",
@@ -43,8 +43,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@noir-ai/core": "1.0.0-beta.1",
-    "@noir-ai/store": "1.0.0-beta.1"
+    "@noir-ai/core": "1.2.0-beta.1",
+    "@noir-ai/store": "1.2.0-beta.1"
   },
   "devDependencies": {
     "@types/node": "^26.1.1"