@noir-ai/cli 1.9.4 → 1.10.0

package/dist/bin.js

@@ -27,6 +27,7 @@ import {
   log,
   requireInteractive,
   spinner,
+  success,
   table,
   tip,
   useColor,
@@ -44,7 +45,12 @@ import { Command, Option } from "commander";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { ContextEngine, createEmbedFn, resolveEmbedderConfig } from "@noir-ai/context";
 import { loadProjectInfo, NOIR_VERSION } from "@noir-ai/core";
-import { ensureDaemonRunning, pidAlive, readDaemonRecord } from "@noir-ai/daemon";
+import {
+  ensureDaemonRunning,
+  pidAlive,
+  readDaemonRecord,
+  resolveGateConfig
+} from "@noir-ai/daemon";
 import { createMemoryEngine } from "@noir-ai/memory";
 import { openStore } from "@noir-ai/store";
 import { WorkflowEngine } from "@noir-ai/workflow";
@@ -214,7 +220,12 @@ async function withInProcessRead(opts, fn) {
       embed,
       storeDegraded: true
     });
-    const workflow = new WorkflowEngine(store, project.root, project.id);
+    const workflow = new WorkflowEngine(
+      store,
+      project.root,
+      project.id,
+      resolveGateConfig(project.config)
+    );
     return await fn({ context, memory, workflow });
   } finally {
     await store.close().catch(() => {
@@ -605,13 +616,13 @@ async function daemonRestart(opts) {
 
 // src/commands/handoff.ts
 import { mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 import {
   defaultHandoffBlock,
   hostLaunchDirective,
   resolveAdapter
 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo4, NOIR_DIR } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo5, NOIR_DIR } from "@noir-ai/core";
 
 // src/commands/status.ts
 import { loadProjectInfo as loadProjectInfo3, NOIR_VERSION as NOIR_VERSION2 } from "@noir-ai/core";
@@ -728,6 +739,9 @@ function renderHuman(p, opts) {
     ],
     opts
   );
+  if (p.workflow && p.workflow.state !== "done" && p.workflow.state !== "abandoned") {
+    tip("resume: `noir task resume`", opts);
+  }
 }
 async function gatherStatusPayload(opts) {
   const project = loadProjectInfo3(process.cwd());
@@ -775,7 +789,17 @@ async function status(opts) {
 }
 
 // src/commands/task.ts
-import { PHASES } from "@noir-ai/workflow";
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import { readdirSync } from "fs";
+import { join } from "path";
+import { loadProjectInfo as loadProjectInfo4 } from "@noir-ai/core";
+import {
+  PHASES,
+  TASK_CLASSES,
+  writeChangelogStub,
+  writeDecisionStub
+} from "@noir-ai/workflow";
 var PHASE_SKILL = {
   // C3 curation (2026-08-10): intake+clarify merged into brainstorming;
   // execute → executing-plans; verify → verifying; document → wrap.
@@ -791,6 +815,24 @@ function skillFor(phase) {
   if (typeof phase !== "string") return null;
   return PHASE_SKILL[phase] ?? null;
 }
+function writeDoneArtifacts(opts, taskId) {
+  try {
+    const project = loadProjectInfo4(process.cwd());
+    const conflict = { conflictPolicy: "preserve", interactive: false };
+    writeChangelogStub(project.root, `- ${taskId}: completed (verify gate passed)`, conflict);
+    const decisionsDir = join(project.root, ".noir", "decisions");
+    let nextN = 1;
+    try {
+      const files = readdirSync(decisionsDir);
+      const nums = files.map((f) => Number.parseInt(f.replace(/\D.*$/, ""), 10)).filter((n) => Number.isFinite(n) && n > 0);
+      if (nums.length > 0) nextN = Math.max(...nums) + 1;
+    } catch {
+    }
+    writeDecisionStub(project.root, nextN, taskId, conflict);
+  } catch {
+    tip("document-phase artifacts could not be written (use --no-artifacts to skip)", opts);
+  }
+}
 async function fetchStatus(opts, taskId) {
   const args = typeof taskId === "string" && taskId.length > 0 ? { taskId } : {};
   const res = await callDaemonTool(
@@ -809,17 +851,23 @@ function formatStamp(ms) {
 function renderStatusRow(s, opts) {
   const flag = s.degraded === true ? `  ${badge("warn", "degraded")}` : "";
   log(`task status \u2014 ${s.taskId}${flag}`, opts);
-  definitionList(
-    [
-      { label: "Task", value: s.taskId },
-      { label: "Phase", value: s.phase },
-      { label: "State", value: s.state },
-      { label: "Mode", value: s.mode },
-      { label: "Next gate", value: s.nextGate ?? "\u2014" },
-      { label: "Updated", value: formatStamp(s.updatedAt) }
-    ],
-    opts
+  const rows = [
+    { label: "Task", value: s.taskId },
+    { label: "Phase", value: s.phase },
+    { label: "State", value: s.state },
+    { label: "Mode", value: s.mode }
+  ];
+  if (typeof s.taskClass === "string" && s.taskClass.length > 0) {
+    rows.push({ label: "Class", value: s.taskClass });
+  }
+  if (typeof s.blockReason === "string" && s.blockReason.length > 0) {
+    rows.push({ label: "Block reason", value: s.blockReason });
+  }
+  rows.push(
+    { label: "Next gate", value: s.nextGate ?? "\u2014" },
+    { label: "Updated", value: formatStamp(s.updatedAt) }
   );
+  definitionList(rows, opts);
 }
 var GATE_PHASES = ["spec", "plan", "verify"];
 function nextGateAfter(phase) {
@@ -912,13 +960,25 @@ async function taskNew(opts) {
     }
     mode = opts.mode;
   }
+  let taskClass;
+  if (opts.taskClass !== void 0) {
+    if (!TASK_CLASSES.includes(opts.taskClass)) {
+      fail(
+        EXIT.USAGE,
+        `task new: invalid class '${opts.taskClass}' (expected one of: ${TASK_CLASSES.join(", ")})`,
+        opts
+      );
+    }
+    taskClass = opts.taskClass;
+  }
   const res = await callDaemonTool(
     opts,
     "workflow_start",
     {
       taskId: opts.slug,
       slug: opts.slug,
-      ...mode === void 0 ? {} : { mode }
+      ...mode === void 0 ? {} : { mode },
+      ...taskClass === void 0 ? {} : { taskClass }
     }
   );
   if (res.ok !== true) {
@@ -952,6 +1012,9 @@ async function taskAdvance(opts) {
     const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "advance failed";
     fail(EXIT.ERROR, `task advance: ${detail}`, opts);
   }
+  if (res.state === "done" && opts.noArtifacts !== true) {
+    writeDoneArtifacts(opts, res.taskId);
+  }
   if (typeof opts.to === "string" && opts.to === "verify") {
     tip("run `noir handoff` for a ready-to-paste host prompt", opts);
   }
@@ -962,6 +1025,272 @@ async function taskAdvance(opts) {
   }
   renderStatusRow(res, opts);
 }
+function renderResumeBriefing(r, opts) {
+  const flag = r.degraded === true ? `  ${badge("warn", "degraded")}` : "";
+  log(`resume \u2014 ${r.taskId} (${r.state}, ${r.mode})${flag}`, opts);
+  const rows = [
+    { label: "Task", value: String(r.taskId) },
+    { label: "Phase", value: String(r.phase) },
+    { label: "State", value: String(r.state) },
+    { label: "Mode", value: String(r.mode) }
+  ];
+  if (typeof r.taskClass === "string" && r.taskClass.length > 0) {
+    rows.push({ label: "Class", value: r.taskClass });
+  }
+  if (typeof r.blockReason === "string" && r.blockReason.length > 0) {
+    rows.push({ label: "Block reason", value: r.blockReason });
+  }
+  rows.push({ label: "Next gate", value: r.nextGate ?? "\u2014" });
+  definitionList(rows, opts);
+  const suggestion = skillFor(r.phase ?? null);
+  if (suggestion) info(`skill for current phase (${r.phase}): ${suggestion}`, opts);
+  if (r.state === "blocked") {
+    info("resume a blocked task with: noir task advance --to <phase>", opts);
+  }
+}
+async function taskResume(opts) {
+  const args = {};
+  if (typeof opts.id === "string" && opts.id.length > 0) {
+    args.taskId = opts.id;
+  }
+  const res = await callDaemonTool(opts, "workflow_resume", args);
+  if (res.resumable !== true) {
+    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "nothing to resume";
+    if (opts.json === true) {
+      process.stdout.write(`${JSON.stringify({ ok: false, resumable: false, error: detail })}
+`);
+      return;
+    }
+    fail(EXIT.ERROR, `task resume: ${detail}`, opts);
+  }
+  if (typeof opts.prompt === "string" && opts.prompt.length > 0) {
+    info(`resume prompt: ${opts.prompt}`, opts);
+  }
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
+`);
+    return;
+  }
+  renderResumeBriefing(res, opts);
+}
+async function taskBlock(opts) {
+  if (typeof opts.reason !== "string" || opts.reason.trim().length === 0) {
+    fail(EXIT.USAGE, "task block: a non-empty <reason> is required", opts);
+  }
+  const args = { reason: opts.reason };
+  if (typeof opts.task === "string" && opts.task.length > 0) args.taskId = opts.task;
+  const res = await callDaemonTool(
+    opts,
+    "workflow_block",
+    args
+  );
+  if (res.ok !== true) {
+    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "block failed";
+    fail(EXIT.ERROR, `task block: ${detail}`, opts);
+  }
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
+`);
+    return;
+  }
+  renderStatusRow(res, opts);
+}
+async function taskAbandon(opts) {
+  if (isInteractive(opts)) {
+    const clack = await import("@clack/prompts");
+    const confirm = await clack.confirm({
+      message: "Abandon this task? This is terminal and cannot be undone.",
+      initialValue: false
+    });
+    if (clack.isCancel(confirm)) {
+      clack.cancel("Cancelled.");
+      fail(EXIT.CANCELLED, "cancelled", opts);
+    }
+    if (confirm !== true) {
+      fail(EXIT.CANCELLED, "abandon cancelled", opts);
+    }
+  }
+  const args = {};
+  if (typeof opts.task === "string" && opts.task.length > 0) args.taskId = opts.task;
+  const res = await callDaemonTool(
+    opts,
+    "workflow_abandon",
+    args
+  );
+  if (res.ok !== true) {
+    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "abandon failed";
+    fail(EXIT.ERROR, `task abandon: ${detail}`, opts);
+  }
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
+`);
+    return;
+  }
+  renderStatusRow(res, opts);
+}
+function runCheck(cmd) {
+  try {
+    const buf = spawnSync("sh", ["-c", cmd], {
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8"
+    });
+    let out = "";
+    if (buf.stdout) out += buf.stdout.toString();
+    if (buf.stderr) out += buf.stderr.toString();
+    const status2 = buf.status;
+    return {
+      exitCode: typeof status2 === "number" ? status2 : 1,
+      digest: createHash("sha256").update(out).digest("hex")
+    };
+  } catch {
+    return { exitCode: 1, digest: createHash("sha256").update("").digest("hex") };
+  }
+}
+async function taskVerify(opts) {
+  const project = loadProjectInfo4(process.cwd());
+  const cfgChecks = project.config.workflow?.gate?.verify?.checks ?? [];
+  const all = cfgChecks.map((c2) => ({
+    name: c2.name,
+    command: c2.command,
+    tier: c2.tier ?? "hard"
+  }));
+  let checks = all;
+  if (opts.check && opts.check.length > 0) {
+    const want = new Set(opts.check);
+    checks = all.filter((c2) => want.has(c2.name));
+    if (checks.length === 0) {
+      fail(
+        EXIT.USAGE,
+        `task verify: no configured checks match --check ${[...want].join(",")}`,
+        opts
+      );
+    }
+  }
+  if (checks.length === 0) {
+    fail(
+      EXIT.USAGE,
+      "task verify: no verify checks configured (set workflow.gate.verify.checks in noir.config)",
+      opts
+    );
+  }
+  const ranAt = Date.now();
+  const evidence = {
+    ranAt,
+    checks: checks.map((c2) => {
+      const r = runCheck(c2.command);
+      return {
+        name: c2.name,
+        exitCode: r.exitCode,
+        outputDigest: r.digest,
+        command: c2.command,
+        tier: c2.tier
+      };
+    }),
+    summary: ""
+  };
+  const passed = evidence.checks.filter((c2) => c2.exitCode === 0).length;
+  const failed = evidence.checks.length - passed;
+  evidence.summary = `${passed} passed, ${failed} failed`;
+  const res = await callDaemonTool(opts, "workflow_advance", { evidence });
+  if (res.ok === true) {
+    if (opts.json === true) {
+      process.stdout.write(`${JSON.stringify({ ok: true, data: res, evidence })}
+`);
+      return;
+    }
+    success(`verify \u2014 ${evidence.summary} \u2192 gate approved`, opts);
+    renderStatusRow(res, opts);
+    return;
+  }
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ evidence, ...res })}
+`);
+    return;
+  }
+  if (res.pendingGate) {
+    warn(`verify gate: ${res.pendingGate.reason} (${evidence.summary})`, opts);
+    const recovery = res.recovery ?? ["retry", "force", "skip", "block"];
+    info(
+      `recovery: ${recovery.map(
+        (r) => r === "retry" ? "`noir task verify`" : r === "force" ? "`noir task advance --force <reason>`" : r === "skip" ? "`noir task advance --skip`" : r === "block" ? "`noir task block <reason>`" : `\`${r}\``
+      ).join(" | ")}`,
+      opts
+    );
+  } else {
+    fail(EXIT.ERROR, `task verify: ${res.error ?? "verify failed"}`, opts);
+  }
+}
+async function taskResearch(opts) {
+  const s = await fetchStatus(opts, opts.id);
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: s })}
+`);
+    return;
+  }
+  renderStatusRow(s, opts);
+  info("research findings are recorded via `noir task research record` (list + record)", opts);
+}
+async function taskResearchRecord(opts) {
+  const TYPES = ["assumption", "discovery", "decision", "grounding-fact"];
+  if (!TYPES.includes(opts.type)) {
+    fail(
+      EXIT.USAGE,
+      `task research record: invalid type '${opts.type}' (expected one of: ${TYPES.join(", ")})`,
+      opts
+    );
+  }
+  const args = { type: opts.type, text: opts.text };
+  if (typeof opts.source === "string" && opts.source.length > 0) args.source = opts.source;
+  if (typeof opts.task === "string" && opts.task.length > 0) args.taskId = opts.task;
+  const res = await callDaemonTool(opts, "workflow_research_record", args);
+  if (res.ok !== true) {
+    const detail = typeof res.error === "string" && res.error.length > 0 ? res.error : "record failed";
+    fail(EXIT.ERROR, `task research record: ${detail}`, opts);
+  }
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: res })}
+`);
+    return;
+  }
+  success(
+    `research recorded \u2192 ${opts.type}: ${opts.text.slice(0, 80)}${opts.text.length > 80 ? "\u2026" : ""}`,
+    opts
+  );
+}
+async function taskDecompose(opts) {
+  const cap = opts.capability.trim();
+  if (cap.length === 0) fail(EXIT.USAGE, "task decompose: <capability-id> is required", opts);
+  const plan = {
+    capabilityId: cap,
+    intent: `Capability ${cap} \u2014 details TBD (run with a provider for an LLM-drafted plan)`,
+    slices: [
+      {
+        id: "s1-walking-skeleton",
+        title: "Walking skeleton \u2014 thinnest end-to-end",
+        type: "feature",
+        rationale: `The first slice for capability ${cap}.`,
+        scopeIn: "End-to-end path linking the main architecture.",
+        scopeOut: "Polish, edge cases, full coverage.",
+        dependsOn: [],
+        files: { create: [], modify: [], preserve: [] },
+        acceptance: [`verify acceptance criteria for capability ${cap}`],
+        doD: ["pnpm test", "pnpm typecheck"],
+        rollbackPlan: { procedure: "revert the slice commit", verifyCommand: "pnpm test" }
+      }
+    ],
+    status: { "s1-walking-skeleton": "planned" }
+  };
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: plan })}
+`);
+    return;
+  }
+  log(`decompose \u2014 ${cap}`, opts);
+  for (const s of plan.slices) {
+    info(`${s.id}: ${s.title} (${s.type}) \u2014 rationale: ${s.rationale}`, opts);
+  }
+  tip("each slice enters the existing clarify\u2192spec\u2192plan\u2192execute\u2192verify\u2192document FSM cycle", opts);
+}
 
 // src/commands/handoff.ts
 var SEED_LIMIT = 5;
