flavor-code 1.2.14 → 1.2.15

package/dist/desktop/main.js

@@ -1,7 +1,7 @@
 // src/desktop/main.ts
 import { appendFileSync } from "fs";
 import { readFile as readFile34, stat as stat15, writeFile as writeFile18 } from "fs/promises";
-import { dirname as dirname23, join as join40 } from "path";
+import { dirname as dirname23, join as join41 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { app, BrowserWindow as BrowserWindow2, dialog, ipcMain, Menu, nativeImage, shell } from "electron";
 
@@ -2611,11 +2611,11 @@ function hexToLab(hex) {
   const b = linearize(channels[2]);
   const x = (0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047;
   const y = 0.2126729 * r + 0.7151522 * g + 0.072175 * b;
-  const z41 = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883;
+  const z43 = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883;
   const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
   const fx = f(x);
   const fy = f(y);
-  const fz = f(z41);
+  const fz = f(z43);
   return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
 }
 function deltaE76(left, right) {
@@ -4230,7 +4230,10 @@ var TaskNodeSchema = z9.object({
   description: z9.string().trim().min(1),
   dependencies: z9.array(z9.string().trim().min(1)),
   expectedOutputs: z9.array(z9.string().trim().min(1)),
-  verification: z9.array(z9.string().trim().min(1))
+  verification: z9.array(z9.string().trim().min(1)),
+  files: z9.array(z9.string().trim().min(1)).describe(
+    "Workspace files this task owns for writing. Tasks whose files overlap are never run in parallel, so declare every file this task may create or modify."
+  ).optional()
 }).strict();
 var TaskGraphSchema = z9.object({
   nodes: z9.array(TaskNodeSchema)
@@ -4422,6 +4425,7 @@ var SubagentScheduler = class {
     const states = new Map(graph.nodes.map((task) => [task.id, "pending"]));
     const results = /* @__PURE__ */ new Map();
     const running = /* @__PURE__ */ new Map();
+    const runningFiles = /* @__PURE__ */ new Map();
     const started = /* @__PURE__ */ new Set();
     try {
       while (statesHaveWork(states)) {
@@ -4430,7 +4434,9 @@ var SubagentScheduler = class {
         for (const task of graph.nodes) {
           if (running.size >= this.#options.maxSubagents) break;
           if (states.get(task.id) !== "pending" || !isReady(task, states)) continue;
+          if (conflictsWithRunning(task, runningFiles)) continue;
           states.set(task.id, "running");
+          if (task.files !== void 0) runningFiles.set(task.id, task.files.map(normalizeOwnedFile));
           const execution = this.#runTask(task, signal);
           running.set(task.id, execution);
           started.add(execution);
@@ -4443,6 +4449,7 @@ var SubagentScheduler = class {
         const completion = await Promise.race(running.values());
         signal.throwIfAborted();
         running.delete(completion.id);
+        runningFiles.delete(completion.id);
         results.set(completion.id, completion.result);
         states.set(completion.id, completion.result.status);
         await this.#options.onResult?.(completion.result);
@@ -4520,6 +4527,26 @@ var SubagentScheduler = class {
 function isReady(task, states) {
   return task.dependencies.every((dependency) => states.get(dependency) === "completed");
 }
+function normalizeOwnedFile(value) {
+  return value.replace(/\\/g, "/");
+}
+function ownedFilesConflict(left, right) {
+  for (const one of left) {
+    for (const other of right) {
+      if (one === other) return true;
+      if (other.startsWith(`${one}/`) || one.startsWith(`${other}/`)) return true;
+    }
+  }
+  return false;
+}
+function conflictsWithRunning(task, runningFiles) {
+  if (task.files === void 0 || task.files.length === 0) return false;
+  const owned = task.files.map(normalizeOwnedFile);
+  for (const files of runningFiles.values()) {
+    if (ownedFilesConflict(owned, files)) return true;
+  }
+  return false;
+}
 function statesHaveWork(states) {
   return [...states.values()].some((state) => state === "pending" || state === "running");
 }
@@ -8686,23 +8713,45 @@ async function readJsonArray(file) {
     return [];
   }
 }
+async function readRules(file) {
+  try {
+    const parsed = JSON.parse(await readFile7(file, "utf8"));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((item) => item !== null && typeof item === "object").filter((item) => typeof item.id === "string" && typeof item.text === "string").map((item) => ({
+      id: item.id,
+      text: item.text,
+      addedAt: typeof item.addedAt === "string" ? item.addedAt : "",
+      ...typeof item.sourceId === "string" ? { sourceId: item.sourceId } : {}
+    }));
+  } catch {
+    return [];
+  }
+}
+async function writeRules(file, rules) {
+  await mkdir8(dirname7(file), { recursive: true, mode: 448 });
+  await writeFile6(file, JSON.stringify(rules, null, 2), { encoding: "utf8", mode: 384 });
+}
 var EvolveStore = class {
   dir;
   signalsFile;
   reflectionsFile;
   doneFile;
   verifiedFile;
+  rulesFile;
   maxSignals;
+  maxRules;
   // Serialize file mutations: tool hooks may fire in bursts.
   #queue = Promise.resolve();
   constructor(options) {
-    const { workspace, maxSignals = 400 } = options;
+    const { workspace, maxSignals = 400, maxRules = 20 } = options;
     this.dir = join9(workspace, ".flavor", "evolve");
     this.signalsFile = join9(this.dir, "signals.jsonl");
     this.reflectionsFile = join9(this.dir, "reflections.jsonl");
     this.doneFile = join9(this.dir, "done.json");
     this.verifiedFile = join9(this.dir, "verified.json");
+    this.rulesFile = join9(this.dir, "rules.json");
     this.maxSignals = maxSignals;
+    this.maxRules = maxRules;
   }
   #enqueue(operation) {
     const next = this.#queue.then(operation, operation);
@@ -8848,6 +8897,43 @@ var EvolveStore = class {
       }
     });
   }
+  /** Learned guardrail rules, oldest first. */
+  listRules() {
+    return this.#enqueue(() => readRules(this.rulesFile));
+  }
+  /**
+   * Add one guardrail rule. Dedupes by fingerprint of the normalized text and
+   * keeps at most maxRules entries (oldest dropped first).
+   */
+  addRule(input) {
+    return this.#enqueue(async () => {
+      const text = input.text.replace(/\s+/g, " ").trim().slice(0, 300);
+      if (text === "") throw new Error("rule text must not be empty");
+      const id = fingerprint("rule", void 0, text);
+      const rules = await readRules(this.rulesFile);
+      const existing = rules.find((rule2) => rule2.id === id);
+      if (existing !== void 0) return { added: false, rule: existing };
+      const rule = {
+        id,
+        text,
+        addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...input.sourceId === void 0 ? {} : { sourceId: input.sourceId }
+      };
+      rules.push(rule);
+      if (rules.length > this.maxRules) rules.splice(0, rules.length - this.maxRules);
+      await writeRules(this.rulesFile, rules);
+      return { added: true, rule };
+    });
+  }
+  removeRule(id) {
+    return this.#enqueue(async () => {
+      const rules = await readRules(this.rulesFile);
+      const next = rules.filter((rule) => rule.id !== id);
+      if (next.length === rules.length) return { removed: false };
+      await writeRules(this.rulesFile, next);
+      return { removed: true };
+    });
+  }
 };
 
 // src/evolve/service.ts
@@ -8859,9 +8945,15 @@ a plugin, a memory rule, a tool wrapper, or a safer default), implement it in
 this session when it is in scope; otherwise ignore them. Never act on them
 without running the test suite afterwards.
 
+`;
+var GUARDRAILS_SECTION_HEADER = `# learned guardrails (evolve)
+
+These rules were distilled from repeated tool failures in this workspace.
+Follow them unless the current task or the user explicitly contradicts one.
+
 `;
 var USAGE = [
-  "usage: /evolve <signals|suggest|improve <id>|verify <name>|reload <name>|test|revert <name>|done <id>|verified|clear>",
+  "usage: /evolve <signals|suggest|improve <id>|verify <name>|reload <name>|test|revert <name>|done <id>|verified|trends [n]|rule <list|add|remove>|clear>",
   "  signals   list recent failing tool results",
   "  suggest   aggregate repeated failures into fix suggestions (trend-aware ordering)",
   "  improve   scaffold a fix-<tool>/ plugin dir + PLAN.md for one suggestion",
@@ -8871,6 +8963,8 @@ var USAGE = [
   "  revert    restore the last good snapshot of a plugin",
   "  done      mark a suggestion as handled (no longer proposed)",
   "  verified  list suggestions auto-verified by improving failure trends",
+  "  trends    cross-run dashboard: tool calls, failures, signalDelta, per-tool movement",
+  "  rule      manage learned guardrails injected into system prompts (list/add <text>/remove <id>)",
   "  clear     reset signals, done markers, and verified markers"
 ].join("\n");
 function runCommand(command, cwd, timeoutMs) {
@@ -8962,9 +9056,17 @@ function createEvolveService(options) {
   }
   async function refreshPromptCache() {
     try {
-      const suggestions = await openWithTrends(promptTop);
-      promptCache = suggestions.length === 0 ? void 0 : `${SUGGEST_SECTION_HEADER}${suggestions.map((suggestion) => `- [${suggestion.id}] ${suggestion.hint}`).join("\n")}
-`;
+      const [suggestions, rules] = await Promise.all([openWithTrends(promptTop), store.listRules()]);
+      const sections = [];
+      if (rules.length > 0) {
+        sections.push(`${GUARDRAILS_SECTION_HEADER}${rules.map((rule) => `- ${rule.text}`).join("\n")}
+`);
+      }
+      if (suggestions.length > 0) {
+        sections.push(`${SUGGEST_SECTION_HEADER}${suggestions.map((suggestion) => `- [${suggestion.id}] ${suggestion.hint}`).join("\n")}
+`);
+      }
+      promptCache = sections.length === 0 ? void 0 : sections.join("\n");
     } catch (error) {
       logger.warn(`prompt section failed \u2014 ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -9144,6 +9246,41 @@ function createEvolveService(options) {
           return signal === void 0 ? `[${id}] (signal no longer recorded)` : `[${id}] ${signal.tool} x${signal.count} \u2014 ${signal.error} (verified)`;
         }).join("\n");
       }
+      if (arg === "trends" || arg.startsWith("trends ")) {
+        const requested = Number.parseInt(arg.slice(6).trim(), 10);
+        const count = Number.isNaN(requested) ? 5 : Math.min(Math.max(requested, 1), 50);
+        const reflections = await store.reflections(count);
+        if (reflections.length === 0) return "no reflections recorded yet \u2014 trends appear after runs end";
+        const sign = (value) => value > 0 ? `+${value}` : String(value);
+        const lines = [`evolve trends (last ${reflections.length} run(s), newest first)`];
+        for (const reflection of reflections) {
+          lines.push(`${reflection.at.replace("T", " ").slice(0, 19)}  ${reflection.reason}: model calls ${reflection.iterations}, tool calls ${reflection.toolCalls} (${reflection.toolErrors} failed), failures ${reflection.totalFailures} (delta ${sign(reflection.signalDelta)})`);
+          const moved = Object.entries(reflection.perTool ?? {}).filter(([, trend]) => trend.delta !== 0);
+          for (const [tool, trend] of moved) {
+            lines.push(`    - ${tool}: ${trend.failures} failure(s) this run (${sign(trend.delta)} vs previous)`);
+          }
+        }
+        return lines.join("\n");
+      }
+      if (arg === "rule" || arg === "rule list") {
+        const rules = await store.listRules();
+        if (rules.length === 0) return "no guardrail rules yet \u2014 add one with /evolve rule add <text>";
+        return rules.map((rule) => `[${rule.id}] ${rule.text}`).join("\n");
+      }
+      if (arg.startsWith("rule add ")) {
+        const text = arg.slice(9).trim();
+        if (text === "") return "usage: /evolve rule add <text>";
+        const { added, rule } = await store.addRule({ text });
+        await refreshPromptCache();
+        return added ? `added guardrail [${rule.id}]: ${rule.text}` : `guardrail already exists [${rule.id}]: ${rule.text}`;
+      }
+      if (arg.startsWith("rule remove ")) {
+        const id = arg.slice(12).trim();
+        if (id === "") return "usage: /evolve rule remove <id>";
+        const { removed } = await store.removeRule(id);
+        await refreshPromptCache();
+        return removed ? `removed guardrail ${id}` : `no guardrail with id "${id}"`;
+      }
       if (arg.startsWith("improve ")) {
         const suggestionId = arg.slice(8).trim();
         const suggestions = await openWithTrends(100);
@@ -9215,18 +9352,31 @@ ${result.stderr.slice(-4e3)}` : ""}`;
     toolDefinition() {
       const inputSchema = z17.object({
         suggestionId: z17.string().min(1).describe("Signal id from the evolve suggestions"),
-        implementation: z17.string().min(1).describe("Concise description of the plugin fix to implement")
+        implementation: z17.string().min(1).describe("Concise description of the fix to implement (plugin plan, or the guardrail rule text when kind is prompt_rule)"),
+        kind: z17.enum(["plugin", "prompt_rule"]).optional().describe(
+          "plugin (default): scaffold a fix plugin; prompt_rule: store a guardrail rule that is injected into future system prompts"
+        )
       });
       return {
         name: "evolve_improve",
-        description: "Implement a fix for one repeated tool failure as a flavor-code plugin: scaffolds the fix-<tool>/ plugin dir, writes PLAN.md, and returns instructions for implementing, verifying, reloading, and testing it. Use when the model proposes a concrete plugin-level fix for a suggestion in the system prompt.",
+        description: "Implement a fix for one repeated tool failure. Default kind=plugin scaffolds the fix-<tool>/ plugin dir and writes PLAN.md with instructions for implementing, verifying, reloading, and testing it. kind=prompt_rule instead stores a concise guardrail rule (from `implementation`) that is injected into future system prompts and closes the suggestion. Use when the model proposes a concrete fix for a suggestion in the system prompt.",
         inputSchema,
         paths: () => [],
         execute: async (input) => {
-          const { suggestionId, implementation } = input;
+          const { suggestionId, implementation, kind } = input;
           const suggestions = await openWithTrends(100);
           const suggestion = suggestions.find((item) => item.id === suggestionId);
           if (suggestion === void 0) throw new Error(`No open suggestion with id "${suggestionId}".`);
+          if (kind === "prompt_rule") {
+            const { added, rule } = await store.addRule({ text: implementation, sourceId: suggestionId });
+            await store.markSuggestionDone(suggestionId);
+            await refreshPromptCache();
+            return [
+              added ? `Stored guardrail rule [${rule.id}]: ${rule.text}` : `Guardrail already exists [${rule.id}]: ${rule.text}`,
+              `Suggestion [${suggestion.id}] marked done. The rule is injected into the system prompt of future runs.`,
+              "Review rules with /evolve rule list; remove one with /evolve rule remove <id>."
+            ].join("\n");
+          }
           const name = sanitizePluginName(suggestion.tool);
           const dir = await scaffoldFixPlugin(workspace, name);
           await writeFile7(join10(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
@@ -13100,11 +13250,11 @@ Treat the assigned task as self-contained. The caller may not share its full con
 Own the user's request end to end. Collaborate when a choice materially changes the result, but use sound judgment for ordinary in-scope implementation details. Keep the user informed at meaningful milestones, synthesize any child-agent results yourself, and do not stop while safe, relevant work remains. A forked child receives an explicit Subagent directive after the inherited conversation; in that case, follow that narrower directive for the child assignment.`;
 }
 function environmentSection(options) {
-  const git2 = options.environment.isGitRepository === "unknown" ? "unknown" : options.environment.isGitRepository ? "yes" : "no";
+  const git3 = options.environment.isGitRepository === "unknown" ? "unknown" : options.environment.isGitRepository ? "yes" : "no";
   return `# Environment
 
 - Working directory: ${data(options.workspace)}
-- Git repository: ${git2}
+- Git repository: ${git3}
 - Platform: ${data(options.environment.platform)}
 - OS version: ${data(options.environment.osVersion)}
 - Shell: ${data(options.environment.shell)}`;
@@ -17559,19 +17709,255 @@ function severityLabel(severity) {
   }
 }
 
-// src/tools/ask-user-question.ts
+// src/git/service.ts
+async function git2(workspace, args, timeoutMs = 3e4) {
+  const result = await execFileNoThrow("git", ["-C", workspace, ...args], { timeout: timeoutMs, useCwd: false });
+  return { ok: result.code === 0, stdout: result.stdout, stderr: result.stderr, code: result.code };
+}
+async function isGitRepository(workspace) {
+  const result = await git2(workspace, ["rev-parse", "--is-inside-work-tree"], 2e3);
+  return result.ok && result.stdout.trim() === "true";
+}
+function gitFailure(result, action) {
+  const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+  return new Error(`git ${action} failed: ${detail.split("\n")[0]}`);
+}
+async function changeSummary(workspace) {
+  const branch = await git2(workspace, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const head = await git2(workspace, ["rev-parse", "--short", "HEAD"]);
+  const status = await git2(workspace, ["status", "--porcelain"]);
+  if (!status.ok) throw gitFailure(status, "status");
+  const statusLines = status.stdout.split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0);
+  const stagedFiles = [];
+  const unstagedFiles = [];
+  const untrackedFiles = [];
+  for (const line of statusLines) {
+    const index = line[0] ?? " ";
+    const worktree = line[1] ?? " ";
+    const file = line.slice(3);
+    if (index === "?" && worktree === "?") {
+      untrackedFiles.push(file);
+      continue;
+    }
+    if (index !== " " && index !== "?") stagedFiles.push(file);
+    if (worktree !== " " && worktree !== "?") unstagedFiles.push(file);
+  }
+  return {
+    branch: branch.ok ? branch.stdout.trim() : "HEAD",
+    head: head.ok ? head.stdout.trim() : "unknown",
+    statusLines,
+    stagedFiles: [...new Set(stagedFiles)],
+    unstagedFiles: [...new Set(unstagedFiles)],
+    untrackedFiles
+  };
+}
+async function stagedDiff(workspace, maxChars = 96e3) {
+  const stat16 = await git2(workspace, ["diff", "--staged", "--stat"]);
+  const diff = await git2(workspace, ["diff", "--staged", "--no-ext-diff", "--no-color"]);
+  if (!diff.ok) throw gitFailure(diff, "diff --staged");
+  const text = diff.stdout;
+  return {
+    diff: text.length > maxChars ? `${text.slice(0, maxChars)}
+\u2026[diff truncated]` : text,
+    stat: stat16.stdout.trim(),
+    truncated: text.length > maxChars
+  };
+}
+async function uncommittedDiff(workspace, maxChars = 96e3) {
+  const stat16 = await git2(workspace, ["diff", "HEAD", "--stat"]);
+  const diff = await git2(workspace, ["diff", "HEAD", "--no-ext-diff", "--no-color"]);
+  if (!diff.ok && !diff.stderr.includes("unknown revision")) throw gitFailure(diff, "diff HEAD");
+  const summary2 = await changeSummary(workspace);
+  const text = diff.stdout;
+  return {
+    diff: text.length > maxChars ? `${text.slice(0, maxChars)}
+\u2026[diff truncated]` : text,
+    stat: stat16.stdout.trim(),
+    untracked: summary2.untrackedFiles
+  };
+}
+async function stageAll(workspace) {
+  const result = await git2(workspace, ["add", "-A"]);
+  if (!result.ok) throw gitFailure(result, "add");
+}
+async function commit(workspace, commitMessage) {
+  const result = await execFileNoThrow("git", ["-C", workspace, "commit", "-F", "-"], {
+    timeout: 3e4,
+    useCwd: false,
+    input: commitMessage
+  });
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+    throw new Error(`git commit failed: ${detail.split("\n")[0]}`);
+  }
+  const head = await git2(workspace, ["log", "-1", "--pretty=%h %s"]);
+  return head.stdout.trim() || "committed";
+}
+async function fileHistory(workspace, path, limit) {
+  const args = [
+    "log",
+    `--max-count=${limit}`,
+    "--date=short",
+    "--pretty=format:%h%x1f%ad%x1f%an%x1f%s",
+    ...path === void 0 ? [] : ["--follow", "--", path]
+  ];
+  const result = await git2(workspace, args, 15e3);
+  if (!result.ok) throw gitFailure(result, "log");
+  return result.stdout.split("\n").filter((line) => line.trim().length > 0).map((line) => {
+    const [hash = "", date = "", author = "", ...subject] = line.split("");
+    return { hash, date, author, subject: subject.join("") };
+  });
+}
+async function gitMarker(workspace) {
+  try {
+    if (!await isGitRepository(workspace)) return void 0;
+    const summary2 = await changeSummary(workspace);
+    if (summary2.head === "unknown") return void 0;
+    const dirty = summary2.statusLines.length > 0 ? "-dirty" : "";
+    return `${summary2.branch}@${summary2.head}${dirty}`;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/git/insights.ts
 import { z as z30 } from "zod";
-var QuestionOptionSchema = z30.object({
-  label: z30.string().trim().min(1),
-  description: z30.string().trim().min(1)
+async function suggestCommitMessage(options, input, signal) {
+  const prompt = [
+    "Write a git commit message for the staged changes below.",
+    "Rules: Conventional Commits style (feat/fix/refactor/docs/test/chore scope); a short imperative subject line <= 72 chars; an optional body only when the change needs explanation; no code fences; reply with the commit message only.",
+    ...input.hint === void 0 || input.hint.trim() === "" ? [] : [`The user added this context: ${input.hint.trim()}`],
+    "",
+    `Change summary:
+${input.stat}`,
+    "",
+    `Diff:
+${input.diff}`
+  ].join("\n");
+  const { adapter, model } = options.registry.get(options.modelId());
+  let text = "";
+  for await (const event of adapter.stream({
+    model,
+    messages: [{ role: "user", content: prompt }],
+    tools: [],
+    signal
+  })) {
+    if (event.type === "text") text += event.text;
+    else if (event.type === "error") throw new Error(`commit message generation failed: ${event.error.message}`);
+    else if (event.type === "done") break;
+  }
+  const cleaned = cleanCommitMessage(text);
+  if (cleaned === "") throw new Error("commit message generation returned no text");
+  return cleaned;
+}
+function cleanCommitMessage(raw) {
+  const trimmed = raw.trim().replace(/^```[a-z]*\s*/iu, "").replace(/```$/u, "").trim();
+  const lines = trimmed.split("\n");
+  const kept = [];
+  for (const line of lines) {
+    if (/^(here('|’)s|notes?:|explanation:)/iu.test(line.trim()) && kept.length > 0) break;
+    kept.push(line);
+  }
+  return kept.join("\n").trim().slice(0, 2e3);
+}
+var ReviewFindingSchema = z30.object({
+  severity: z30.enum(["critical", "warning", "nit"]),
+  file: z30.string(),
+  line: z30.string().describe('Line number or hunk header the finding refers to, e.g. "42" or "@@ -10,4 +10,6 @@"'),
+  issue: z30.string(),
+  suggestion: z30.string()
+}).strict();
+var ReviewReportSchema = z30.object({
+  summary: z30.string().describe("One-paragraph overall assessment of the change"),
+  verdict: z30.enum(["ship", "ship-with-fixes", "needs-work"]),
+  findings: z30.array(ReviewFindingSchema).max(20)
+}).strict();
+async function reviewDiff(options, input, signal) {
+  const prompt = [
+    "You are reviewing uncommitted local changes before the user commits them.",
+    "Focus on: correctness bugs, broken error handling, security issues (secrets, injection, path traversal), missing edge cases, and obvious test gaps.",
+    "Do not comment on formatting or style unless it hides a bug. Report at most the 10 most important findings.",
+    ...input.focus === void 0 || input.focus.trim() === "" ? [] : [`The user specifically wants attention on: ${input.focus.trim()}`],
+    ...input.untracked.length === 0 ? [] : [`Untracked files not shown in the diff: ${input.untracked.join(", ")}`],
+    "",
+    `Change summary:
+${input.stat}`,
+    "",
+    `Diff:
+${input.diff}`
+  ].join("\n");
+  const structured = withStructuredOutput({
+    registry: options.registry,
+    modelId: options.modelId(),
+    name: "report_review",
+    description: "Structured review report for uncommitted changes",
+    schema: ReviewReportSchema
+  });
+  const { value } = await structured.invoke({
+    messages: [{ role: "user", content: prompt }],
+    signal
+  });
+  return value;
+}
+function formatReviewReport(report) {
+  const lines = [`Review verdict: ${report.verdict}`, "", report.summary.trim()];
+  if (report.findings.length > 0) {
+    lines.push("", "Findings:");
+    for (const finding of report.findings) {
+      lines.push(`- [${finding.severity}] ${finding.file}${finding.line === "" ? "" : `:${finding.line}`} \u2014 ${finding.issue}`);
+      if (finding.suggestion.trim() !== "") lines.push(`  fix: ${finding.suggestion}`);
+    }
+  } else {
+    lines.push("", "No issues found.");
+  }
+  return lines.join("\n");
+}
+
+// src/git/tools.ts
+import { z as z31 } from "zod";
+var GitHistoryInput = z31.object({
+  path: z31.string().describe("File to inspect; omit for the whole repository history").optional(),
+  limit: z31.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
 });
-var QuestionSchema = z30.object({
-  question: z30.string().trim().min(1),
-  header: z30.string().trim().min(1),
-  options: z30.array(QuestionOptionSchema).min(1).max(4)
+function createGitHistoryTool(workspace) {
+  return {
+    name: "GitHistory",
+    description: "Show git commit history for the repository or for one file (follows renames). Use to understand when and why code changed.",
+    inputSchema: GitHistoryInput,
+    readOnly: true,
+    paths: (input) => input.path === void 0 ? [] : [input.path],
+    summarize: (input) => input.path ?? "repository",
+    renderForModel: (output) => output,
+    async execute(input, signal) {
+      signal.throwIfAborted();
+      if (!await isGitRepository(workspace)) throw new Error("Not a git repository");
+      const limit = input.limit ?? 20;
+      const entries = await fileHistory(workspace, input.path, limit);
+      if (entries.length === 0) {
+        return input.path === void 0 ? "No commits found." : `No commits found for ${input.path} (the file may be untracked).`;
+      }
+      const scope2 = input.path === void 0 ? "repository" : input.path;
+      return [
+        `git history for ${scope2} (${entries.length} commits):`,
+        ...entries.map((entry2) => `${entry2.hash} ${entry2.date} ${entry2.author}: ${entry2.subject}`)
+      ].join("\n");
+    }
+  };
+}
+
+// src/tools/ask-user-question.ts
+import { z as z32 } from "zod";
+var QuestionOptionSchema = z32.object({
+  label: z32.string().trim().min(1),
+  description: z32.string().trim().min(1)
+});
+var QuestionSchema = z32.object({
+  question: z32.string().trim().min(1),
+  header: z32.string().trim().min(1),
+  options: z32.array(QuestionOptionSchema).min(1).max(4)
 });
-var AskUserQuestionInput = z30.object({
-  questions: z30.array(QuestionSchema).min(1).max(4)
+var AskUserQuestionInput = z32.object({
+  questions: z32.array(QuestionSchema).min(1).max(4)
 });
 function hookAnswersFromUpdatedInput(updatedInput, questions) {
   if (typeof updatedInput !== "object" || updatedInput === null) return void 0;
@@ -17655,20 +18041,20 @@ function createAskUserQuestionTool(handler) {
 }
 
 // src/tools/todo-write.ts
-import { z as z31 } from "zod";
-var TodoStatusSchema = z31.enum([
+import { z as z33 } from "zod";
+var TodoStatusSchema = z33.enum([
   "pending",
   "in_progress",
   "completed",
   "cancelled"
 ]);
-var TodoItemSchema = z31.object({
-  content: z31.string().trim().min(1),
+var TodoItemSchema = z33.object({
+  content: z33.string().trim().min(1),
   status: TodoStatusSchema,
-  activeForm: z31.string().trim().min(1)
+  activeForm: z33.string().trim().min(1)
 });
-var TodoWriteInput = z31.object({
-  todos: z31.array(TodoItemSchema).min(1).max(50)
+var TodoWriteInput = z33.object({
+  todos: z33.array(TodoItemSchema).min(1).max(50)
 });
 function createTodoWriteTool() {
   return {
@@ -17705,36 +18091,36 @@ function createTodoWriteTool() {
 import { randomUUID as randomUUID14 } from "crypto";
 import { link, lstat as lstat11, mkdir as mkdir20, readFile as readFile20, readdir as readdir10, unlink as unlink2, writeFile as writeFile12 } from "fs/promises";
 import { dirname as dirname20, join as join24, resolve as resolve24 } from "path";
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
 var TOOL_NAME = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
-var JsonSchemaObject = z32.record(z32.string(), z32.unknown()).superRefine((schema, context) => {
+var JsonSchemaObject = z34.record(z34.string(), z34.unknown()).superRefine((schema, context) => {
   if (schema.type !== "object") {
     context.addIssue({ code: "custom", message: "Tool input JSON Schema must have type object" });
   }
 });
-var RegisterManagedToolInputSchema = z32.object({
-  name: z32.string().regex(TOOL_NAME).describe("Unique callable tool name using letters, digits, and underscores"),
-  description: z32.string().min(1).max(4096).describe("Purpose and appropriate use of the generated tool"),
+var RegisterManagedToolInputSchema = z34.object({
+  name: z34.string().regex(TOOL_NAME).describe("Unique callable tool name using letters, digits, and underscores"),
+  description: z34.string().min(1).max(4096).describe("Purpose and appropriate use of the generated tool"),
   inputSchema: JsonSchemaObject.describe("Provider-facing JSON Schema with an object at the root"),
-  implementation: z32.string().min(1).max(64 * 1024).describe(
+  implementation: z34.string().min(1).max(64 * 1024).describe(
     "Async JavaScript function body, or complete function/arrow expression, receiving input, signal, and context; return the tool result"
   ),
-  scope: z32.enum(["project", "global"]).default("project").describe(
+  scope: z34.enum(["project", "global"]).default("project").describe(
     "Project persists in the current workspace; global persists for every workspace"
   ),
-  agents: z32.array(z32.enum(["main", "subagent"])).min(1).max(2).optional().describe(
+  agents: z34.array(z34.enum(["main", "subagent"])).min(1).max(2).optional().describe(
     "Agent roles allowed to call the generated tool; omit to allow both"
   )
 }).strict();
-var RemoveManagedToolInputSchema = z32.object({
-  name: z32.string().regex(TOOL_NAME).describe("Managed tool name to remove"),
-  scope: z32.enum(["project", "global"]).optional().describe("Required only when the same name exists in both scopes")
+var RemoveManagedToolInputSchema = z34.object({
+  name: z34.string().regex(TOOL_NAME).describe("Managed tool name to remove"),
+  scope: z34.enum(["project", "global"]).optional().describe("Required only when the same name exists in both scopes")
 }).strict();
 var ManagedToolRecordSchema = RegisterManagedToolInputSchema.extend({
-  version: z32.literal(MANAGED_TOOL_VERSION),
-  createdAt: z32.string().datetime()
+  version: z34.literal(MANAGED_TOOL_VERSION),
+  createdAt: z34.string().datetime()
 }).strict();
 var AsyncFunction = Object.getPrototypeOf(async function() {
 }).constructor;
@@ -17921,7 +18307,7 @@ function createManagedToolManagementTools(options) {
   const listTools = {
     name: "ListRegisteredTools",
     description: "List durable tools created through RegisterTool, including scope, path, and active precedence",
-    inputSchema: z32.object({}).strict(),
+    inputSchema: z34.object({}).strict(),
     agents: mainOnly,
     paths: () => [],
     execute: async (_input, signal) => {
@@ -17934,7 +18320,7 @@ function createManagedToolManagementTools(options) {
 function compileDefinition(record3, scope2, workspace) {
   let inputSchema;
   try {
-    inputSchema = z32.fromJSONSchema(record3.inputSchema);
+    inputSchema = z34.fromJSONSchema(record3.inputSchema);
   } catch (error) {
     throw new Error(`Invalid input schema for managed tool "${record3.name}": ${message(error)}`);
   }
@@ -18034,7 +18420,7 @@ function isMissing4(error) {
 }
 
 // src/pals/protocol.ts
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 var PROTOCOL_VERSION = 1;
 var MAX_ALIAS_LENGTH = 64;
 var MAX_MESSAGE_BYTES = 32 * 1024;
@@ -18051,65 +18437,65 @@ var MIN_UUID_PREFIX_LENGTH = 8;
 function normalizePalIdentity(value) {
   return value.trim().toLocaleLowerCase("en-US");
 }
-var VersionSchema = z33.literal(PROTOCOL_VERSION);
-var UuidSchema = z33.uuid();
-var PrintableIdentitySchema = z33.string().trim().min(1).max(MAX_ALIAS_LENGTH).refine(
+var VersionSchema = z35.literal(PROTOCOL_VERSION);
+var UuidSchema = z35.uuid();
+var PrintableIdentitySchema = z35.string().trim().min(1).max(MAX_ALIAS_LENGTH).refine(
   (value) => !/[\p{Cc}\uD800-\uDFFF]/u.test(value),
   "Identity must contain only printable non-control Unicode"
 );
 var PalAliasSchema = PrintableIdentitySchema;
 var PalTargetSchema = PrintableIdentitySchema;
-var BoundedTextSchema = z33.string().refine(
+var BoundedTextSchema = z35.string().refine(
   (value) => Buffer.byteLength(value, "utf8") <= MAX_MESSAGE_BYTES,
   `Text must not exceed ${MAX_MESSAGE_BYTES} UTF-8 bytes`
 );
 var NonEmptyBoundedTextSchema = BoundedTextSchema.refine((value) => value.length > 0, "Text must not be empty");
-var CompletionDetailSchema = z33.string().trim().min(1).refine(
+var CompletionDetailSchema = z35.string().trim().min(1).refine(
   (value) => Buffer.byteLength(value, "utf8") <= MAX_COMPLETION_DETAIL_BYTES,
   `Completion evidence must not exceed ${MAX_COMPLETION_DETAIL_BYTES} UTF-8 bytes`
 );
-var PalPresenceSchema = z33.object({
+var PalPresenceSchema = z35.object({
   version: VersionSchema,
   id: UuidSchema,
   alias: PalAliasSchema,
-  projectPath: z33.string().min(1).refine(
+  projectPath: z35.string().min(1).refine(
     (value) => Buffer.byteLength(value, "utf8") <= MAX_PROJECT_PATH_BYTES,
     `Project path must not exceed ${MAX_PROJECT_PATH_BYTES} UTF-8 bytes`
   ),
-  connectedAt: z33.iso.datetime(),
-  lastSeenAt: z33.iso.datetime()
+  connectedAt: z35.iso.datetime(),
+  lastSeenAt: z35.iso.datetime()
 }).strict();
-var PalPresenceListSchema = z33.array(PalPresenceSchema).max(MAX_ACTIVE_PALS);
-var PalTaskMessageSchema = z33.object({
+var PalPresenceListSchema = z35.array(PalPresenceSchema).max(MAX_ACTIVE_PALS);
+var PalTaskMessageSchema = z35.object({
   version: VersionSchema,
-  type: z33.literal("task"),
+  type: z35.literal("task"),
   messageId: UuidSchema,
   target: PalTargetSchema,
   goal: NonEmptyBoundedTextSchema
 }).strict();
-var PalTaskEventSchema = z33.object({
+var PalTaskEventSchema = z35.object({
   version: VersionSchema,
-  type: z33.literal("task-event"),
+  type: z35.literal("task-event"),
   messageId: UuidSchema,
   taskId: UuidSchema,
   senderId: UuidSchema,
   recipientId: UuidSchema,
-  status: z33.enum(["accepted", "started", "progress", "completed", "failed", "cancelled"]),
+  status: z35.enum(["accepted", "started", "progress", "completed", "failed", "cancelled"]),
   detail: BoundedTextSchema.optional()
 }).strict();
-var DeliveryReceiptSchema = z33.object({
+var DeliveryReceiptSchema = z35.object({
   version: VersionSchema,
-  type: z33.literal("delivery-receipt"),
+  type: z35.literal("delivery-receipt"),
   messageId: UuidSchema,
-  status: z33.enum(["delivered", "duplicate", "rejected"]),
-  recipientIds: z33.array(UuidSchema).max(MAX_PARTICIPANTS),
+  status: z35.enum(["delivered", "duplicate", "rejected"]),
+  recipientIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
   error: BoundedTextSchema.optional()
 }).strict();
-var CoWorkParticipantSchema = z33.object({
+var CoWorkParticipantSchema = z35.object({
   palId: UuidSchema,
-  required: z33.boolean()
+  required: z35.boolean()
 }).strict();
-var CoWorkProposalParticipantsSchema = z33.array(CoWorkParticipantSchema).min(2).max(MAX_PARTICIPANTS).superRefine((participants, context) => {
+var CoWorkProposalParticipantsSchema = z35.array(CoWorkParticipantSchema).min(2).max(MAX_PARTICIPANTS).superRefine((participants, context) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [index, participant] of participants.entries()) {
     const id = participant.palId.toLowerCase();
@@ -18119,19 +18505,19 @@ var CoWorkProposalParticipantsSchema = z33.array(CoWorkParticipantSchema).min(2)
     seen.add(id);
   }
 });
-var CoWorkPlanTaskSchema = z33.object({
-  id: z33.string().min(1).max(128),
+var CoWorkPlanTaskSchema = z35.object({
+  id: z35.string().min(1).max(128),
   assigneeId: UuidSchema,
   description: NonEmptyBoundedTextSchema,
-  dependsOn: z33.array(z33.string().min(1).max(128)).max(MAX_PLAN_TASKS)
+  dependsOn: z35.array(z35.string().min(1).max(128)).max(MAX_PLAN_TASKS)
 }).strict();
-var CoWorkPlanSchema = z33.object({
+var CoWorkPlanSchema = z35.object({
   version: VersionSchema,
   coWorkId: UuidSchema,
-  epoch: z33.number().int().positive(),
+  epoch: z35.number().int().positive(),
   goal: NonEmptyBoundedTextSchema,
-  participants: z33.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
-  tasks: z33.array(CoWorkPlanTaskSchema).min(1).max(MAX_PLAN_TASKS)
+  participants: z35.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
+  tasks: z35.array(CoWorkPlanTaskSchema).min(1).max(MAX_PLAN_TASKS)
 }).strict().superRefine((plan, context) => {
   if (Buffer.byteLength(JSON.stringify(plan), "utf8") > MAX_PLAN_ENCODED_BYTES) {
     context.addIssue({ code: "custom", message: `Encoded plan must not exceed ${MAX_PLAN_ENCODED_BYTES} UTF-8 bytes` });
@@ -18181,7 +18567,7 @@ var CoWorkPlanSchema = z33.object({
     }
   }
 });
-var CoWorkPhaseSchema = z33.enum([
+var CoWorkPhaseSchema = z35.enum([
   "proposed",
   "planning",
   "prepared",
@@ -18191,30 +18577,30 @@ var CoWorkPhaseSchema = z33.enum([
   "failed",
   "cancelled"
 ]);
-var IntegrationResultSchema = z33.object({
-  passed: z33.boolean(),
+var IntegrationResultSchema = z35.object({
+  passed: z35.boolean(),
   evidence: CompletionDetailSchema
 }).strict();
-var CoWorkCompletionAssertionSchema = z33.object({
+var CoWorkCompletionAssertionSchema = z35.object({
   participantId: UuidSchema,
-  passed: z33.boolean(),
+  passed: z35.boolean(),
   detail: CompletionDetailSchema.optional()
 }).strict();
-var CoWorkSnapshotSchema = z33.object({
+var CoWorkSnapshotSchema = z35.object({
   version: VersionSchema,
   coWorkId: UuidSchema,
-  epoch: z33.number().int().positive(),
+  epoch: z35.number().int().positive(),
   phase: CoWorkPhaseSchema,
   goal: NonEmptyBoundedTextSchema,
-  participants: z33.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
+  participants: z35.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
   integrationOwnerId: UuidSchema,
-  acceptedParticipantIds: z33.array(UuidSchema).max(MAX_PARTICIPANTS),
-  planHash: z33.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  acceptedParticipantIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
+  planHash: z35.string().regex(/^[a-f0-9]{64}$/).nullable(),
   plan: CoWorkPlanSchema.nullable(),
-  planAcceptedParticipantIds: z33.array(UuidSchema).max(MAX_PARTICIPANTS),
-  readyParticipantIds: z33.array(UuidSchema).max(MAX_PARTICIPANTS),
-  completedParticipantIds: z33.array(UuidSchema).max(MAX_PARTICIPANTS),
-  completionAssertions: z33.array(CoWorkCompletionAssertionSchema).max(MAX_PARTICIPANTS),
+  planAcceptedParticipantIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
+  readyParticipantIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
+  completedParticipantIds: z35.array(UuidSchema).max(MAX_PARTICIPANTS),
+  completionAssertions: z35.array(CoWorkCompletionAssertionSchema).max(MAX_PARTICIPANTS),
   integration: IntegrationResultSchema.nullable()
 }).strict().superRefine((snapshot4, context) => {
   if (Buffer.byteLength(JSON.stringify(snapshot4), "utf8") > MAX_SNAPSHOT_ENCODED_BYTES) {
@@ -18245,87 +18631,87 @@ var RequestBase = {
   version: VersionSchema,
   requestId: UuidSchema
 };
-var RegisterRequestSchema = z33.object({
+var RegisterRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("register"),
-  authToken: z33.string().regex(/^[a-f0-9]{64}$/).optional(),
+  type: z35.literal("register"),
+  authToken: z35.string().regex(/^[a-f0-9]{64}$/).optional(),
   presence: PalPresenceSchema
 }).strict();
-var HeartbeatRequestSchema = z33.object({ ...RequestBase, type: z33.literal("heartbeat") }).strict();
-var ListRequestSchema = z33.object({ ...RequestBase, type: z33.literal("list") }).strict();
-var DisconnectRequestSchema = z33.object({ ...RequestBase, type: z33.literal("disconnect") }).strict();
-var ChatRequestSchema = z33.object({
+var HeartbeatRequestSchema = z35.object({ ...RequestBase, type: z35.literal("heartbeat") }).strict();
+var ListRequestSchema = z35.object({ ...RequestBase, type: z35.literal("list") }).strict();
+var DisconnectRequestSchema = z35.object({ ...RequestBase, type: z35.literal("disconnect") }).strict();
+var ChatRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("chat"),
+  type: z35.literal("chat"),
   messageId: UuidSchema,
   target: PalTargetSchema,
   message: NonEmptyBoundedTextSchema
 }).strict();
-var TaskRequestSchema = z33.object({
+var TaskRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("task"),
+  type: z35.literal("task"),
   messageId: UuidSchema,
   target: PalTargetSchema,
   goal: NonEmptyBoundedTextSchema
 }).strict();
-var CoWorkProposeRequestSchema = z33.object({
+var CoWorkProposeRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("cowork-propose"),
+  type: z35.literal("cowork-propose"),
   coWorkId: UuidSchema,
   goal: NonEmptyBoundedTextSchema,
   participants: CoWorkProposalParticipantsSchema
 }).strict();
-var CoWorkAcceptanceRequestSchema = z33.object({
+var CoWorkAcceptanceRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("cowork-accept"),
+  type: z35.literal("cowork-accept"),
   coWorkId: UuidSchema,
-  epoch: z33.number().int().positive()
+  epoch: z35.number().int().positive()
 }).strict();
-var CoWorkPlanRequestSchema = z33.object({ ...RequestBase, type: z33.literal("cowork-plan"), plan: CoWorkPlanSchema }).strict();
-var CoWorkPlanAcceptanceRequestSchema = z33.object({
+var CoWorkPlanRequestSchema = z35.object({ ...RequestBase, type: z35.literal("cowork-plan"), plan: CoWorkPlanSchema }).strict();
+var CoWorkPlanAcceptanceRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("cowork-plan-accept"),
+  type: z35.literal("cowork-plan-accept"),
   coWorkId: UuidSchema,
-  epoch: z33.number().int().positive(),
-  planHash: z33.string().regex(/^[a-f0-9]{64}$/)
+  epoch: z35.number().int().positive(),
+  planHash: z35.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var CoWorkReadyRequestSchema = z33.object({
+var CoWorkReadyRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("cowork-ready"),
+  type: z35.literal("cowork-ready"),
   coWorkId: UuidSchema,
-  epoch: z33.number().int().positive(),
-  planHash: z33.string().regex(/^[a-f0-9]{64}$/)
+  epoch: z35.number().int().positive(),
+  planHash: z35.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var CoWorkCompleteRequestSchema = z33.object({
+var CoWorkCompleteRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("cowork-complete"),
+  type: z35.literal("cowork-complete"),
   coWorkId: UuidSchema,
-  epoch: z33.number().int().positive(),
-  planHash: z33.string().regex(/^[a-f0-9]{64}$/),
-  passed: z33.boolean(),
+  epoch: z35.number().int().positive(),
+  planHash: z35.string().regex(/^[a-f0-9]{64}$/),
+  passed: z35.boolean(),
   detail: CompletionDetailSchema.optional()
 }).strict();
-var CoWorkIntegrationRequestSchema = z33.object({
+var CoWorkIntegrationRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("cowork-integration"),
+  type: z35.literal("cowork-integration"),
   coWorkId: UuidSchema,
-  epoch: z33.number().int().positive(),
-  planHash: z33.string().regex(/^[a-f0-9]{64}$/),
-  passed: z33.boolean(),
+  epoch: z35.number().int().positive(),
+  planHash: z35.string().regex(/^[a-f0-9]{64}$/),
+  passed: z35.boolean(),
   evidence: CompletionDetailSchema
 }).strict();
-var CoWorkGetRequestSchema = z33.object({
+var CoWorkGetRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("cowork-get"),
+  type: z35.literal("cowork-get"),
   coWorkId: UuidSchema
 }).strict();
-var CoWorkCancelRequestSchema = z33.object({
+var CoWorkCancelRequestSchema = z35.object({
   ...RequestBase,
-  type: z33.literal("cowork-cancel"),
+  type: z35.literal("cowork-cancel"),
   coWorkId: UuidSchema,
   reason: NonEmptyBoundedTextSchema
 }).strict();
-var BrokerRequestSchema = z33.discriminatedUnion("type", [
+var BrokerRequestSchema = z35.discriminatedUnion("type", [
   RegisterRequestSchema,
   HeartbeatRequestSchema,
   ListRequestSchema,
@@ -18342,49 +18728,49 @@ var BrokerRequestSchema = z33.discriminatedUnion("type", [
   CoWorkGetRequestSchema,
   CoWorkCancelRequestSchema
 ]);
-var BrokerOkResponseSchema = z33.object({
+var BrokerOkResponseSchema = z35.object({
   version: VersionSchema,
-  type: z33.literal("ok"),
+  type: z35.literal("ok"),
   requestId: UuidSchema,
-  data: z33.unknown()
+  data: z35.unknown()
 }).strict();
-var BrokerErrorResponseSchema = z33.object({
+var BrokerErrorResponseSchema = z35.object({
   version: VersionSchema,
-  type: z33.literal("error"),
+  type: z35.literal("error"),
   requestId: UuidSchema,
-  code: z33.enum(["invalid-request", "authentication-failed", "not-found", "ambiguous-target", "alias-conflict", "invalid-transition", "stale-epoch", "duplicate"]),
+  code: z35.enum(["invalid-request", "authentication-failed", "not-found", "ambiguous-target", "alias-conflict", "invalid-transition", "stale-epoch", "duplicate"]),
   message: BoundedTextSchema
 }).strict();
-var ChatEventSchema = z33.object({
+var ChatEventSchema = z35.object({
   version: VersionSchema,
-  type: z33.literal("chat-event"),
+  type: z35.literal("chat-event"),
   messageId: UuidSchema,
   senderId: UuidSchema,
   recipientId: UuidSchema,
   message: NonEmptyBoundedTextSchema
 }).strict();
-var CoWorkEventSchema = z33.object({
+var CoWorkEventSchema = z35.object({
   version: VersionSchema,
-  type: z33.literal("cowork-event"),
-  action: z33.enum(["PROPOSE", "PLAN", "START", "END", "FAIL", "CANCEL"]),
+  type: z35.literal("cowork-event"),
+  action: z35.enum(["PROPOSE", "PLAN", "START", "END", "FAIL", "CANCEL"]),
   actorId: UuidSchema,
   coWorkId: UuidSchema,
-  epoch: z33.number().int().positive(),
-  planHash: z33.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  epoch: z35.number().int().positive(),
+  planHash: z35.string().regex(/^[a-f0-9]{64}$/).nullable(),
   snapshot: CoWorkSnapshotSchema
 }).strict();
-var BrokerEventSchema = z33.union([ChatEventSchema, PalTaskEventSchema, DeliveryReceiptSchema, CoWorkEventSchema]);
-var BrokerEventResponseSchema = z33.object({
+var BrokerEventSchema = z35.union([ChatEventSchema, PalTaskEventSchema, DeliveryReceiptSchema, CoWorkEventSchema]);
+var BrokerEventResponseSchema = z35.object({
   version: VersionSchema,
-  type: z33.literal("event"),
+  type: z35.literal("event"),
   event: BrokerEventSchema
 }).strict();
-var BrokerResponseSchema = z33.discriminatedUnion("type", [
+var BrokerResponseSchema = z35.discriminatedUnion("type", [
   BrokerOkResponseSchema,
   BrokerErrorResponseSchema,
   BrokerEventResponseSchema
 ]);
-var ControlFrameSchema = z33.string().refine(
+var ControlFrameSchema = z35.string().refine(
   (frame) => Buffer.byteLength(frame, "utf8") <= MAX_CONTROL_FRAME_BYTES,
   `Control frame must not exceed ${MAX_CONTROL_FRAME_BYTES} UTF-8 bytes`
 );
@@ -18419,6 +18805,8 @@ var MVP_COMMANDS = [
   "goal",
   "evolve",
   "mcp",
+  "commit",
+  "review",
   "ide",
   "memory",
   "remember",
@@ -18469,6 +18857,14 @@ function parseSlashCommand(input, dynamicCommands = [], skillCommands = []) {
   if (name === "evolve") {
     return { name, args };
   }
+  if (name === "commit") {
+    const hint = args.join(" ").trim();
+    return hint.length === 0 ? { name } : { name, hint };
+  }
+  if (name === "review") {
+    const focus = args.join(" ").trim();
+    return focus.length === 0 ? { name } : { name, focus };
+  }
   if (name === "loop") {
     const goal = args.join(" ").trim();
     if (!goal) return { name: "invalid", command: name, message: "Use /loop <goal>." };
@@ -18676,6 +19072,8 @@ var HELP = [
   "/compact  /clear  /help  /exit",
   "/loop <goal>                            run a verified autonomous loop",
   "/goal <objective>                       run a goal pipeline with adversarial verification",
+  "/commit [hint]                          draft a commit message for staged changes and commit",
+  "/review [focus]                         review uncommitted changes before committing",
   "/evolve <signals|suggest|improve <id>|verify <name>|reload <name>|test|revert <name>|done <id>>  self-improvement loop",
   "/mcp [status|tools|reconnect|enable|disable]  manage MCP servers",
   "/ide                                     show VS Code connection and cursor/selection",
@@ -19016,6 +19414,10 @@ var FlavorSession = class {
       for await (const event of this.#services.runLoop(command.goal, signal)) this.#services.output(event);
     } else if (command.name === "goal") {
       for await (const event of this.#services.runGoal(command.goal, signal)) this.#services.output(event);
+    } else if (command.name === "commit") {
+      this.#notice(await required(this.#services.gitCommit, "commit")(command.hint, signal));
+    } else if (command.name === "review") {
+      this.#notice(await required(this.#services.gitReview, "review")(command.focus, signal));
     } else if (command.name === "mcp") {
       this.#notice(await this.#services.mcp(command, signal));
     } else if (command.name === "pals") {
@@ -19285,7 +19687,7 @@ var LANG_LABELS = /* @__PURE__ */ new Map([
 ]);
 
 // src/hallucination/confidence.ts
-import { z as z34 } from "zod";
+import { z as z36 } from "zod";
 
 // src/hallucination/types.ts
 var DEFAULT_SLIDING_WINDOW_SIZE = 20;
@@ -19298,12 +19700,12 @@ var DEFAULT_EVALUATION_TIMEOUT_MS = 2e3;
 var MAX_QUERY_CHARS = 5e3;
 var MAX_OUTPUT_CHARS = 1e4;
 var MAX_EVIDENCE_CHARS = 6e3;
-var ConfidenceSchema = z34.object({
-  taskAlignment: z34.number(),
-  evidenceGrounding: z34.number(),
-  processReliability: z34.number(),
-  reason: z34.string(),
-  unsupportedClaims: z34.array(z34.string()).max(3)
+var ConfidenceSchema = z36.object({
+  taskAlignment: z36.number(),
+  evidenceGrounding: z36.number(),
+  processReliability: z36.number(),
+  reason: z36.string(),
+  unsupportedClaims: z36.array(z36.string()).max(3)
 });
 var PROMPT = `You are a fast, evidence-aware task-completion verifier.
 
@@ -21396,15 +21798,15 @@ function workspacePath(root, input) {
 }
 
 // src/tools/terminal.ts
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 import { resolve as resolve29 } from "path";
-var Id = z35.string().regex(/^term-[a-f0-9-]+$/);
-var OpenInput = z35.object({ cwd: z35.string().optional(), shell: z35.string().optional(), args: z35.array(z35.string()).optional(), columns: z35.coerce.number().int().min(10).max(500).optional(), rows: z35.coerce.number().int().min(2).max(300).optional() });
-var OptionalBoolean = z35.union([z35.boolean(), z35.string().refine((value) => value === "true" || value === "false")]);
-var WriteInput2 = z35.object({ id: Id, data: z35.string().max(1e5), enter: OptionalBoolean.optional() });
-var ReadInput3 = z35.object({ id: Id, cursor: z35.coerce.number().int().min(0).optional() });
-var ResizeInput = z35.object({ id: Id, columns: z35.coerce.number().int().min(10).max(500), rows: z35.coerce.number().int().min(2).max(300) });
-var CloseInput = z35.object({ id: Id });
+var Id = z37.string().regex(/^term-[a-f0-9-]+$/);
+var OpenInput = z37.object({ cwd: z37.string().optional(), shell: z37.string().optional(), args: z37.array(z37.string()).optional(), columns: z37.coerce.number().int().min(10).max(500).optional(), rows: z37.coerce.number().int().min(2).max(300).optional() });
+var OptionalBoolean = z37.union([z37.boolean(), z37.string().refine((value) => value === "true" || value === "false")]);
+var WriteInput2 = z37.object({ id: Id, data: z37.string().max(1e5), enter: OptionalBoolean.optional() });
+var ReadInput3 = z37.object({ id: Id, cursor: z37.coerce.number().int().min(0).optional() });
+var ResizeInput = z37.object({ id: Id, columns: z37.coerce.number().int().min(10).max(500), rows: z37.coerce.number().int().min(2).max(300) });
+var CloseInput = z37.object({ id: Id });
 function createTerminalTools(terminals, workspace = process.cwd()) {
   const tools = [
     {
@@ -21480,7 +21882,7 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
     {
       name: "TerminalList",
       description: "List persistent terminals owned by this agent",
-      inputSchema: z35.object({}),
+      inputSchema: z37.object({}),
       paths: () => [],
       execute: async (_input, _signal, context) => terminals.list(owner(context))
     }
@@ -22056,7 +22458,7 @@ var PalClient = class {
 };
 
 // src/pals/tools.ts
-import { z as z36 } from "zod";
+import { z as z38 } from "zod";
 var DEFAULT_SHARE_BUDGET_BYTES = 128 * 1024;
 var CollaborationShareGuard = class {
   redact;
@@ -22077,25 +22479,25 @@ var CollaborationShareGuard = class {
     return redacted;
   }
 };
-var Uuid = z36.uuid();
-var Hash = z36.string().regex(/^[a-f0-9]{64}$/);
+var Uuid = z38.uuid();
+var Hash = z38.string().regex(/^[a-f0-9]{64}$/);
 var Target = PalTargetSchema;
-var BoundedText = z36.string().trim().min(1).refine(
+var BoundedText = z38.string().trim().min(1).refine(
   (value) => Buffer.byteLength(value, "utf8") <= MAX_MESSAGE_BYTES,
   `Text must not exceed ${MAX_MESSAGE_BYTES} UTF-8 bytes`
 );
-var CompletionEvidence = z36.string().trim().min(1).refine(
+var CompletionEvidence = z38.string().trim().min(1).refine(
   (value) => Buffer.byteLength(value, "utf8") <= MAX_COMPLETION_DETAIL_BYTES,
   `Completion evidence must not exceed ${MAX_COMPLETION_DETAIL_BYTES} UTF-8 bytes`
 );
-var EmptyInput = z36.object({}).strict();
-var StateInput = z36.object({ coWorkId: Uuid }).strict();
-var TokenInput = z36.object({ coWorkId: Uuid, epoch: z36.number().int().positive(), planHash: Hash }).strict();
-var SendInput = z36.object({ target: Target, message: BoundedText, coWorkId: Uuid.optional() }).strict();
-var PlanInput = z36.object({ plan: CoWorkPlanSchema }).strict();
-var ProgressInput = z36.object({ coWorkId: Uuid, target: Target, detail: BoundedText }).strict();
-var CompleteInput = TokenInput.extend({ passed: z36.boolean(), detail: CompletionEvidence }).strict();
-var IntegrateInput = TokenInput.extend({ passed: z36.boolean(), evidence: CompletionEvidence }).strict();
+var EmptyInput = z38.object({}).strict();
+var StateInput = z38.object({ coWorkId: Uuid }).strict();
+var TokenInput = z38.object({ coWorkId: Uuid, epoch: z38.number().int().positive(), planHash: Hash }).strict();
+var SendInput = z38.object({ target: Target, message: BoundedText, coWorkId: Uuid.optional() }).strict();
+var PlanInput = z38.object({ plan: CoWorkPlanSchema }).strict();
+var ProgressInput = z38.object({ coWorkId: Uuid, target: Target, detail: BoundedText }).strict();
+var CompleteInput = TokenInput.extend({ passed: z38.boolean(), detail: CompletionEvidence }).strict();
+var IntegrateInput = TokenInput.extend({ passed: z38.boolean(), evidence: CompletionEvidence }).strict();
 var sharedBytes = (...values) => values.reduce((total, value) => total + Buffer.byteLength(value, "utf8"), 0);
 function resolvePresence(presences, target) {
   const normalized = normalizePalIdentity(target);
@@ -22448,6 +22850,7 @@ async function createProductionRuntime(options) {
     createApplyPatchTool(workspace, fileMutationOptions),
     createGlobTool(workspace),
     createGrepTool(workspace),
+    createGitHistoryTool(workspace),
     createShellTool(workspace, {
       jobs,
       ...executionEnvironment === void 0 ? {} : { executionEnvironment }
@@ -22824,7 +23227,7 @@ async function createProductionRuntime(options) {
     })) tools.push(tool);
     const taskTool = {
       name: "Task",
-      description: "Validate a task graph and execute its nodes with isolated child agents",
+      description: "Validate a task graph and execute its nodes with isolated child agents. Declare each node's `files` (the workspace files it may create or modify) whenever a task writes files; nodes with overlapping files are serialized automatically to prevent concurrent write conflicts.",
       inputSchema: TaskGraphSchema,
       paths: () => [],
       execute: async (input, signal) => {
@@ -23512,6 +23915,19 @@ async function createProductionRuntime(options) {
       hooksStatus: () => HOOK_EVENT_NAMES.map((name) => ({ name, pluginHandlers: pluginHooks.filter((item) => item === name).length })),
       tasks: () => ({ plan: taskPlan, graph: taskGraph, states: taskStates, results: taskResults }),
       evolve: (args) => evolveService.handleCommand(args),
+      gitCommit: (hint, signal) => runGitCommit({
+        workspace,
+        registry,
+        questions,
+        modelId: () => harness.subagentModelId,
+        notify: (message2) => emitOutput({ type: "notice", message: message2 })
+      }, hint, signal),
+      gitReview: (focus, signal) => runGitReview({
+        workspace,
+        registry,
+        modelId: () => harness.subagentModelId,
+        notify: (message2) => emitOutput({ type: "notice", message: message2 })
+      }, focus, signal),
       audit: async (toolFilter) => {
         try {
           const raw = await readFile25(auditLogger.path, "utf8");
@@ -23599,7 +24015,11 @@ ${summary2}`;
       },
       ide: () => ide.status(),
       ideContext: () => ide.editorContext(),
-      checkpoint: (label) => sessionHistory.checkpoint(label, harness.main.context.snapshot()),
+      checkpoint: async (label) => {
+        const marker = await gitMarker(workspace);
+        const tagged = marker === void 0 ? label : label === void 0 ? `git: ${marker}` : `${label} (git: ${marker})`;
+        return sessionHistory.checkpoint(tagged, harness.main.context.snapshot());
+      },
       tree: () => sessionHistory.tree(),
       rewind: async (nodeId) => {
         await sessionHistory.rewind(nodeId, harness.main.context.snapshot());
@@ -24031,6 +24451,70 @@ async function* persistEach(source, persist) {
     await persist();
   }
 }
+async function runGitCommit(deps, hint, signal) {
+  if (!await isGitRepository(deps.workspace)) return "Not a git repository \u2014 /commit needs git.";
+  let summary2 = await changeSummary(deps.workspace);
+  if (summary2.statusLines.length === 0) return "Working tree clean \u2014 nothing to commit.";
+  if (summary2.stagedFiles.length === 0) {
+    if (deps.questions === void 0) throw new Error("Nothing is staged. Run `git add` on the files you want to commit first.");
+    const stageAnswers = await deps.questions.ask([{
+      header: "Staging",
+      question: `Nothing is staged, but ${summary2.statusLines.length} change(s) exist. Stage everything before committing?`,
+      options: [
+        { label: "Stage all", description: "Run git add -A, then generate the commit message." },
+        { label: "Cancel", description: "Abort /commit and leave the working tree as-is." }
+      ]
+    }], signal);
+    if (stageAnswers[0] !== "Stage all") return "/commit cancelled \u2014 nothing was staged.";
+    await stageAll(deps.workspace);
+    summary2 = await changeSummary(deps.workspace);
+    if (summary2.stagedFiles.length === 0) return "Nothing ended up staged \u2014 /commit aborted.";
+  }
+  const staged = await stagedDiff(deps.workspace);
+  signal.throwIfAborted();
+  deps.notify?.("Generating commit message\u2026");
+  let commitMessage;
+  try {
+    commitMessage = await suggestCommitMessage(
+      { registry: deps.registry, modelId: deps.modelId },
+      { stat: staged.stat, diff: staged.diff, ...hint === void 0 ? {} : { hint } },
+      signal
+    );
+  } catch (error) {
+    signal.throwIfAborted();
+    const scope2 = summary2.stagedFiles.length === 1 ? summary2.stagedFiles[0] ?? "1 file" : `${summary2.stagedFiles.length} files`;
+    commitMessage = `chore: update ${scope2}`;
+    deps.notify?.(`Commit message generation failed (${message(error)}); using a fallback message.`);
+  }
+  deps.notify?.(`Proposed commit message:
+${commitMessage}`);
+  if (deps.questions !== void 0) {
+    const confirmAnswers = await deps.questions.ask([{
+      header: "Commit",
+      question: `Commit ${summary2.stagedFiles.length} staged file(s) on ${summary2.branch} with the message above?`,
+      options: [
+        { label: "Commit", description: "Run git commit with the proposed message." },
+        { label: "Cancel", description: "Abort; the staged changes stay as-is." }
+      ]
+    }], signal);
+    if (confirmAnswers[0] !== "Commit") return "/commit cancelled \u2014 staged changes left untouched.";
+  }
+  const result = await commit(deps.workspace, commitMessage);
+  return `Committed: ${result}`;
+}
+async function runGitReview(deps, focus, signal) {
+  if (!await isGitRepository(deps.workspace)) return "Not a git repository \u2014 /review needs git.";
+  const changes = await uncommittedDiff(deps.workspace);
+  if (changes.diff.trim() === "" && changes.untracked.length === 0) return "No uncommitted changes to review.";
+  signal.throwIfAborted();
+  deps.notify?.("Reviewing uncommitted changes\u2026");
+  const report = await reviewDiff(
+    { registry: deps.registry, modelId: deps.modelId },
+    { stat: changes.stat, diff: changes.diff, untracked: changes.untracked, ...focus === void 0 ? {} : { focus } },
+    signal
+  );
+  return formatReviewReport(report);
+}
 async function runChild(harness, skills, task, attempt, signal, parentContext) {
   return harness.runSubagent(task, async (child, childSignal) => {
     const skill = await skills.match(task.description);
@@ -24043,6 +24527,7 @@ ${await skills.loadBody(skill)}`;
       `Complete task ${task.id}: ${task.description}`,
       `Expected outputs: ${task.expectedOutputs.join("; ")}`,
       `Verification: ${task.verification.join("; ")}`,
+      ...task.files === void 0 || task.files.length === 0 ? [] : [`Owned files: ${task.files.join(", ")}. Restrict your file writes to these paths; concurrent tasks own everything else.`],
       `For completed work, finish by calling TaskOutput. Otherwise return only JSON matching these fields: ${Object.keys(SubagentResultSchema.shape).join(", ")}.${repair}`
     ].join("\n");
     for await (const event of child.loop.run({ prompt, signal: childSignal })) {
@@ -24478,7 +24963,7 @@ import { basename as basename9, join as join39, resolve as resolve33 } from "pat
 // src/d2c/workflow.ts
 import { createHash as createHash17 } from "crypto";
 import { join as join30 } from "path";
-import { z as z37 } from "zod";
+import { z as z39 } from "zod";
 
 // src/d2c/workflow-shared.ts
 function reviewProgress(workflow) {
@@ -24501,91 +24986,91 @@ function buildD2cQualityRepairPrompt(task, issue) {
 }
 
 // src/d2c/workflow.ts
-var ReviewSchema2 = z37.object({
-  fingerprint: z37.string().min(1).max(256),
-  pageId: z37.string().min(1).max(128),
-  reportId: z37.string().min(1).max(128),
-  signature: z37.string().regex(/^[a-f0-9]{64}$/),
-  label: z37.string().min(1).max(1e3),
-  decision: z37.enum(["pending", "accepted", "needs-fix"]),
-  instruction: z37.string().max(1e4).optional(),
-  moduleId: z37.string().min(1).max(128).optional(),
-  moduleSourceFiles: z37.array(z37.string().min(1).max(2048)).max(64).optional(),
-  updatedAt: z37.iso.datetime()
+var ReviewSchema2 = z39.object({
+  fingerprint: z39.string().min(1).max(256),
+  pageId: z39.string().min(1).max(128),
+  reportId: z39.string().min(1).max(128),
+  signature: z39.string().regex(/^[a-f0-9]{64}$/),
+  label: z39.string().min(1).max(1e3),
+  decision: z39.enum(["pending", "accepted", "needs-fix"]),
+  instruction: z39.string().max(1e4).optional(),
+  moduleId: z39.string().min(1).max(128).optional(),
+  moduleSourceFiles: z39.array(z39.string().min(1).max(2048)).max(64).optional(),
+  updatedAt: z39.iso.datetime()
 }).strict();
-var InteractionRunSchema = z37.object({
-  schema: z37.literal(1),
-  runAt: z37.iso.datetime(),
-  baseUrl: z37.string().url().max(2048),
-  passed: z37.boolean(),
-  total: z37.number().int().nonnegative().max(5e4),
-  failures: z37.number().int().nonnegative().max(5e4),
-  apiRequestCount: z37.number().int().nonnegative().max(1e7),
-  scenarios: z37.array(z37.object({
-    id: z37.string().min(1).max(128),
-    pageUrl: z37.string().url().max(2048),
-    passed: z37.boolean(),
-    durationMs: z37.number().int().nonnegative().max(864e5),
-    apiRequestCount: z37.number().int().nonnegative().max(1e7),
-    failure: z37.string().max(2e4).optional(),
-    requests: z37.array(z37.object({ method: z37.string().min(1).max(16), path: z37.string().min(1).max(2048), status: z37.number().int().min(0).max(599) }).strict()).max(1e4).optional()
+var InteractionRunSchema = z39.object({
+  schema: z39.literal(1),
+  runAt: z39.iso.datetime(),
+  baseUrl: z39.string().url().max(2048),
+  passed: z39.boolean(),
+  total: z39.number().int().nonnegative().max(5e4),
+  failures: z39.number().int().nonnegative().max(5e4),
+  apiRequestCount: z39.number().int().nonnegative().max(1e7),
+  scenarios: z39.array(z39.object({
+    id: z39.string().min(1).max(128),
+    pageUrl: z39.string().url().max(2048),
+    passed: z39.boolean(),
+    durationMs: z39.number().int().nonnegative().max(864e5),
+    apiRequestCount: z39.number().int().nonnegative().max(1e7),
+    failure: z39.string().max(2e4).optional(),
+    requests: z39.array(z39.object({ method: z39.string().min(1).max(16), path: z39.string().min(1).max(2048), status: z39.number().int().min(0).max(599) }).strict()).max(1e4).optional()
   }).strict()).max(5e4),
-  evidenceMode: z37.enum(["contract", "autonomous", "contract-fallback"]).optional()
+  evidenceMode: z39.enum(["contract", "autonomous", "contract-fallback"]).optional()
 }).strict();
-var QualityJudgmentSchema = z37.object({
-  schema: z37.literal(1),
-  runAt: z37.iso.datetime(),
-  model: z37.string().min(1).max(256),
-  visualScore: z37.number().min(0).max(100),
-  interactionScore: z37.number().min(0).max(100),
-  rawVisualScore: z37.number().min(0).max(100).optional(),
-  rawInteractionScore: z37.number().min(0).max(100).optional(),
-  staticVisualScore: z37.number().min(0).max(100),
-  deterministicInteractionPassed: z37.boolean(),
-  overallScore: z37.number().min(0).max(100),
-  threshold: z37.number().min(0).max(100),
-  verdict: z37.enum(["pass", "fail"]),
-  confidence: z37.enum(["high", "medium", "low"]),
-  summary: z37.string().min(1).max(4e3),
-  strengths: z37.array(z37.string().min(1).max(1e3)).max(20),
-  evidenceMode: z37.enum(["contract", "autonomous", "contract-fallback"]).optional(),
-  issues: z37.array(z37.object({
-    category: z37.enum(["visual", "interaction", "accessibility", "reliability"]),
-    severity: z37.enum(["minor", "major", "critical"]),
-    description: z37.string().min(1).max(2e3),
-    evidence: z37.string().min(1).max(2e3).optional(),
-    recommendation: z37.string().min(1).max(2e3),
-    selector: z37.string().min(1).max(2048).optional(),
-    scoreImpact: z37.number().min(0).max(30).optional(),
-    id: z37.string().regex(/^quality-[a-f0-9]{20}$/).optional(),
-    decision: z37.enum(["pending", "skipped", "fixing"]).optional(),
-    updatedAt: z37.iso.datetime().optional()
+var QualityJudgmentSchema = z39.object({
+  schema: z39.literal(1),
+  runAt: z39.iso.datetime(),
+  model: z39.string().min(1).max(256),
+  visualScore: z39.number().min(0).max(100),
+  interactionScore: z39.number().min(0).max(100),
+  rawVisualScore: z39.number().min(0).max(100).optional(),
+  rawInteractionScore: z39.number().min(0).max(100).optional(),
+  staticVisualScore: z39.number().min(0).max(100),
+  deterministicInteractionPassed: z39.boolean(),
+  overallScore: z39.number().min(0).max(100),
+  threshold: z39.number().min(0).max(100),
+  verdict: z39.enum(["pass", "fail"]),
+  confidence: z39.enum(["high", "medium", "low"]),
+  summary: z39.string().min(1).max(4e3),
+  strengths: z39.array(z39.string().min(1).max(1e3)).max(20),
+  evidenceMode: z39.enum(["contract", "autonomous", "contract-fallback"]).optional(),
+  issues: z39.array(z39.object({
+    category: z39.enum(["visual", "interaction", "accessibility", "reliability"]),
+    severity: z39.enum(["minor", "major", "critical"]),
+    description: z39.string().min(1).max(2e3),
+    evidence: z39.string().min(1).max(2e3).optional(),
+    recommendation: z39.string().min(1).max(2e3),
+    selector: z39.string().min(1).max(2048).optional(),
+    scoreImpact: z39.number().min(0).max(30).optional(),
+    id: z39.string().regex(/^quality-[a-f0-9]{20}$/).optional(),
+    decision: z39.enum(["pending", "skipped", "fixing"]).optional(),
+    updatedAt: z39.iso.datetime().optional()
   }).strict()).max(100)
 }).strict();
-var WorkflowSchema = z37.object({
-  schema: z37.literal(1),
-  task: z37.string().regex(D2C_TASK_PATTERN),
-  revision: z37.number().int().nonnegative(),
-  stage: z37.enum(["visual-review", "api-mapping", "integrating", "interaction-review", "quality-judge", "completed"]),
-  framework: z37.enum(["vue", "react"]),
-  activeReportId: z37.string().min(1).max(128),
-  activeBatchId: z37.string().min(1).max(128).optional(),
-  implementationDir: z37.string().min(1).max(32768),
-  reviews: z37.array(ReviewSchema2).max(1e4),
-  openapi: z37.object({
-    sourceName: z37.string().min(1).max(255),
-    importedAt: z37.iso.datetime(),
-    hash: z37.string().regex(/^[a-f0-9]{64}$/),
-    version: z37.string().min(1).max(32),
-    title: z37.string().min(1).max(500),
-    baseUrl: z37.string().max(4096).optional()
+var WorkflowSchema = z39.object({
+  schema: z39.literal(1),
+  task: z39.string().regex(D2C_TASK_PATTERN),
+  revision: z39.number().int().nonnegative(),
+  stage: z39.enum(["visual-review", "api-mapping", "integrating", "interaction-review", "quality-judge", "completed"]),
+  framework: z39.enum(["vue", "react"]),
+  activeReportId: z39.string().min(1).max(128),
+  activeBatchId: z39.string().min(1).max(128).optional(),
+  implementationDir: z39.string().min(1).max(32768),
+  reviews: z39.array(ReviewSchema2).max(1e4),
+  openapi: z39.object({
+    sourceName: z39.string().min(1).max(255),
+    importedAt: z39.iso.datetime(),
+    hash: z39.string().regex(/^[a-f0-9]{64}$/),
+    version: z39.string().min(1).max(32),
+    title: z39.string().min(1).max(500),
+    baseUrl: z39.string().max(4096).optional()
   }).strict().optional(),
-  mappings: z37.array(z37.unknown()).max(5e3).optional(),
-  integrationFiles: z37.array(z37.string().min(1).max(2048)).max(1e3).optional(),
-  interaction: z37.object({ manualDecision: z37.enum(["pending", "accepted"]), automated: InteractionRunSchema.optional(), updatedAt: z37.iso.datetime() }).strict().optional(),
+  mappings: z39.array(z39.unknown()).max(5e3).optional(),
+  integrationFiles: z39.array(z39.string().min(1).max(2048)).max(1e3).optional(),
+  interaction: z39.object({ manualDecision: z39.enum(["pending", "accepted"]), automated: InteractionRunSchema.optional(), updatedAt: z39.iso.datetime() }).strict().optional(),
   quality: QualityJudgmentSchema.optional(),
-  qualityWaivers: z37.array(z37.object({ issueId: z37.string().regex(/^quality-[a-f0-9]{20}$/), updatedAt: z37.iso.datetime() }).strict()).max(100).optional(),
-  updatedAt: z37.iso.datetime()
+  qualityWaivers: z39.array(z39.object({ issueId: z39.string().regex(/^quality-[a-f0-9]{20}$/), updatedAt: z39.iso.datetime() }).strict()).max(100).optional(),
+  updatedAt: z39.iso.datetime()
 }).strict();
 function pageId(report) {
   return report.page?.id ?? "index";
@@ -25002,16 +25487,16 @@ function confirmApiMapping(mapping, operationKey, operations) {
 // src/d2c/modules.ts
 import { readFile as readFile26 } from "fs/promises";
 import { isAbsolute as isAbsolute15, join as join31, normalize as normalize2, posix, sep as sep23, win32 as win322 } from "path";
-import { z as z38 } from "zod";
-var ModuleSchema = z38.object({
-  id: z38.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
-  label: z38.string().trim().min(1).max(200),
-  sourceFiles: z38.array(z38.string().trim().min(1).max(2048)).min(1).max(64),
-  keywords: z38.array(z38.string().trim().min(1).max(100)).max(100).optional(),
-  dataNeeds: z38.array(z38.string().trim().min(1).max(100)).max(100).optional(),
-  actions: z38.array(z38.string().trim().min(1).max(100)).max(100).optional()
+import { z as z40 } from "zod";
+var ModuleSchema = z40.object({
+  id: z40.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
+  label: z40.string().trim().min(1).max(200),
+  sourceFiles: z40.array(z40.string().trim().min(1).max(2048)).min(1).max(64),
+  keywords: z40.array(z40.string().trim().min(1).max(100)).max(100).optional(),
+  dataNeeds: z40.array(z40.string().trim().min(1).max(100)).max(100).optional(),
+  actions: z40.array(z40.string().trim().min(1).max(100)).max(100).optional()
 }).strict();
-var ManifestSchema3 = z38.object({ schema: z38.literal(1), modules: z38.array(ModuleSchema).min(1).max(500) }).passthrough();
+var ManifestSchema3 = z40.object({ schema: z40.literal(1), modules: z40.array(ModuleSchema).min(1).max(500) }).passthrough();
 function safeSource(path) {
   if (isAbsolute15(path) || posix.isAbsolute(path) || win322.isAbsolute(path) || path.includes("\0")) return false;
   const value = normalize2(path);
@@ -25453,7 +25938,7 @@ ${managed.output().slice(-4e3)}`);
 import { createHash as createHash19, randomUUID as randomUUID23 } from "crypto";
 import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile30, rename as rename13, stat as stat12, unlink as unlink6, writeFile as writeFile15 } from "fs/promises";
 import { join as join34 } from "path";
-import { z as z39 } from "zod";
+import { z as z41 } from "zod";
 
 // src/e2e/prd-governance.ts
 import { createHash as createHash18, randomUUID as randomUUID22 } from "crypto";
@@ -25572,38 +26057,38 @@ var RelativePrototypePath = "product/prototype/index.html";
 var RelativeInteractionPath = "product/prototype/interaction-manifest.json";
 var defaultPlanFileOperations = { rename: rename13, copyFile: copyFile2, unlink: unlink6 };
 var planWriteQueues = /* @__PURE__ */ new Map();
-var PlanSchema2 = z39.object({
-  schema: z39.literal(1),
-  task: z39.string().regex(D2C_TASK_PATTERN),
-  revision: z39.number().int().nonnegative(),
-  phase: z39.enum(["prd-generating", "prd-review", "design-generating", "design-review", "ready-for-d2c"]),
-  framework: z39.enum(["vue", "react"]),
-  technology: z39.object({
-    frontend: z39.string().trim().min(1).max(64),
-    backend: z39.string().trim().min(1).max(64),
-    frontendSource: z39.enum(["default", "requirement"]),
-    backendSource: z39.enum(["default", "requirement"])
+var PlanSchema2 = z41.object({
+  schema: z41.literal(1),
+  task: z41.string().regex(D2C_TASK_PATTERN),
+  revision: z41.number().int().nonnegative(),
+  phase: z41.enum(["prd-generating", "prd-review", "design-generating", "design-review", "ready-for-d2c"]),
+  framework: z41.enum(["vue", "react"]),
+  technology: z41.object({
+    frontend: z41.string().trim().min(1).max(64),
+    backend: z41.string().trim().min(1).max(64),
+    frontendSource: z41.enum(["default", "requirement"]),
+    backendSource: z41.enum(["default", "requirement"])
   }).strict().optional(),
-  requirement: z39.string().trim().min(2).max(5e4),
-  prd: z39.object({ path: z39.literal(RelativePrdPath), updatedAt: z39.iso.datetime(), contentHash: z39.string().regex(/^[a-f0-9]{64}$/).optional() }).strict().optional(),
-  approvedPrd: z39.object({
-    hash: z39.string().regex(/^[a-f0-9]{64}$/),
-    approvedAt: z39.iso.datetime(),
-    criteria: z39.array(z39.object({ id: z39.string().regex(/^AC-\d{3,}$/), text: z39.string().trim().min(1).max(4e3) }).strict()).min(1).max(1e4)
+  requirement: z41.string().trim().min(2).max(5e4),
+  prd: z41.object({ path: z41.literal(RelativePrdPath), updatedAt: z41.iso.datetime(), contentHash: z41.string().regex(/^[a-f0-9]{64}$/).optional() }).strict().optional(),
+  approvedPrd: z41.object({
+    hash: z41.string().regex(/^[a-f0-9]{64}$/),
+    approvedAt: z41.iso.datetime(),
+    criteria: z41.array(z41.object({ id: z41.string().regex(/^AC-\d{3,}$/), text: z41.string().trim().min(1).max(4e3) }).strict()).min(1).max(1e4)
   }).strict().optional(),
-  prototype: z39.object({
-    entryHtml: z39.literal(RelativePrototypePath),
-    interactionManifest: z39.literal(RelativeInteractionPath),
-    updatedAt: z39.iso.datetime(),
-    contentHash: z39.string().regex(/^[a-f0-9]{64}$/).optional()
+  prototype: z41.object({
+    entryHtml: z41.literal(RelativePrototypePath),
+    interactionManifest: z41.literal(RelativeInteractionPath),
+    updatedAt: z41.iso.datetime(),
+    contentHash: z41.string().regex(/^[a-f0-9]{64}$/).optional()
   }).strict().optional(),
-  feedback: z39.object({
-    stage: z39.enum(["prd", "design"]),
-    message: z39.string().trim().min(1).max(1e4),
-    updatedAt: z39.iso.datetime()
+  feedback: z41.object({
+    stage: z41.enum(["prd", "design"]),
+    message: z41.string().trim().min(1).max(1e4),
+    updatedAt: z41.iso.datetime()
   }).strict().optional(),
-  createdAt: z39.iso.datetime(),
-  updatedAt: z39.iso.datetime()
+  createdAt: z41.iso.datetime(),
+  updatedAt: z41.iso.datetime()
 }).strict();
 function d2cProductDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error("Invalid D2C task name");
@@ -25764,10 +26249,10 @@ async function writeD2cProductPlan(workspace, plan, operations = defaultPlanFile
   return parsed;
 }
 async function createD2cProductPlan(workspace, input, now = () => /* @__PURE__ */ new Date()) {
-  const parsed = z39.object({
-    task: z39.string().regex(D2C_TASK_PATTERN),
-    framework: z39.enum(["vue", "react"]),
-    requirement: z39.string().trim().min(2).max(5e4)
+  const parsed = z41.object({
+    task: z41.string().regex(D2C_TASK_PATTERN),
+    framework: z41.enum(["vue", "react"]),
+    requirement: z41.string().trim().min(2).max(5e4)
   }).strict().parse(input);
   const timestamp2 = now().toISOString();
   if (await readD2cProductPlan(workspace, parsed.task) !== void 0) {
@@ -25999,31 +26484,31 @@ function createAcceptanceEvidence(coverage, run, now = /* @__PURE__ */ new Date(
 // src/e2e/delivery-run.ts
 import { createHash as createHash21 } from "crypto";
 import { join as join35 } from "path";
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 var DELIVERY_NODE_IDS = ["requirement", "prd", "design", "d2c", "api", "acceptance", "delivery"];
-var ArtifactSchema = z40.object({
-  path: z40.string().min(1).max(32768),
-  hash: z40.string().regex(/^[a-f0-9]{64}$/),
-  bytes: z40.number().int().nonnegative(),
-  createdAt: z40.iso.datetime()
+var ArtifactSchema = z42.object({
+  path: z42.string().min(1).max(32768),
+  hash: z42.string().regex(/^[a-f0-9]{64}$/),
+  bytes: z42.number().int().nonnegative(),
+  createdAt: z42.iso.datetime()
 }).strict();
-var NodeSchema = z40.object({
-  id: z40.enum(DELIVERY_NODE_IDS),
-  status: z40.enum(["pending", "running", "waiting-approval", "succeeded", "failed", "stale"]),
-  attempt: z40.number().int().nonnegative(),
-  inputs: z40.array(ArtifactSchema).max(1e4),
-  outputs: z40.array(ArtifactSchema).max(1e4),
-  startedAt: z40.iso.datetime().optional(),
-  completedAt: z40.iso.datetime().optional(),
-  error: z40.string().max(2e4).optional()
+var NodeSchema = z42.object({
+  id: z42.enum(DELIVERY_NODE_IDS),
+  status: z42.enum(["pending", "running", "waiting-approval", "succeeded", "failed", "stale"]),
+  attempt: z42.number().int().nonnegative(),
+  inputs: z42.array(ArtifactSchema).max(1e4),
+  outputs: z42.array(ArtifactSchema).max(1e4),
+  startedAt: z42.iso.datetime().optional(),
+  completedAt: z42.iso.datetime().optional(),
+  error: z42.string().max(2e4).optional()
 }).strict();
-var DeliveryRunSchema = z40.object({
-  schema: z40.literal(1),
-  task: z40.string().regex(D2C_TASK_PATTERN),
-  revision: z40.number().int().nonnegative(),
-  nodes: z40.record(z40.enum(DELIVERY_NODE_IDS), NodeSchema),
-  createdAt: z40.iso.datetime(),
-  updatedAt: z40.iso.datetime()
+var DeliveryRunSchema = z42.object({
+  schema: z42.literal(1),
+  task: z42.string().regex(D2C_TASK_PATTERN),
+  revision: z42.number().int().nonnegative(),
+  nodes: z42.record(z42.enum(DELIVERY_NODE_IDS), NodeSchema),
+  createdAt: z42.iso.datetime(),
+  updatedAt: z42.iso.datetime()
 }).strict();
 var dependencies = {
   requirement: [],
@@ -27862,7 +28347,69 @@ function desktopWindowChrome(platform = process.platform) {
   };
 }
 
+// src/utils/crash-guard.ts
+import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join40 } from "path";
+var installed = false;
+function installCrashGuard(options = {}) {
+  if (installed) return;
+  installed = true;
+  const crashLogDir = () => {
+    try {
+      return join40((options.workspace ?? process.cwd)(), ".flavor");
+    } catch {
+      return process.cwd();
+    }
+  };
+  const writeCrashLog = (kind, detail) => {
+    try {
+      const dir = crashLogDir();
+      mkdirSync2(dir, { recursive: true });
+      const path = join40(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
+      writeFileSync(path, [
+        `kind: ${kind}`,
+        `version: ${process.version}`,
+        `platform: ${process.platform}`,
+        `time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+        "",
+        detail
+      ].join("\n"), { encoding: "utf8", mode: 384 });
+      return path;
+    } catch {
+      return void 0;
+    }
+  };
+  const restoreTerminal = () => {
+    try {
+      if (process.stdout.isTTY === true) process.stdout.write("\x1B[?25h\x1B[?1049l");
+    } catch {
+    }
+  };
+  const describe = (reason) => {
+    if (reason instanceof Error) return `${reason.name}: ${reason.message}
+${reason.stack ?? ""}`;
+    return String(reason);
+  };
+  const crash = (kind, reason) => {
+    const detail = describe(reason);
+    const logPath = writeCrashLog(kind, detail);
+    restoreTerminal();
+    try {
+      const safe = redactErrorText(detail.split("\n").slice(0, 3).join("\n"));
+      process.stderr.write(`flavor crashed (${kind}): ${safe}
+`);
+      if (logPath !== void 0) process.stderr.write(`crash log: ${logPath}
+`);
+    } catch {
+    }
+    process.exit(1);
+  };
+  process.on("unhandledRejection", (reason) => crash("unhandledRejection", reason));
+  process.on("uncaughtException", (error) => crash("uncaughtException", error));
+}
+
 // src/desktop/main.ts
+installCrashGuard();
 var moduleDirectory = dirname23(fileURLToPath4(import.meta.url));
 var developmentUrl = process.env.FLAVOR_DESKTOP_DEV_URL;
 var mainWindow;
@@ -27870,7 +28417,7 @@ var appMenu;
 var quitting = false;
 function logStartup(step, detail) {
   try {
-    const logPath = join40(dirname23(process.execPath), "flavor-code-startup.log");
+    const logPath = join41(dirname23(process.execPath), "flavor-code-startup.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(logPath, `[${ts}] ${step}${detail ? ` | ${detail}` : ""}
 `);
@@ -27895,7 +28442,7 @@ var d2cEmbedded = createEmbeddedD2cAutomation(() => {
   };
 });
 var d2cJudgeClient = createD2cJudgeClient();
-var judgeStore = () => createD2cJudgeConfigStore(join40(app.getPath("userData"), "d2c-judge.json"));
+var judgeStore = () => createD2cJudgeConfigStore(join41(app.getPath("userData"), "d2c-judge.json"));
 function judgeImage(png) {
   const image = nativeImage.createFromBuffer(png);
   const size = image.getSize();
@@ -27945,7 +28492,7 @@ var controller = new DesktopRuntimeController({
   })
 });
 function statePath() {
-  return join40(app.getPath("userData"), "desktop-state.json");
+  return join41(app.getPath("userData"), "desktop-state.json");
 }
 async function loadPersistedWorkspace() {
   try {
@@ -27980,7 +28527,7 @@ async function chooseAndOpenWorkspace() {
 var cachedAppIconDataUrl;
 function appIconDataUrl() {
   if (cachedAppIconDataUrl !== void 0) return cachedAppIconDataUrl;
-  const icon = nativeImage.createFromPath(join40(app.getAppPath(), "assets", "icon.png"));
+  const icon = nativeImage.createFromPath(join41(app.getAppPath(), "assets", "icon.png"));
   if (icon.isEmpty()) return void 0;
   cachedAppIconDataUrl = icon.toDataURL();
   return cachedAppIconDataUrl;
@@ -28225,7 +28772,7 @@ function applicationMenu() {
   ]);
 }
 async function createWindow() {
-  const rendererPath = join40(app.getAppPath(), "dist", "desktop-renderer", "index.html");
+  const rendererPath = join41(app.getAppPath(), "dist", "desktop-renderer", "index.html");
   mainWindow = new BrowserWindow2({
     title: "Flavor Code",
     width: 1280,
@@ -28236,14 +28783,14 @@ async function createWindow() {
     show: false,
     ...desktopWindowChrome(),
     webPreferences: {
-      preload: join40(moduleDirectory, "preload.cjs"),
+      preload: join41(moduleDirectory, "preload.cjs"),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
       webSecurity: true
     }
   });
-  const iconPath = join40(app.getAppPath(), "assets", "icon.png");
+  const iconPath = join41(app.getAppPath(), "assets", "icon.png");
   const icon = nativeImage.createFromPath(iconPath);
   if (!icon.isEmpty()) {
     mainWindow.setIcon(icon);