@noir-ai/workflow 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agaaaptr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# @noir-ai/workflow
+
+The spec-driven development lifecycle engine: a hand-rolled finite-state machine (Intake → Clarify → Spec → Plan → Execute → Verify → Document) with observable, escapable gates. Every decision is recorded; phases can be force-skipped with a reason or jumped to directly. Supports Full, Quick, and Resume modes with cross-session resume.
+
+Part of the **[Noir](https://github.com/agaaaptr/noir#readme)** toolkit — the discipline, context, and memory layer for any agentic CLI.
+
+## Install
+
+```bash
+npm install @noir-ai/workflow
+```
+
+> Most users install the CLI instead, which pulls in the packages it needs:
+>
+> ```bash
+> npm install -g @noir-ai/cli
+> ```
+
+## License
+
+MIT © agaaaptr

package/dist/index.d.ts

@@ -0,0 +1,240 @@
+import { ProjectId } from '@noir-ai/core';
+import { Store } from '@noir-ai/store';
+
+declare const PHASES: readonly ["intake", "clarify", "spec", "plan", "execute", "verify", "document"];
+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 {
+    phase: Phase;
+    decision: 'approved' | 'forced' | 'skipped';
+    reason?: string;
+    at: number;
+}
+interface TaskState {
+    taskId: string;
+    slug: string;
+    projectId: ProjectId;
+    state: WorkflowState;
+    phase: Phase;
+    mode: Mode;
+    history: GateResult[];
+    jumpEntry?: Phase;
+    /** Reason captured by `setBlocked` (admin escape; set directly, not via FSM). */
+    blockReason?: string;
+    updatedAt: number;
+}
+
+/**
+ * Write intake artifact to .noir/intake/<taskId>.md
+ */
+declare function writeIntake(root: string, taskId: string, content: string): void;
+/**
+ * Write spec artifact to .noir/specs/<taskId>-<slug>.md
+ * Creates markdown with frontmatter and body
+ */
+declare function writeSpec(root: string, taskId: string, slug: string, body: string): void;
+/**
+ * Write plan artifact to .noir/plans/<taskId>-<slug>.md
+ */
+declare function writePlan(root: string, taskId: string, slug: string, body: string): void;
+/**
+ * Write task artifact to .noir/tasks/<taskId>-<taskName>.md
+ */
+declare function writeTask(root: string, taskId: string, taskName: string, body: string): void;
+/**
+ * Write decision stub to .noir/decisions/<n>.md
+ */
+declare function writeDecisionStub(root: string, n: number, title: string): void;
+/**
+ * Write changelog stub entry to .noir/CHANGELOG.md
+ */
+declare function writeChangelogStub(root: string, entry: string): void;
+/**
+ * Write audit export to .noir/audit/<taskId>.json
+ * Exports GateResult array as JSON
+ */
+declare function writeAuditExport(root: string, taskId: string, results: GateResult[]): void;
+
+/** Options for {@link WorkflowEngine.advance}. */
+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}.
+     */
+    force?: {
+        reason?: string;
+    };
+    /**
+     * 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.
+     */
+    to?: Phase;
+    /**
+     * Quick-mode: record the landing gate (if any) as `decision: 'skipped'`
+     * instead of `approved`. The gate is still RECORDED — never silently dropped
+     * (Noir §9.1 observable-checkpoint invariant) — only the decision changes.
+     * Mutually exclusive with {@link force}.
+     */
+    skip?: true;
+}
+/**
+ * WorkflowEngine — drives an SDD task through its lifecycle.
+ *
+ * The engine is a thin orchestrator over three T1–T3 primitives:
+ *   • the hand-rolled FSM ({@link applyTransition}) for legal forward moves,
+ *   • {@link recordGate} for observable checkpoint audit, and
+ *   • the store KV for persisted {@link TaskState}.
+ *
+ * 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`.
+ *
+ * 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.
+ */
+declare class WorkflowEngine {
+    private readonly store;
+    /**
+     * Project root — the engine is constructed with it so modes (quickPath
+     * writes a spec stub via {@link writeSpec}) and future artifact flushes
+     * (checkpoint/audit export) are self-contained. Public so the modes module
+     * can pass it to {@link ArtifactWriter}.
+     */
+    readonly root: string;
+    private readonly projectId;
+    constructor(store: Store, 
+    /**
+     * Project root — the engine is constructed with it so modes (quickPath
+     * writes a spec stub via {@link writeSpec}) and future artifact flushes
+     * (checkpoint/audit export) are self-contained. Public so the modes module
+     * can pass it to {@link ArtifactWriter}.
+     */
+    root: string, projectId: ProjectId);
+    /**
+     * 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).
+     */
+    startTask(taskId: string, slug: string, mode: Mode): Promise<TaskState>;
+    /**
+     * Advance `taskId` to its next phase, or jump with `opts.to`.
+     *
+     * At a gate-landing state (entering `specified` / `planned` / `done`) a
+     * {@link GateResult} is recorded — `approved` by default, `forced` (with the
+     * 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`.
+     */
+    advance(taskId: string, opts?: AdvanceOpts): Promise<TaskState>;
+    /** Read the persisted TaskState, or null if the task is unknown. */
+    status(taskId: string): TaskState | null;
+    /**
+     * The taskId of the most-recently-started task (`workflow:active` in the
+     * store KV), or `null` when no task has been started yet. Lets the MCP
+     * `workflow_status` / `checkpoint` tools omit `taskId` and operate on the
+     * active task.
+     */
+    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.
+     */
+    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`.
+     */
+    setBlocked(taskId: string, reason?: string): Promise<TaskState>;
+    /** Set state directly to `abandoned` (terminal; no FSM edge). */
+    abandon(taskId: string): Promise<TaskState>;
+    private nextPhaseOf;
+    private requireTask;
+    private persist;
+}
+
+/**
+ * The workflow state a phase's gate guards entry into (Noir §9.1 observable
+ * checkpoint). A gate fires when its phase completes:
+ *   spec-gate   → entering `specified`
+ *   plan-gate   → entering `planned`
+ *   verify-gate → entering `done`
+ *
+ * Phases without a gate (intake / clarify / execute / document) return `null`.
+ * This is distinct from {@link stateForPhase}: `stateForPhase('verify')` is the
+ * in-progress `verifying`, while `gateFor('verify')` is the state the verify
+ * gate admits you into (`done`).
+ */
+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).
+ * 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:
+ * prior entries are read and preserved (never overwritten).
+ */
+declare function recordGate(store: Store, taskId: string, result: GateResult): void;
+
+/**
+ * Default spec body written by {@link runQuick}. Quick mode is "discipline
+ * lite": the spec is stubbed (the spec + plan gates are skipped), but a real
+ * spec file still lands on disk so later phases (and humans) have something to
+ * read. Exported so callers/tests can assert on the canonical stub text.
+ */
+declare const QUICK_SPEC_STUB = "<quick-mode stub spec>";
+/** Options for {@link runQuick}. */
+interface QuickOpts {
+    /**
+     * Override the stub spec body (defaults to {@link QUICK_SPEC_STUB}). Useful
+     * when a quick task already has a one-line description worth persisting.
+     */
+    specBody?: string;
+}
+/**
+ * Quick mode — the fast path for small / spike tasks.
+ *
+ * Writes a stub spec to `.noir/specs/<taskId>-<slug>.md` (via
+ * {@link writeSpec}) and fast-forwards the task from `draft` to `executing`,
+ * recording the spec and plan gates as `decision: 'skipped'`. The verify gate
+ * is intentionally LEFT alone — it still fires as `approved` when the task
+ * later reaches `done`, providing the one real checkpoint (discipline lite).
+ *
+ * The task must already be started (`engine.startTask(..., 'quick')`); this
+ * function reads the slug from the persisted TaskState. Skipped gates are
+ * RECORDED (Noir §9.1 observable-checkpoint invariant), never silently dropped
+ * — the audit KV and `history` both carry the `skipped` entries.
+ */
+declare function runQuick(engine: WorkflowEngine, taskId: string, opts?: QuickOpts): Promise<TaskState>;
+/**
+ * Reconstruct the in-flight TaskState across a session break.
+ *
+ * Reads `workflow:active` from the store KV → the most-recently-started
+ * taskId (T4 semantics; v1 is one-task-per-project) → the persisted
+ * `workflow:<taskId>` TaskState. Returns `null` when there is no active task,
+ * the task record is missing, or the active task is terminal (`done` /
+ * `abandoned` — nothing to resume). A `blocked` task IS resumable.
+ *
+ * Uses only the public {@link Store} API, so a freshly-`openStore`'d handle
+ * against the same on-disk DB is sufficient (no live engine required).
+ */
+declare function resumeTask(store: Store): Promise<TaskState | null>;
+
+declare function canTransition(from: WorkflowState, to: WorkflowState): boolean;
+declare function applyTransition(from: WorkflowState, to: WorkflowState): WorkflowState;
+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 };

package/dist/index.js

@@ -0,0 +1,363 @@
+// src/artifacts.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { paths } from "@noir-ai/core";
+function writeIntake(root, taskId, content) {
+  const dir = join(root, ".noir", "intake");
+  const file = join(dir, `${taskId}.md`);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(file, content, "utf-8");
+}
+function writeSpec(root, taskId, slug, body) {
+  const dir = paths.specsDir(root);
+  const file = paths.specFile(root, taskId, slug);
+  mkdirSync(dir, { recursive: true });
+  const content = `---
+taskId: ${taskId}
+slug: ${slug}
+---
+
+${body}`;
+  writeFileSync(file, content, "utf-8");
+}
+function writePlan(root, taskId, slug, body) {
+  const dir = paths.plansDir(root);
+  const file = paths.planFile(root, taskId, slug);
+  mkdirSync(dir, { recursive: true });
+  const content = `---
+taskId: ${taskId}
+slug: ${slug}
+---
+
+${body}`;
+  writeFileSync(file, content, "utf-8");
+}
+function writeTask(root, taskId, taskName, body) {
+  const dir = paths.tasksDir(root);
+  const file = paths.taskFile(root, taskId, taskName);
+  mkdirSync(dir, { recursive: true });
+  const content = `---
+taskId: ${taskId}
+task: ${taskName}
+---
+
+${body}`;
+  writeFileSync(file, content, "utf-8");
+}
+function writeDecisionStub(root, n, title) {
+  const dir = paths.decisionsDir(root);
+  const file = paths.decisionFile(root, n);
+  mkdirSync(dir, { recursive: true });
+  const content = `# ${title}
+
+*Decision record ${n}*
+
+<!-- Status: pending -->
+`;
+  writeFileSync(file, content, "utf-8");
+}
+function writeChangelogStub(root, entry) {
+  const file = join(root, ".noir", "CHANGELOG.md");
+  mkdirSync(join(root, ".noir"), { recursive: true });
+  let content;
+  if (existsSync(file)) {
+    const existing = readFileSync(file, "utf-8");
+    const prefix = existing.endsWith("\n") ? existing : `${existing}
+`;
+    content = `${prefix}${entry}
+`;
+  } else {
+    content = `# Changelog
+
+${entry}
+`;
+  }
+  writeFileSync(file, content, "utf-8");
+}
+function writeAuditExport(root, taskId, results) {
+  const dir = paths.auditDir(root);
+  const file = paths.auditFile(root, taskId);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(file, JSON.stringify(results, null, 2), "utf-8");
+}
+
+// src/gates.ts
+function gateFor(phase) {
+  switch (phase) {
+    case "spec":
+      return "specified";
+    case "plan":
+      return "planned";
+    case "verify":
+      return "done";
+    default:
+      return null;
+  }
+}
+function recordGate(store, taskId, result) {
+  const key = `audit:${taskId}`;
+  const prior = store.getState(key) ?? [];
+  store.setState(key, [...prior, { ...result, at: Date.now() }]);
+}
+
+// src/types.ts
+var PHASES = [
+  "intake",
+  "clarify",
+  "spec",
+  "plan",
+  "execute",
+  "verify",
+  "document"
+];
+var STATES = [
+  "draft",
+  "clarifying",
+  "specified",
+  "planned",
+  "executing",
+  "verifying",
+  "done",
+  "blocked",
+  "abandoned"
+];
+
+// src/state-machine.ts
+var TRANSITIONS = {
+  draft: ["clarifying"],
+  clarifying: ["specified"],
+  specified: ["planned"],
+  planned: ["executing"],
+  executing: ["verifying"],
+  verifying: ["done"],
+  done: [],
+  blocked: ["draft", "clarifying", "specified", "planned", "executing", "verifying"],
+  abandoned: []
+};
+function canTransition(from, to) {
+  return (TRANSITIONS[from] ?? []).includes(to);
+}
+function applyTransition(from, to) {
+  if (!canTransition(from, to)) {
+    const hint = to === "planned" ? " (the spec gate must be passed first)" : to === "executing" ? " (the plan gate must be passed first)" : to === "done" ? " (the verify gate must be passed first)" : "";
+    throw new Error(`Illegal transition ${from} \u2192 ${to}${hint}`);
+  }
+  return to;
+}
+function stateForPhase(p) {
+  switch (p) {
+    case "intake":
+      return "draft";
+    case "clarify":
+      return "clarifying";
+    case "spec":
+      return "specified";
+    case "plan":
+      return "planned";
+    case "execute":
+      return "executing";
+    case "verify":
+      return "verifying";
+    case "document":
+      return "done";
+  }
+}
+function nextPhase(state) {
+  const map = {
+    draft: "clarify",
+    clarifying: "spec",
+    specified: "plan",
+    planned: "execute",
+    executing: "verify",
+    verifying: "document"
+  };
+  return map[state] ?? null;
+}
+
+// src/engine.ts
+var ACTIVE_KEY = "workflow:active";
+var GATE_PHASES = ["spec", "plan", "verify"];
+function gatePhaseForState(state) {
+  for (const p of GATE_PHASES) {
+    if (gateFor(p) === state) return p;
+  }
+  return null;
+}
+var WorkflowEngine = class {
+  constructor(store, root, projectId) {
+    this.store = store;
+    this.root = root;
+    this.projectId = projectId;
+  }
+  store;
+  root;
+  projectId;
+  /**
+   * 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).
+   */
+  async startTask(taskId, slug, mode) {
+    const task = {
+      taskId,
+      slug,
+      projectId: this.projectId,
+      state: "draft",
+      phase: "intake",
+      mode,
+      history: [],
+      updatedAt: Date.now()
+    };
+    this.persist(task);
+    this.store.setState(ACTIVE_KEY, taskId);
+    return task;
+  }
+  /**
+   * Advance `taskId` to its next phase, or jump with `opts.to`.
+   *
+   * At a gate-landing state (entering `specified` / `planned` / `done`) a
+   * {@link GateResult} is recorded — `approved` by default, `forced` (with the
+   * 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`.
+   */
+  async advance(taskId, opts) {
+    const task = this.requireTask(taskId);
+    if (opts?.force && opts?.skip) {
+      throw new Error("cannot combine --force and skip");
+    }
+    if (opts?.force && !opts.force.reason?.trim()) {
+      throw new Error("--force requires a reason");
+    }
+    const jump = opts?.to !== void 0;
+    const targetPhase = jump ? opts?.to : this.nextPhaseOf(task);
+    const targetState = stateForPhase(targetPhase);
+    if (!jump) {
+      applyTransition(task.state, targetState);
+    }
+    const gatePhase = gatePhaseForState(targetState);
+    if (gatePhase !== null) {
+      const decision = opts?.force ? "forced" : opts?.skip ? "skipped" : "approved";
+      const gate = {
+        phase: gatePhase,
+        decision,
+        // exactOptionalPropertyTypes is false; spread reason only when forced.
+        ...opts?.force ? { reason: opts.force.reason } : {},
+        at: Date.now()
+      };
+      recordGate(this.store, taskId, gate);
+      task.history.push(gate);
+    }
+    task.state = targetState;
+    task.phase = targetPhase;
+    if (jump) task.jumpEntry = targetPhase;
+    task.updatedAt = Date.now();
+    this.persist(task);
+    return task;
+  }
+  /** Read the persisted TaskState, or null if the task is unknown. */
+  status(taskId) {
+    return this.store.getState(workflowKey(taskId));
+  }
+  /**
+   * The taskId of the most-recently-started task (`workflow:active` in the
+   * store KV), or `null` when no task has been started yet. Lets the MCP
+   * `workflow_status` / `checkpoint` tools omit `taskId` and operate on the
+   * active task.
+   */
+  activeTaskId() {
+    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.
+   */
+  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);
+  }
+  /**
+   * Set state directly to `blocked` (no FSM edge — the admin escape). The reason
+   * is captured on the TaskState for surfacing in `noir.workflow_status`.
+   */
+  async setBlocked(taskId, reason) {
+    const task = this.requireTask(taskId);
+    task.state = "blocked";
+    if (reason) task.blockReason = reason;
+    task.updatedAt = Date.now();
+    this.persist(task);
+    return task;
+  }
+  /** Set state directly to `abandoned` (terminal; no FSM edge). */
+  async abandon(taskId) {
+    const task = this.requireTask(taskId);
+    task.state = "abandoned";
+    task.updatedAt = Date.now();
+    this.persist(task);
+    return task;
+  }
+  nextPhaseOf(task) {
+    const next = nextPhase(task.state);
+    if (next === null) {
+      throw new Error(`No next phase from state ${task.state}`);
+    }
+    return next;
+  }
+  requireTask(taskId) {
+    const task = this.store.getState(workflowKey(taskId));
+    if (!task) throw new Error(`Unknown task: ${taskId}`);
+    return task;
+  }
+  persist(task) {
+    this.store.setState(workflowKey(task.taskId), task);
+  }
+};
+function workflowKey(taskId) {
+  return `workflow:${taskId}`;
+}
+
+// src/modes.ts
+var QUICK_SPEC_STUB = "<quick-mode stub spec>";
+async function runQuick(engine, taskId, opts) {
+  const task = engine.status(taskId);
+  if (!task) throw new Error(`Unknown task: ${taskId}`);
+  writeSpec(engine.root, taskId, task.slug, opts?.specBody ?? QUICK_SPEC_STUB);
+  await engine.advance(taskId);
+  await engine.advance(taskId, { skip: true });
+  await engine.advance(taskId, { skip: true });
+  return engine.advance(taskId);
+}
+var TERMINAL_STATES = /* @__PURE__ */ new Set(["done", "abandoned"]);
+async function resumeTask(store) {
+  const activeId = store.getState("workflow:active");
+  if (!activeId) return null;
+  const task = store.getState(`workflow:${activeId}`);
+  if (!task) return null;
+  if (TERMINAL_STATES.has(task.state)) return null;
+  return task;
+}
+export {
+  PHASES,
+  QUICK_SPEC_STUB,
+  STATES,
+  WorkflowEngine,
+  applyTransition,
+  canTransition,
+  gateFor,
+  nextPhase,
+  recordGate,
+  resumeTask,
+  runQuick,
+  stateForPhase,
+  writeAuditExport,
+  writeChangelogStub,
+  writeDecisionStub,
+  writeIntake,
+  writePlan,
+  writeSpec,
+  writeTask
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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":"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","names":[]}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@noir-ai/workflow",
+  "version": "1.0.0-beta.1",
+  "description": "Noir workflow — the spec-driven lifecycle engine (intake → document) with observable, escapable gates.",
+  "license": "MIT",
+  "author": "agaaaptr",
+  "homepage": "https://github.com/agaaaptr/noir#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agaaaptr/noir.git",
+    "directory": "packages/workflow"
+  },
+  "bugs": {
+    "url": "https://github.com/agaaaptr/noir/issues"
+  },
+  "keywords": [
+    "noir",
+    "workflow",
+    "sdd",
+    "spec-driven",
+    "lifecycle",
+    "fsm",
+    "agent"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@noir-ai/core": "1.0.0-beta.1",
+    "@noir-ai/store": "1.0.0-beta.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}