nccgs 2.1.1 → 3.0.0-rc.2

package/runtime/hooks/unity-transport.mjs

@@ -0,0 +1,12 @@
+// Unity transport policy: direct CLI + com.unity.pipeline only. No Unity MCP servers,
+// no Coplay/AnkleBreaker, no `unity mcp` mode, no registering them through Claude/Codex.
+export const PROVIDER = /mcp-?for-?unity|unity[-_. ]?mcp|coplay|anklebreaker|unitymcp/i;
+
+export function unityMcpViolation(cmd) {
+  if (!cmd) return null;
+  if (/\bunity(\.exe)?\s+mcp\b/i.test(cmd)) return "`unity mcp` mode is disabled; use `unity command` / Pipeline directly";
+  if (/\b(claude|codex)\s+mcp\s+add(-json)?\b/i.test(cmd) && PROVIDER.test(cmd)) return "registering a Unity MCP server is disabled";
+  if (/\b(uvx|uv|pipx?|pip3|npx|npm|pnpm|bunx)\b/i.test(cmd) && PROVIDER.test(cmd)) return "installing or launching a Unity MCP server is disabled";
+  if (/\bgit\s+clone\b/i.test(cmd) && PROVIDER.test(cmd)) return "cloning a Unity MCP server is disabled";
+  return null;
+}

package/runtime/modes.json

@@ -0,0 +1,39 @@
+{
+  "schemaVersion": 1,
+  "builtin": true,
+  "agents": ["coordinator", "implementer", "reviewer", "fast-fix", "scout", "playtester"],
+  "modes": {
+    "FAST": {
+      "description": "Cheapest. Sonnet everywhere, Haiku for scouting. Good for prototypes and small fixes.",
+      "coordinator": { "model": "sonnet", "effort": "medium" },
+      "implementer": { "model": "sonnet", "effort": "high" },
+      "reviewer":    { "model": "sonnet", "effort": "high", "fallback": null },
+      "fast-fix":    { "model": "sonnet", "effort": "medium" },
+      "scout":       { "model": "haiku",  "effort": null },
+      "playtester":  { "model": "sonnet", "effort": "medium" }
+    },
+    "BALANCE": {
+      "description": "Default. Opus for the coordinator, implementer and reviewer; Sonnet for support agents.",
+      "coordinator": { "model": "opus",   "effort": "high" },
+      "implementer": { "model": "opus",   "effort": "high" },
+      "reviewer":    { "model": "opus",   "effort": "high", "fallback": null },
+      "fast-fix":    { "model": "sonnet", "effort": "high" },
+      "scout":       { "model": "sonnet", "effort": "medium" },
+      "playtester":  { "model": "sonnet", "effort": "high" }
+    },
+    "PERFORMANCE": {
+      "description": "Strongest. Opus/xhigh for building, Fable/high for independent review (falls back to Opus/xhigh when Fable is unavailable).",
+      "coordinator": { "model": "opus",   "effort": "xhigh" },
+      "implementer": { "model": "opus",   "effort": "xhigh" },
+      "reviewer":    { "model": "fable",  "effort": "high", "fallback": { "model": "opus", "effort": "xhigh" } },
+      "fast-fix":    { "model": "sonnet", "effort": "high" },
+      "scout":       { "model": "sonnet", "effort": "medium" },
+      "playtester":  { "model": "sonnet", "effort": "high" }
+    }
+  },
+  "allowed": {
+    "models": ["haiku", "sonnet", "opus", "fable", "inherit"],
+    "efforts": ["low", "medium", "high", "xhigh", "max"],
+    "notes": "A full model ID (claude-...) is also accepted. Unusual model/effort combinations warn, they do not fail."
+  }
+}

package/runtime/task/cost.mjs