@@ -1069,7 +1398,7 @@ function resolveDirective(root, p) {
 }
 function handoffFilePath(root, taskId, projectId) {
   const id = typeof taskId === "string" && taskId.length > 0 ? taskId : projectId;
-  return join(root, NOIR_DIR, "handoff", `${id}.md`);
+  return join2(root, NOIR_DIR, "handoff", `${id}.md`);
 }
 async function extractSeeds(opts, probe, query) {
   if (!probe.running) return { context: null, memory: null };
@@ -1101,7 +1430,7 @@ async function probeOnly(opts) {
   return probeDaemon(opts);
 }
 async function handoff(opts) {
-  const project = loadProjectInfo4(process.cwd());
+  const project = loadProjectInfo5(process.cwd());
   const host = project.config.host;
   const snapshot = await gatherStatusPayload(opts);
   const probe = await probeOnly(opts);
@@ -1135,7 +1464,7 @@ async function handoff(opts) {
   const md = renderMarkdown(full);
   if (opts.write === true) {
     const path = handoffFilePath(project.root, task?.taskId, project.id);
-    mkdirSync(join(project.root, NOIR_DIR, "handoff"), { recursive: true });
+    mkdirSync(join2(project.root, NOIR_DIR, "handoff"), { recursive: true });
     writeFileSync(path, md, "utf8");
     info(`handoff written to ${path}`, opts);
     return;
@@ -1146,7 +1475,7 @@ async function handoff(opts) {
 // src/commands/home.ts
 import { hostLaunchDirective as hostLaunchDirective2 } from "@noir-ai/adapters";
 import {
-  loadProjectInfo as loadProjectInfo5,
+  loadProjectInfo as loadProjectInfo6,
   NOIR_VERSION as NOIR_VERSION3,
   readInstallRecord
 } from "@noir-ai/core";
@@ -1444,7 +1773,7 @@ async function resolveSections(commands) {
 // src/commands/home.ts
 function tryProject() {
   try {
-    const info2 = loadProjectInfo5(process.cwd());
+    const info2 = loadProjectInfo6(process.cwd());
     return { id: info2.id, name: info2.name, host: info2.config.host };
   } catch {
     return null;
@@ -1608,7 +1937,7 @@ async function runMenu(opts, deps) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo5(process.cwd());
+        const info2 = loadProjectInfo6(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -1904,9 +2233,105 @@ async function memoryConsolidate(opts) {
   fail(EXIT.ERROR, `memory consolidate did not run: ${reason}${suffix}`, opts);
 }
 
+// src/commands/release.ts
+import { execSync, spawnSync as spawnSync2 } from "child_process";
+function describe(step, who) {
+  const m = {
+    preflight: "check clean tree, on develop, HEAD pushed, gate green, no version collision",
+    bump: "run bump-version.mjs + update CHANGELOG + roadmap docs",
+    gate: "re-run the full gate (lint/build/typecheck/test/docs:validate)",
+    commit: "commit chore(release) + push develop",
+    "ci-develop": "wait for CI on develop \u2192 green",
+    "beta-tag": "pnpm release:tag \u2192 beta tag + push",
+    "human-approve-beta": "approve the release workflow publish job in GitHub Actions",
+    "merge-main": "merge develop \u2192 main (fast-forward) + push",
+    "ci-main": "wait for CI on main \u2192 green",
+    "stable-tag": "pnpm release:tag \u2192 stable tag + push",
+    "human-approve-stable": "approve the release workflow publish job in GitHub Actions (again)",
+    "dist-bump": "update Homebrew (packaging/homebrew/noir.rb) + Scoop (packaging/scoop/noir.json) from npm",
+    sync: "merge main \u2192 develop + verify both branches at same SHA"
+  };
+  return `${m[step]} [${who}]`;
+}
+var ALL = [
+  "preflight",
+  "bump",
+  "gate",
+  "commit",
+  "ci-develop",
+  "beta-tag",
+  "human-approve-beta",
+  "merge-main",
+  "ci-main",
+  "stable-tag",
+  "human-approve-stable",
+  "dist-bump",
+  "sync"
+];
+async function release(opts) {
+  if (opts.dryRun) {
+    log("noir release --dry-run (no changes will be made)", opts);
+    for (const s of ALL) {
+      const who = s.startsWith("human-approve") ? "human" : "noir";
+      info(`${s}: ${describe(s, who)}`, opts);
+    }
+    tip('full release flow documented in CLAUDE.md "Patch release flow (beta \u2192 stable)"', opts);
+    return;
+  }
+  const version = opts.version?.trim();
+  if (!version) {
+    fail(EXIT.USAGE, "release: <version> is required (e.g. noir release 1.10.0)", opts);
+  }
+  const channel = opts.channel === "stable" ? "stable" : "beta";
+  log(`noir release ${version} (${channel} channel)`, opts);
+  try {
+    info(`[1/13] preflight: ${describe("preflight", "noir")}`, opts);
+    execSync("git diff --quiet", { encoding: "utf8" });
+    const branch = execSync("git branch --show-current", { encoding: "utf8" }).trim();
+    if (branch !== "develop") fail(EXIT.ERROR, "release: must be on develop", opts);
+    const status2 = execSync("git status --porcelain", { encoding: "utf8" }).trim();
+    if (status2) fail(EXIT.ERROR, "release: tree must be clean", opts);
+    success("preflight: \u2713 clean, on develop", opts);
+    info(`[2/13] bump: ${describe("bump", "noir")}`, opts);
+    spawnSync2("node", ["scripts/bump-version.mjs", version], {
+      encoding: "utf8",
+      stdio: "inherit"
+    });
+    success(`bump: \u2713 version ${version}`, opts);
+    info(`[3/13] gate: ${describe("gate", "noir")}`, opts);
+    execSync("pnpm lint && pnpm build && pnpm typecheck && pnpm test && pnpm docs:validate", {
+      encoding: "utf8",
+      stdio: "inherit"
+    });
+    success("gate: \u2713 full gate green", opts);
+    info(`[4/13] commit/push: ${describe("commit", "noir")}`, opts);
+    spawnSync2("git", ["add", "-A"], { encoding: "utf8", stdio: "inherit" });
+    spawnSync2("git", ["commit", "-m", `chore(release): v${version} + docs sync`], {
+      encoding: "utf8",
+      stdio: "inherit"
+    });
+    execSync("git push origin develop", { encoding: "utf8" });
+    success("commit: \u2713 pushed to develop", opts);
+    info(`[5/13] ci-develop: waiting for CI on develop\u2026`, opts);
+    info(`[6/13] beta-tag: ${describe("beta-tag", "noir")}`, opts);
+    tip("after CI green: run `pnpm release:tag` and push the beta tag", opts);
+    warn(`[7/13] ${describe("human-approve-beta", "human")}`, opts);
+    tip("open GitHub Actions \u2192 approve the publish job, then continue", opts);
+    tip("after approval: verify `npm view @noir-ai/cli dist-tags beta` = beta version", opts);
+    info("remaining steps (merge\u2192stable\u2192dist\u2192sync): see CLAUDE.md", opts);
+    for (const s of ALL.slice(7)) {
+      const who = s.startsWith("human-approve") ? "human" : "noir";
+      info(`  ${s}: ${describe(s, who)}`, opts);
+    }
+    success(`release ${version}: preflight\u2192bump\u2192gate\u2192commit done. Resume after approval.`, opts);
+  } catch (err) {
+    fail(EXIT.ERROR, `release failed: ${err instanceof Error ? err.message : String(err)}`, opts);
+  }
+}
+
 // src/commands/skills.ts
 import { claudeAdapter } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo6 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo7 } from "@noir-ai/core";
 import {
   buildRegistry,
   discoverAll,
@@ -2000,7 +2425,7 @@ async function skillsList(opts) {
 }
 async function skillsSync(opts) {
   const root = process.cwd();
-  const project = loadProjectInfo6(root);
+  const project = loadProjectInfo7(root);
   if (!claudeAdapter.skillsDir) {
     const data2 = {
       emitted: [],
@@ -2467,15 +2892,20 @@ function createProgram() {
     throw new NoirCliError(EXIT.USAGE, "Usage: noir skills list|sync|lint|registry");
   });
   const taskGrp = program2.command("task").description("workflow task control");
-  taskGrp.command("new").description("start a new workflow task").requiredOption("--slug <slug>", "task slug").option("--mode <mode>", "full | quick").action(async (...args) => {
+  taskGrp.command("new").description("start a new workflow task").requiredOption("--slug <slug>", "task slug").option("--mode <mode>", "full | quick").option(
+    "--class <taskClass>",
+    "task class (feature/epic/enhancement/bugfix/spike/quick-task/refactor) \u2014 drives the PRD gate"
+  ).action(async (...args) => {
     const cmd = trailingCmd(args);
     const g = cmd.optsWithGlobals();
     const slug = typeof g.slug === "string" ? g.slug : "";
     const mode = typeof g.mode === "string" ? g.mode : void 0;
+    const taskClass = typeof g.class === "string" ? g.class : void 0;
     await taskNew({
       ...toCliOptions(g),
       slug,
-      ...mode === void 0 ? {} : { mode }
+      ...mode === void 0 ? {} : { mode },
+      ...taskClass === void 0 ? {} : { taskClass }
     });
   });
   taskGrp.command("status").description("active (or named) task status").argument("[id]", "task id (defaults to active)").action(async (...args) => {
@@ -2488,7 +2918,7 @@ function createProgram() {
       ...id === void 0 ? {} : { id }
     });
   });
-  taskGrp.command("advance").description("advance the active task to the next phase").option("--to <phase>", "target phase").option("--force <reason>", "force the gate with a reason").action(async (...args) => {
+  taskGrp.command("advance").description("advance the active task to the next phase").option("--to <phase>", "target phase").option("--force <reason>", "force the gate with a reason").option("--no-artifacts", "skip the document-phase artifact writes at done").action(async (...args) => {
     const cmd = trailingCmd(args);
     const g = cmd.optsWithGlobals();
     const to = typeof g.to === "string" ? g.to : void 0;
@@ -2496,14 +2926,99 @@ function createProgram() {
     await taskAdvance({
       ...toCliOptions(g),
       ...to === void 0 ? {} : { to },
-      ...force === void 0 ? {} : { force }
+      ...force === void 0 ? {} : { force },
+      ...g.artifacts === false ? { noArtifacts: true } : {}
     });
   });
   taskGrp.command("next").description("suggest the next phase + applicable skill").action(async (...args) => {
     await taskNext(toCliOptions(trailingCmd(args).optsWithGlobals()));
   });
+  taskGrp.command("decompose").description(
+    "decompose a capability into buildable slices (template-only offline; see the spec)"
+  ).argument("<capability>", "capability id, e.g. C4").option("--out <path>", "output path for the SlicePlan JSON").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const capability = typeof args[0] === "string" ? args[0] : "";
+    await taskDecompose({
+      ...toCliOptions(g),
+      capability,
+      ...typeof g.out === "string" && g.out.length > 0 ? { out: g.out } : {}
+    });
+  });
+  taskGrp.command("verify").description("run configured verify checks and submit evidence to the verify gate").option(
+    "--check <name>",
+    "restrict to a named check (repeatable)",
+    (val, acc) => [...acc, val],
+    []
+  ).action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const check = Array.isArray(g.check) ? g.check : void 0;
+    await taskVerify({
+      ...toCliOptions(g),
+      ...check === void 0 || check.length === 0 ? {} : { check }
+    });
+  });
+  taskGrp.command("research").description("list research findings for the active (or named) task").argument("[id]", "task id (defaults to active)").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const first = args[0];
+    const id = typeof first === "string" ? first : void 0;
+    await taskResearch({
+      ...toCliOptions(g),
+      ...id === void 0 ? {} : { id }
+    });
+  });
+  taskGrp.command("research-record").description("record a research finding for the active (or named) task").requiredOption("--type <type>", "assumption | discovery | decision | grounding-fact").requiredOption("--text <text>", "finding text (capped)").option("--source <ref>", "evidence/citation (required unless grounding-fact)").option("--task <id>", "task id (defaults to active)").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    await taskResearchRecord({
+      ...toCliOptions(g),
+      type: String(g.type ?? ""),
+      text: String(g.text ?? ""),
+      ...typeof g.source === "string" && g.source.length > 0 ? { source: g.source } : {},
+      ...typeof g.task === "string" && g.task.length > 0 ? { task: g.task } : {}
+    });
+  });
+  taskGrp.command("resume").description("resume the active (or named) in-flight/blocked task").argument("[id]", "task id (defaults to active)").option("--last", "target the active task explicitly (scripting)").option("--prompt <text>", "a continue instruction to surface in the briefing").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const first = args[0];
+    const id = typeof first === "string" ? first : void 0;
+    const last = g.last === true;
+    const prompt = typeof g.prompt === "string" ? g.prompt : void 0;
+    await taskResume({
+      ...toCliOptions(g),
+      ...id === void 0 ? {} : { id },
+      ...last ? { last } : {},
+      ...prompt === void 0 ? {} : { prompt }
+    });
+  });
+  taskGrp.command("block").description("mark the active (or named) task blocked with a reason").argument("<reason>", "why the task is stuck (non-empty)").option("--task <id>", "task id (defaults to active)").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const reason = typeof args[0] === "string" ? args[0] : "";
+    const task = typeof g.task === "string" ? g.task : void 0;
+    await taskBlock({
+      ...toCliOptions(g),
+      reason,
+      ...task === void 0 ? {} : { task }
+    });
+  });
+  taskGrp.command("abandon").description("abandon the active (or named) task (terminal, confirmed)").option("--task <id>", "task id (defaults to active)").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const task = typeof g.task === "string" ? g.task : void 0;
+    await taskAbandon({
+      ...toCliOptions(g),
+      ...task === void 0 ? {} : { task }
+    });
+  });
   taskGrp.action(() => {
-    throw new NoirCliError(EXIT.USAGE, "Usage: noir task new|status|advance|next");
+    throw new NoirCliError(
+      EXIT.USAGE,
+      "Usage: noir task new|status|advance|next|verify|research|research-record|resume|block|abandon"
+    );
   });
   const installCmd = program2.command("install").description(
     "install Noir via the native managed-Node path (or migrate from another install method)"
@@ -2538,6 +3053,16 @@ function createProgram() {
   program2.command("wrap").description("session-end alias for `noir handoff`").option("--write", "persist to .noir/handoff/<id>.md (gitignored)").action(async (...args) => {
     await handoff(buildHandoffOptions(trailingCmd(args).optsWithGlobals()));
   });
+  program2.command("release").description("guided release orchestrator over the patch-release flow").argument("[version]", "target version, e.g. 1.10.0").option("--channel <channel>", "beta (default) | stable").option("--dry-run", "print the checklist without executing any steps").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    await release({
+      ...toCliOptions(g),
+      ...typeof args[0] === "string" && args[0].length > 0 ? { version: args[0] } : {},
+      ...typeof g.channel === "string" && g.channel.length > 0 ? { channel: g.channel } : {},
+      ...g.dryRun === true ? { dryRun: true } : {}
+    });
+  });
   program2.command("tui").description("interactive Ink dashboard (host \xB7 phase \xB7 daemon + /command dispatch)").action(async (...args) => {
     const g = actionGlobals(args);
     const opts = toCliOptions(g);