@@ -0,0 +1,103 @@
+// Token cost per task, read from the Claude Code transcripts the hooks recorded (session.start and
+// agent.* events carry transcript paths). Every assistant message in [openedAt, closedAt] counts once
+// (deduplicated by message id); subagent transcripts under <session>/subagents/ count too and are
+// attributed to the agent name the SubagentStart event recorded for that agentId.
+// Tokens are the fact. Dollars are an estimate from config.pricing (per million tokens) and only
+// appear for models that have a price row.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { at, loadConfig } from "../core/project.mjs";
+import { exists, readText } from "../core/fs.mjs";
+
+const USAGE_KEYS = ["input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens", "output_tokens"];
+
+export function readEvents(root) {
+  const text = readText(at(root, "events"), "");
+  const out = [];
+  for (const line of text.split("\n")) { if (!line.trim()) continue; try { out.push(JSON.parse(line)); } catch {} }
+  return out;
+}
+
+// Transcript files that can hold messages for this project: the session transcripts named by hooks
+// and every subagent transcript beside them.
+// Sessions recorded before transcript paths were logged (alpha.6 and earlier) are found by session id
+// under ~/.claude/projects/*/<sessionId>.jsonl.
+function findBySessionId(sessionId) {
+  const base = path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"), "projects");
+  if (!exists(base)) return null;
+  for (const dir of fs.readdirSync(base)) {
+    const f = path.join(base, dir, `${sessionId}.jsonl`);
+    if (exists(f)) return f;
+  }
+  return null;
+}
+
+export function transcriptFiles(root, events = readEvents(root)) {
+  const files = new Set();
+  const sessions = new Set();
+  for (const e of events) {
+    for (const p of [e.transcriptPath, e.agentTranscriptPath]) if (p && exists(p)) files.add(path.resolve(p));
+    if (e.sessionId && !e.transcriptPath) sessions.add(e.sessionId);
+  }
+  for (const id of sessions) { const f = findBySessionId(id); if (f) files.add(f); }
+  for (const f of [...files]) {
+    const dir = path.join(path.dirname(f), path.basename(f, ".jsonl"), "subagents");
+    if (exists(dir)) for (const n of fs.readdirSync(dir)) if (n.endsWith(".jsonl")) files.add(path.join(dir, n));
+  }
+  return [...files];
+}
+
+function* assistantMessages(file) {
+  let text;
+  try { text = fs.readFileSync(file, "utf8"); } catch { return; }
+  for (const line of text.split("\n")) {
+    if (!line.includes('"assistant"')) continue;
+    let j; try { j = JSON.parse(line); } catch { continue; }
+    if (j.type !== "assistant" || !j.message?.usage) continue;
+    yield { id: j.message.id ?? j.uuid, at: Date.parse(j.timestamp), model: j.message.model ?? "unknown", agentId: j.agentId ?? null, usage: j.message.usage };
+  }
+}
+
+const empty = () => ({ input: 0, cacheWrite: 0, cacheRead: 0, output: 0, messages: 0 });
+function add(acc, u) {
+  acc.input += u.input_tokens ?? 0; acc.cacheWrite += u.cache_creation_input_tokens ?? 0; acc.cacheRead += u.cache_read_input_tokens ?? 0; acc.output += u.output_tokens ?? 0; acc.messages += 1;
+}
+
+export function taskCost(root, task, { events = readEvents(root), config = loadConfig(root) } = {}) {
+  const from = Date.parse(task.openedAt), to = task.closedAt ? Date.parse(task.closedAt) : Date.now();
+  const agentNames = new Map();
+  for (const e of events) if (e.type === "agent.start" && e.agentId && e.agent) agentNames.set(e.agentId, e.agent);
+  const files = transcriptFiles(root, events);
+  const seen = new Set();
+  const byModel = {}, byAgent = {};
+  const total = empty();
+  for (const file of files) {
+    for (const m of assistantMessages(file)) {
+      if (!(m.at >= from && m.at <= to) || seen.has(m.id)) continue;
+      seen.add(m.id);
+      const agent = m.agentId ? (agentNames.get(m.agentId) ?? "subagent") : "coordinator";
+      byModel[m.model] ??= empty(); add(byModel[m.model], m.usage);
+      byAgent[agent] ??= empty(); add(byAgent[agent], m.usage);
+      add(total, m.usage);
+    }
+  }
+  const pricing = config.pricing ?? {};
+  let usd = 0, priced = 0;
+  for (const [model, t] of Object.entries(byModel)) {
+    const row = priceFor(model, pricing);
+    if (!row) continue;
+    priced++;
+    usd += (t.input * row.input + t.cacheWrite * row.cacheWrite + t.cacheRead * row.cacheRead + t.output * row.output) / 1e6;
+  }
+  return { total, byModel, byAgent, transcripts: files.length, estimatedUsd: priced ? Number(usd.toFixed(4)) : null, pricedModels: priced, unpricedModels: Object.keys(byModel).length - priced };
+}
+
+// pricing rows are keyed by a substring of the model id ("opus", "sonnet", "claude-haiku-5-5").
+function priceFor(model, pricing) {
+  const keys = Object.keys(pricing).sort((a, b) => b.length - a.length);
+  const k = keys.find(k => model.includes(k));
+  return k ? pricing[k] : null;
+}
+
+export const fmtTokens = n => n >= 1e6 ? `${(n / 1e6).toFixed(2)}M` : n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);

package/runtime/task/criteria.mjs

@@ -0,0 +1,128 @@
+// Acceptance criteria: each criterion owns assertions against evidence artifacts that
+// Unity (through `task verify`) produced. Claude writes criteria; it never writes artifacts.
+//
+// Assertion: { artifact, pointer?, op, value?, min?, max? }
+//   op: eq | gte | lte | exists | contains | range | image
+//   artifact: path relative to the project (usually under .nccgs/evidence/)
+//   pointer: JSON pointer into a JSON artifact (eq/gte/lte/contains/range)
+import fs from "node:fs";
+import path from "node:path";
+import { readJson, exists } from "../core/fs.mjs";
+
+export const OPS = ["eq", "gte", "lte", "exists", "contains", "range", "image"];
+
+export function validateCriteria(criteria) {
+  const problems = [];
+  if (!Array.isArray(criteria) || criteria.length === 0) problems.push("criteria must be a non-empty array");
+  const ids = new Set();
+  for (const [i, c] of (criteria ?? []).entries()) {
+    const where = `criteria[${i}]`;
+    if (!c?.id || typeof c.id !== "string") problems.push(`${where}.id is required`);
+    else if (ids.has(c.id)) problems.push(`${where}.id duplicates ${c.id}`); else ids.add(c.id);
+    if (!c?.description) problems.push(`${where}.description is required`);
+    if (c?.kind === "manual") continue;             // decided by a person at close time
+    if (!Array.isArray(c?.assertions) || !c.assertions.length) { problems.push(`${where}.assertions must be a non-empty array (or kind: "manual")`); continue; }
+    for (const [j, a] of c.assertions.entries()) {
+      const w = `${where}.assertions[${j}]`;
+      if (!a?.artifact) problems.push(`${w}.artifact is required`);
+      if (!OPS.includes(a?.op)) problems.push(`${w}.op must be one of ${OPS.join("|")}`);
+      if (["eq", "gte", "lte", "contains"].includes(a?.op) && !("value" in (a ?? {}))) problems.push(`${w}.value is required for ${a?.op}`);
+      if (["eq", "gte", "lte", "contains", "range"].includes(a?.op) && typeof a?.pointer !== "string") problems.push(`${w}.pointer is required for ${a?.op}`);
+      if (a?.op === "range" && !(Number.isFinite(a.min) || Number.isFinite(a.max))) problems.push(`${w} range needs min and/or max`);
+    }
+  }
+  return problems;
+}
+
+function pointer(value, ptr) {
+  if (!ptr || ptr === "/") return value;
+  let cur = value;
+  for (const raw of ptr.split("/").slice(1)) {
+    const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (cur === null || typeof cur !== "object") return undefined;
+    cur = Array.isArray(cur) ? cur[Number(key)] : cur[key];
+  }
+  return cur;
+}
+
+function pngSize(file) {
+  try {
+    const fd = fs.openSync(file, "r"); const head = Buffer.alloc(24); fs.readSync(fd, head, 0, 24, 0); fs.closeSync(fd);
+    if (head.toString("hex", 0, 8) !== "89504e470d0a1a0a") return null;
+    return { width: head.readUInt32BE(16), height: head.readUInt32BE(20) };
+  } catch { return null; }
+}
+
+// Evaluate one assertion against the project. Returns { status: PASS|FAIL|UNVERIFIED, actual, reason }.
+export function evaluateAssertion(root, a) {
+  const file = path.resolve(root, a.artifact);
+  if (!exists(file)) return { status: "UNVERIFIED", reason: `artifact missing: ${a.artifact}` };
+  if (a.op === "exists") {
+    const size = fs.statSync(file).size;
+    return size > 0 ? { status: "PASS", actual: size } : { status: "FAIL", actual: 0, reason: "artifact is empty" };
+  }
+  if (a.op === "image") {
+    const size = pngSize(file);
+    if (!size) return { status: "FAIL", reason: "not a PNG" };
+    const min = a.minWidth ?? 64;
+    const ok = size.width >= min && size.height >= Math.min(min, 64) && fs.statSync(file).size > 200;
+    return ok ? { status: "PASS", actual: size } : { status: "FAIL", actual: size, reason: `image smaller than ${min}px` };
+  }
+  let json;
+  try { json = readJson(file); } catch (e) { return { status: "UNVERIFIED", reason: e.message }; }
+  const actual = pointer(json, a.pointer);
+  if (actual === undefined) return { status: "UNVERIFIED", reason: `pointer ${a.pointer} not found` };
+  switch (a.op) {
+    case "eq": return actual === a.value ? { status: "PASS", actual } : { status: "FAIL", actual, reason: `expected ${JSON.stringify(a.value)}` };
+    case "gte": return typeof actual === "number" && actual >= a.value ? { status: "PASS", actual } : { status: "FAIL", actual, reason: `expected >= ${a.value}` };
+    case "lte": return typeof actual === "number" && actual <= a.value ? { status: "PASS", actual } : { status: "FAIL", actual, reason: `expected <= ${a.value}` };
+    case "range": {
+      const ok = typeof actual === "number" && (!Number.isFinite(a.min) || actual >= a.min) && (!Number.isFinite(a.max) || actual <= a.max);
+      return ok ? { status: "PASS", actual } : { status: "FAIL", actual, reason: `expected within [${a.min ?? "-inf"}, ${a.max ?? "inf"}]` };
+    }
+    case "contains": {
+      const hay = Array.isArray(actual) ? actual : String(actual);
+      const ok = Array.isArray(hay) ? hay.includes(a.value) : hay.includes(String(a.value));
+      return ok ? { status: "PASS", actual } : { status: "FAIL", actual, reason: `expected to contain ${JSON.stringify(a.value)}` };
+    }
+    default: return { status: "UNVERIFIED", reason: `unknown op ${a.op}` };
+  }
+}
+
+// Evaluate all criteria. A criterion passes only when every assertion passes.
+// `task close --decide id=pass|accepted|yes|ok` all mean accepted; fail|rejected|no mean rejected.
+export function normalizeDecision(d) {
+  const v = String(d ?? "").trim().toLowerCase();
+  if (["accepted", "accept", "pass", "passed", "yes", "ok", "true"].includes(v)) return "accepted";
+  if (["rejected", "reject", "fail", "failed", "no", "false"].includes(v)) return "rejected";
+  return v || null;
+}
+
+export function evaluate(root, criteria, { manualDecisions = {} } = {}) {
+  const rows = criteria.map(c => {
+    if (c.kind === "manual") {
+      const d = normalizeDecision(manualDecisions[c.id]);
+      return { id: c.id, description: c.description, kind: "manual", status: d === "accepted" ? "PASS" : d === "rejected" ? "FAIL" : "PENDING", assertions: [] };
+    }
+    const results = c.assertions.map(a => ({ ...a, ...evaluateAssertion(root, a) }));
+    const status = results.every(r => r.status === "PASS") ? "PASS" : results.some(r => r.status === "FAIL") ? "FAIL" : "UNVERIFIED";
+    return { id: c.id, description: c.description, status, assertions: results };
+  });
+  const summary = { total: rows.length, pass: rows.filter(r => r.status === "PASS").length, fail: rows.filter(r => r.status === "FAIL").length, unverified: rows.filter(r => r.status === "UNVERIFIED").length, pending: rows.filter(r => r.status === "PENDING").length };
+  return { rows, summary, allPass: summary.pass === summary.total };
+}
+
+// Default observation criteria added when a task touches what the player sees.
+export function defaultObserveCriteria(taskId) {
+  const m = `.nccgs/evidence/measurements/${taskId}-observe.json`;
+  return [{
+    id: "observe", description: "The game enters Play Mode without exceptions and a screenshot of the Game view is captured",
+    assertions: [
+      { artifact: m, pointer: "/enteredPlayMode", op: "eq", value: true },
+      { artifact: m, pointer: "/exceptionCount", op: "eq", value: 0 },
+      { artifact: `.nccgs/evidence/screens/${taskId}/01.png`, op: "image" }
+    ]
+  }];
+}
+
+export const PLAYER_VISIBLE = /(^|\/)(Assets\/.*\.(unity|prefab|uxml|uss|shader|shadergraph|mat|anim|controller)|Assets\/(UI|Scenes|Prefabs)\/)/i;

package/runtime/task/feedback.mjs

@@ -0,0 +1,136 @@
+// nccgs feedback: one bundle a person can send after days of use — what ran, what failed, what was
+// blocked, how long and how many tokens each task took, the doctor's view and any note they add.
+// Everything comes from local files (ledger, events, diagnostics, reports); no code, no screenshots,
+// no transcripts, no secrets. Nothing is uploaded: the bundle is written under .nccgs/feedback/ and
+// the person decides where it goes.
+import path from "node:path";
+import os from "node:os";
+import { writeJson, writeText, readText, exists, toPosix, appendLine } from "../core/fs.mjs";
+import { at, loadConfig, editorVersion, pipelineVersion } from "../core/project.mjs";
+import { listTasks } from "../task/ledger.mjs";
+import { readEvents, taskCost, fmtTokens } from "../task/cost.mjs";
+import { readDiag } from "../core/diag.mjs";
+import { inScope } from "../core/snapshot.mjs";
+import { readJson } from "../core/fs.mjs";
+import { fileURLToPath } from "node:url";
+import { evaluate, markSent } from "../core/feedback-policy.mjs";
+
+// the runtime is installed into the project; its version is in install-state.json, falling back to the package
+function nccgsVersion(root) { try { return readJson(at(root, "installState")).version; } catch { try { return readJson(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json")).version; } catch { return "unknown"; } } }
+
+const DAY = 86400000;
+const count = (arr, key) => arr.reduce((m, x) => { const k = key(x); m[k] = (m[k] ?? 0) + 1; return m; }, {});
+
+export async function buildBundle(root, { sinceDays = 14, note = "", withReports = false, doctor = null, trigger = "manual", reasons = [] } = {}) {
+  const sinceMs = Date.now() - sinceDays * DAY;
+  const config = loadConfig(root);
+  const events = readEvents(root).filter(e => Date.parse(e.at) >= sinceMs);
+  const diags = readDiag(root, { sinceMs });
+  const tasks = listTasks(root).filter(t => Date.parse(t.updatedAt ?? t.openedAt) >= sinceMs);
+  const taskRows = tasks.map(t => {
+    let cost = null; try { cost = taskCost(root, t); } catch {}
+    const verifications = t.verifications ?? [];
+    return {
+      id: t.id, title: t.title, rigor: t.rigor, mode: t.mode, status: t.status, outcome: t.outcome ?? null, fromPlan: !!t.fromPlan,
+      openedAt: t.openedAt, closedAt: t.closedAt ?? null, minutes: t.closedAt ? Math.round((Date.parse(t.closedAt) - Date.parse(t.openedAt)) / 60000) : null,
+      criteria: (t.criteria ?? []).length, manualCriteria: (t.criteria ?? []).filter(c => c.kind === "manual").length,
+      verifications: { total: verifications.length, failed: verifications.filter(v => !v.ok).length, byKind: count(verifications, v => v.kind) },
+      reviews: (t.reviews ?? []).map(r => ({ verdict: r.verdict, model: r.model, findings: count(r.findings ?? [], f => (f.severity ?? "INFO").toUpperCase()), resolved: (r.findings ?? []).filter(f => f.resolved).length })),
+      fixRounds: `${t.fixRounds}/${t.maxFixRounds}`,
+      changedFiles: (t.changedFiles ?? []).length, outsideContract: (t.changedFiles ?? []).filter(f => !inScope(f, t.files)).length,
+      tokens: cost?.total?.messages ? { in: cost.total.input + cost.total.cacheWrite + cost.total.cacheRead, cached: cost.total.cacheRead, out: cost.total.output, messages: cost.total.messages, byAgent: Object.fromEntries(Object.entries(cost.byAgent).map(([k, v]) => [k, v.output])) } : null
+    };
+  });
+  let doc = null;
+  if (doctor) { try { doc = await doctor(root); doc = { summary: doc.summary, checks: doc.checks.map(c => ({ id: c.id, status: c.status, message: c.message })) }; } catch (e) { doc = { error: e.message }; } }
+  const bundle = {
+    schemaVersion: 1, generatedAt: new Date().toISOString(), sinceDays, trigger, reasons,
+    nccgs: nccgsVersion(root), node: process.version, platform: `${os.platform()} ${os.release()} ${os.arch()}`,
+    project: { editor: editorVersion(root), pipeline: pipelineVersion(root), mode: config.mode, rigor: config.rigor, autonomy: config.autonomy, reportLanguage: config.report?.language ?? "en" },
+    doctor: doc,
+    totals: {
+      tasks: taskRows.length, closed: taskRows.filter(t => t.status === "closed").length, byOutcome: count(taskRows.filter(t => t.status === "closed"), t => t.outcome),
+      verifications: taskRows.reduce((a, t) => a + t.verifications.total, 0), failedVerifications: taskRows.reduce((a, t) => a + t.verifications.failed, 0),
+      fixRounds: taskRows.reduce((a, t) => a + Number(t.fixRounds.split("/")[0]), 0),
+      tokensOut: taskRows.reduce((a, t) => a + (t.tokens?.out ?? 0), 0),
+      sessions: events.filter(e => e.type === "session.start").length,
+      agentRuns: count(events.filter(e => e.type === "agent.start"), e => e.agent || "unknown"),
+      diagnostics: count(diags, d => d.kind)
+    },
+    tasks: taskRows,
+    diagnostics: diags.slice(-300),
+    updateNotices: exists(at(root, "updateCheck")) ? JSON.parse(readText(at(root, "updateCheck"), "{}")).notices ?? [] : [],
+    state: readText(at(root, "state"), "").split("\n").filter(l => l.startsWith("- ")).slice(0, 30),
+    note: note || null,
+    reports: withReports ? Object.fromEntries(tasks.filter(t => t.report && exists(path.resolve(root, t.report))).map(t => [t.id, readText(path.resolve(root, t.report), "")])) : undefined
+  };
+  const stamp = new Date().toISOString().slice(0, 19).replace(/[:T]/g, "-").slice(0, 16);
+  const dir = path.join(at(root, "nccgs"), "feedback");
+  const jsonFile = path.join(dir, `nccgs-feedback-${stamp}.json`);
+  const mdFile = path.join(dir, `nccgs-feedback-${stamp}.md`);
+  writeJson(jsonFile, bundle);
+  writeText(mdFile, renderSummary(bundle));
+  return { jsonFile, mdFile, bundle };
+}
+
+const MAX_BYTES = 512 * 1024;
+
+// POST the bundle to the configured endpoint. Never throws; the outcome is appended to
+// .nccgs/feedback/sent.jsonl so a person can see what left the machine and when.
+export async function sendBundle(root, { bundle, markdown, endpoint = loadConfig(root).feedback?.endpoint, timeoutMs = 10000 } = {}) {
+  const log = path.join(at(root, "nccgs"), "feedback", "sent.jsonl");
+  const record = async r => { try { appendLine(log, JSON.stringify({ at: new Date().toISOString(), endpoint, ...r })); } catch {} return r; };
+  if (!endpoint) return record({ ok: false, reason: "no endpoint configured" });
+  let body = JSON.stringify({ bundle, markdown });
+  if (body.length > MAX_BYTES) { body = JSON.stringify({ bundle: { ...bundle, diagnostics: bundle.diagnostics.slice(-50), reports: undefined, truncated: true }, markdown }); }
+  if (body.length > MAX_BYTES) return record({ ok: false, reason: `bundle too large (${body.length} bytes)` });
+  const ctl = new AbortController(); const t = setTimeout(() => ctl.abort(), timeoutMs);
+  try {
+    const r = await fetch(endpoint, { method: "POST", headers: { "content-type": "application/json", "user-agent": `nccgs/${bundle.nccgs}` }, body, signal: ctl.signal });
+    const text = await r.text().catch(() => "");
+    let id = null; try { id = JSON.parse(text).id ?? null; } catch {}
+    if (!r.ok) return record({ ok: false, status: r.status, reason: text.slice(0, 200) });
+    markSent(root);
+    return record({ ok: true, status: r.status, id, bytes: body.length });
+  } catch (e) { return record({ ok: false, reason: e.name === "AbortError" ? "timeout" : e.message }); }
+  finally { clearTimeout(t); }
+}
+
+// Called by hooks and `task close`: decide, and either send (consent auto) or return a suggestion.
+// Returns { action, reasons, sent? } and never throws.
+export async function autoFeedback(root, { trigger = "hook" } = {}) {
+  try {
+    const d = evaluate(root);
+    if (d.action !== "send") return d;
+    const { bundle, mdFile } = await buildBundle(root, { sinceDays: 14, trigger, reasons: d.reasons });
+    const sent = await sendBundle(root, { bundle, markdown: readText(mdFile, "") });
+    return { ...d, sent };
+  } catch (e) { return { action: "none", reasons: [], error: e.message }; }
+}
+
+export function renderSummary(b) {
+  const L = [];
+  L.push(`# NCCGS feedback · ${b.generatedAt.slice(0, 10)} · last ${b.sinceDays} days`, "");
+  L.push(`NCCGS ${b.nccgs} · Node ${b.node} · ${b.platform} · Unity ${b.project.editor ?? "?"} · Pipeline ${b.project.pipeline ?? "?"} · mode ${b.project.mode} · rigor ${b.project.rigor} · autonomy ${b.project.autonomy}`, "");
+  const t = b.totals;
+  L.push(`**Totals.** ${t.tasks} tasks (${t.closed} closed: ${Object.entries(t.byOutcome).map(([k, v]) => `${v} ${k}`).join(", ") || "none"}) · ${t.verifications} verifications (${t.failedVerifications} failed) · ${t.fixRounds} fix rounds · ${fmtTokens(t.tokensOut)} tokens out · ${t.sessions} sessions · agents: ${Object.entries(t.agentRuns).map(([k, v]) => `${k} ×${v}`).join(", ") || "none"}`, "");
+  if (b.doctor?.summary) L.push(`**Doctor.** ${b.doctor.summary.pass} pass · ${b.doctor.summary.warn} warn · ${b.doctor.summary.fail} fail${b.doctor.checks.filter(c => c.status !== "pass").map(c => `\n- ${c.status.toUpperCase()} ${c.id}: ${c.message}`).join("")}`, "");
+  L.push(`## Tasks`, "", `| Task | Rigor | Outcome | Verify (failed) | Review | Fix | Outside scope | Minutes | Tokens out |`, `| --- | --- | --- | --- | --- | --- | --- | --- | --- |`);
+  for (const x of b.tasks) L.push(`| ${x.id} ${x.title.slice(0, 40)} | ${x.rigor} | ${x.status === "closed" ? x.outcome : x.status} | ${x.verifications.total} (${x.verifications.failed}) | ${x.reviews.map(r => `${r.verdict}${Object.keys(r.findings).length ? ` ${Object.entries(r.findings).map(([k, v]) => `${k[0]}${v}`).join("/")}` : ""}`).join(" → ") || "–"} | ${x.fixRounds} | ${x.outsideContract} | ${x.minutes ?? "–"} | ${x.tokens ? fmtTokens(x.tokens.out) : "–"} |`);
+  L.push("");
+  const kinds = Object.entries(t.diagnostics);
+  L.push(`## Diagnostics (${b.diagnostics.length})`, "");
+  if (!kinds.length) L.push("Nothing recorded: no runtime errors, failed verifications, Unity failures or hook blocks in the window.", "");
+  else {
+    L.push(kinds.map(([k, v]) => `${k} ×${v}`).join(" · "), "");
+    const groups = {};
+    for (const d of b.diagnostics) { const key = `${d.kind}: ${(d.reason ?? d.message ?? d.error?.message ?? (d.errors?.[0]?.code ?? d.errors?.[0]?.message) ?? d.name ?? "").toString().slice(0, 100)}`; groups[key] = (groups[key] ?? 0) + 1; }
+    for (const [k, v] of Object.entries(groups).sort((a, b) => b[1] - a[1]).slice(0, 30)) L.push(`- ×${v} ${k}`);
+    L.push("");
+  }
+  if (b.updateNotices?.length) L.push(`## Updates pending`, "", ...b.updateNotices.map(n => `- ${n.component} ${n.current} → ${n.latest}`), "");
+  if (b.note) L.push(`## Note from the person`, "", b.note, "");
+  L.push(`## Recent closes`, "", ...(b.state.length ? b.state : ["(none)"]), "");
+  L.push("_Local bundle. Contains task metadata, counts, diagnostics and the note above; no source code, screenshots, transcripts or credentials. The JSON beside this file has the detail._");
+  return L.join("\n");
+}

package/runtime/task/ledger.mjs

@@ -0,0 +1,109 @@
+// Task records: .nccgs/tasks/<id>.json (schema 3). The ledger records; it does not block tool calls.
+import fs from "node:fs";
+import path from "node:path";
+import { readJson, writeJson, exists, nowIso, shortId, appendLine } from "../core/fs.mjs";
+import { at, loadConfig, ensureLayout, editorVersion } from "../core/project.mjs";
+import { snapshot } from "../core/snapshot.mjs";
+import { validateCriteria, defaultObserveCriteria, PLAYER_VISIBLE, evaluate } from "./criteria.mjs";
+
+export const RIGORS = ["prototype", "production", "release"];
+export const REVIEW_REQUIRED = { prototype: 0, production: 1, release: 2 };
+export const FIX_ROUNDS = { prototype: 6, production: 4, release: 2 };
+
+export const taskFile = (root, id) => path.join(at(root, "tasks"), `${id}.json`);
+
+export function loadTask(root, id) {
+  const file = taskFile(root, id);
+  if (!exists(file)) throw new Error(`Task ${id} not found (${file})`);
+  return readJson(file);
+}
+export function saveTask(root, task) { task.updatedAt = nowIso(); writeJson(taskFile(root, task.id), task); return task; }
+export function listTasks(root) {
+  const dir = at(root, "tasks");
+  if (!exists(dir)) return [];
+  return fs.readdirSync(dir).filter(f => f.endsWith(".json")).map(f => readJson(path.join(dir, f))).sort((a, b) => (a.openedAt < b.openedAt ? 1 : -1));
+}
+export function openTasks(root) { return listTasks(root).filter(t => t.status !== "closed"); }
+
+export function event(root, type, data = {}) {
+  appendLine(at(root, "events"), JSON.stringify({ at: nowIso(), type, ...data }));
+}
+
+export function openTask(root, { id, title, rigor, files = [], criteria = [], mode, notes = "", plan = false }) {
+  ensureLayout(root);
+  const config = loadConfig(root);
+  rigor = rigor || config.rigor;
+  if (!RIGORS.includes(rigor)) throw new Error(`rigor must be one of ${RIGORS.join("|")}`);
+  id = id || `T-${new Date().toISOString().slice(0, 10).replace(/-/g, "")}-${shortId()}`;
+  if (exists(taskFile(root, id))) throw new Error(`Task ${id} already exists`);
+  if (!title) throw new Error("--title is required");
+  const touchesPlayerVisible = files.some(f => PLAYER_VISIBLE.test(f));
+  const all = [...criteria];
+  if (rigor !== "prototype" && touchesPlayerVisible && !all.some(c => c.id === "observe")) all.push(...defaultObserveCriteria(id));
+  const problems = validateCriteria(all);
+  if (problems.length) throw new Error(`Invalid criteria:\n- ${problems.join("\n- ")}`);
+  const task = {
+    schemaVersion: 3, id, title, rigor, mode: mode || config.mode, status: "open", notes,
+    unity: { editor: editorVersion(root) },
+    files, criteria: all, fromPlan: !!plan,
+    openedAt: nowIso(), updatedAt: nowIso(), closedAt: null,
+    snapshotAtOpen: brief(snapshot(root, { config })),
+    verifications: [], reviews: [], fixRounds: 0, maxFixRounds: FIX_ROUNDS[rigor],
+    manualDecisions: {}, outcome: null, report: null
+  };
+  saveTask(root, task);
+  event(root, "task.open", { id, rigor, title });
+  return task;
+}
+
+// The task file keeps the sha only; the per-file map lives in .nccgs/cache/snapshots/<sha>.json.
+const brief = s => ({ sha: s.sha, files: s.files, at: s.at });
+
+export function assess(root, task) {
+  const evaluation = evaluate(root, task.criteria, { manualDecisions: task.manualDecisions });
+  const current = brief(snapshot(root));
+  const lastVerification = task.verifications.at(-1);
+  const stale = lastVerification ? lastVerification.snapshot !== current.sha : true;
+  return { evaluation, snapshot: current, stale, lastVerification };
+}
+
+export function recordVerification(root, task, record) {
+  task.verifications.push({ ...record, at: nowIso(), snapshot: snapshot(root).sha });
+  task.status = task.status === "open" ? "verifying" : task.status;
+  saveTask(root, task);
+  event(root, "task.verify", { id: task.id, name: record.name, ok: record.ok });
+}
+
+export function reviewsNeeded(task) { return REVIEW_REQUIRED[task.rigor] ?? 1; }
+
+// Mark a reviewer finding resolved. MEDIUM/LOW may be resolved by the coordinator with a reason (the
+// report shows who and why); HIGH/BLOCKER are resolved only by a new review verdict, never by hand.
+export function resolveFinding(root, task, { match, reason, by = "coordinator" }) {
+  const review = task.reviews.at(-1);
+  if (!review) throw new Error("no review recorded for this task");
+  if (!reason) throw new Error("--reason is required: say what changed or why the finding does not apply");
+  const needle = String(match).toLowerCase();
+  const hits = (review.findings ?? []).map((f, i) => ({ f, i })).filter(({ f, i }) => String(i) === needle || (f.title ?? f.summary ?? "").toLowerCase().includes(needle));
+  if (hits.length !== 1) throw new Error(hits.length ? `"${match}" matches ${hits.length} findings; use the index` : `no finding matches "${match}"`);
+  const { f, i } = hits[0];
+  if (/HIGH|BLOCKER/i.test(f.severity ?? "")) throw new Error(`${f.severity} findings are resolved only by re-review (task review --id ${task.id}, then --import)`);
+  if (f.resolved) throw new Error(`finding ${i} is already resolved`);
+  Object.assign(f, { resolved: true, resolvedBy: by, resolvedAt: nowIso(), resolvedReason: reason, resolvedSnapshot: snapshot(root).sha });
+  saveTask(root, task);
+  event(root, "task.finding.resolve", { id: task.id, index: i, severity: f.severity, by, reason });
+  return { index: i, finding: f };
+}
+
+export function readyToClose(root, task, outcome) {
+  const { evaluation, snapshot: current, stale } = assess(root, task);
+  const reasons = [];
+  if (outcome === "success") {
+    if (!evaluation.allPass) reasons.push(`criteria not all passing: ${evaluation.summary.fail} fail, ${evaluation.summary.unverified} unverified, ${evaluation.summary.pending} pending`);
+    if (stale) reasons.push("source changed after the last verification; run `task verify` again");
+    const latest = task.reviews.at(-1);
+    const passes = task.reviews.filter(r => r.verdict === "PASS" && r.snapshot === current.sha);
+    if (latest && latest.verdict !== "PASS" && latest.snapshot === current.sha) reasons.push(`latest review on this snapshot is ${latest.verdict}; fix and re-review`);
+    if (passes.length < reviewsNeeded(task)) reasons.push(`independent review PASS on the current snapshot required (${passes.length}/${reviewsNeeded(task)})`);
+  }
+  return { ok: reasons.length === 0, reasons, evaluation, snapshot: current, stale };
+}

package/runtime/task/plan.mjs

@@ -0,0 +1,69 @@
+// The slice plan: .nccgs/design/slice.json, written by /map-systems, consumed by /vertical-slice and
+// `task open --plan <id>`. Each item is a full task contract (title, files, criteria, notes, rigor) plus
+// `dependsOn`, so a task can only be opened when its dependencies closed SUCCESS.
+import path from "node:path";
+import { readJson, writeJson, exists } from "../core/fs.mjs";
+import { at } from "../core/project.mjs";
+import { listTasks } from "./ledger.mjs";
+import { validateCriteria } from "./criteria.mjs";
+
+export const planFile = root => path.join(at(root, "nccgs"), "design", "slice.json");
+
+export function loadPlan(root) {
+  const f = planFile(root);
+  if (!exists(f)) throw new Error("no slice plan: run /map-systems first (it writes .nccgs/design/slice.json)");
+  const plan = readJson(f);
+  const problems = validatePlan(plan);
+  if (problems.length) throw new Error(`slice.json invalid:\n- ${problems.join("\n- ")}`);
+  return plan;
+}
+
+export function validatePlan(plan) {
+  const problems = [];
+  if (!plan || typeof plan !== "object") return ["not an object"];
+  if (plan.schemaVersion !== 1) problems.push("schemaVersion must be 1");
+  if (!Array.isArray(plan.tasks) || !plan.tasks.length) return [...problems, "tasks must be a non-empty array"];
+  const ids = new Set();
+  for (const [i, t] of plan.tasks.entries()) {
+    const w = `tasks[${i}]`;
+    if (!t.id || typeof t.id !== "string") problems.push(`${w}.id required`);
+    else if (ids.has(t.id)) problems.push(`${w}.id ${t.id} duplicated`); else ids.add(t.id);
+    if (!t.title) problems.push(`${w}.title required`);
+    if (!Array.isArray(t.files) || !t.files.length) problems.push(`${w}.files must list the files in scope`);
+    if (!Array.isArray(t.criteria) || !t.criteria.length) problems.push(`${w}.criteria must be a non-empty array`);
+    else problems.push(...validateCriteria(t.criteria).map(p => `${w}.criteria: ${p}`));
+    for (const d of t.dependsOn ?? []) if (!plan.tasks.some(x => x.id === d)) problems.push(`${w}.dependsOn ${d} is not in the plan`);
+  }
+  return problems;
+}
+
+// Status of every planned task against the ledger: done | open | ready | blocked.
+export function planStatus(root, plan = loadPlan(root)) {
+  const tasks = listTasks(root);
+  const byId = new Map(tasks.map(t => [t.id, t]));
+  return plan.tasks.map(p => {
+    const t = byId.get(p.id);
+    const state = t ? (t.status === "closed" ? (t.outcome === "success" ? "done" : `closed-${t.outcome}`) : "open") : null;
+    const waiting = (p.dependsOn ?? []).filter(d => byId.get(d)?.outcome !== "success");
+    return { id: p.id, title: p.title, state: state ?? (waiting.length ? "blocked" : "ready"), waiting, rigor: p.rigor ?? null };
+  });
+}
+
+export function nextPlanned(root, plan = loadPlan(root)) {
+  return planStatus(root, plan).find(s => s.state === "ready" || s.state === "open") ?? null;
+}
+
+export function planItem(root, id, plan = loadPlan(root)) {
+  const item = plan.tasks.find(t => t.id === id);
+  if (!item) throw new Error(`plan has no task ${id} (${plan.tasks.map(t => t.id).join(", ")})`);
+  const status = planStatus(root, plan).find(s => s.id === id);
+  if (status.state === "blocked") throw new Error(`${id} waits for ${status.waiting.join(", ")} to close SUCCESS`);
+  return item;
+}
+
+export function savePlan(root, plan) {
+  const problems = validatePlan(plan);
+  if (problems.length) throw new Error(`slice.json invalid:\n- ${problems.join("\n- ")}`);
+  writeJson(planFile(root), plan);
+  return planFile(root);
+}