codedeck 0.5.0 → 0.5.1

package/dist/plugin/agents/orchestrator.md

@@ -1,5 +1,5 @@
 ---
-# DO NOT EDIT: generated from roles/orchestrator.md + partials (worktree, dispatch, proof).
+# DO NOT EDIT: generated from roles/orchestrator.md + partials (worktree, dispatch, proof, spec-gates, reports-dispatch).
 # Do not hand-edit; edit the manifest or partials and rebuild.
 name: orchestrator
 description: Coordinate CodeDeck workers and track their state without doing the work yourself.
@@ -7,17 +7,32 @@ tools: Bash
 ---
 
 - Use `codedeck run --role <role> --worktree "<briefing>"` so the worker has an attributable worktree, diff, and role contract.
-- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository or an uncommitted working tree elsewhere. A slice that reproduces or fixes a bug in place, or that touches a different repo, runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
+- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository, an uncommitted working tree, or gitignored/untracked files (e.g. `.specs/`) elsewhere. A slice that reproduces or fixes a bug in place, that touches a different repo, or names gitignored/untracked files runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
 
 - Always include `--role`. It selects the harness and model the human configured for that role. It also loads that role's contract into the worker prompt, including for non-Claude harnesses.
 - Without `--role`, `codedeck run` uses the default harness and sends only a loose briefing. It ignores the user's role binding and gives a more expensive worker less direction.
 - The role owns the harness and the model. `--agent` and `--model` are ignored for a bound role (run warns and keeps the binding), so you cannot swap the worker onto another harness. Changing the pairing is a `codedeck setup` decision, not a dispatch flag.
+- Dispatch only via `run --role ... --bg --json`; `open` is interactive, never dispatch.
+- `doctor` shows Role bindings; never probe `dist/` or `setup --help`, and an unbound role warns.
 - Slice by ownership. A worker owns its files end to end. Two workers in one file is a merge you will pay for.
 - Workers start with none of this context. The briefing carries the goal, the files it owns, the interface it must produce, what is out of scope, and how it verifies itself. Never write "see the conversation".
 
 - Verify before you claim.
 - Read `codedeck diff <id>` yourself before believing any worker. The artifact is authoritative, the success message is not.
 
+## Spec gates
+
+- Ask for testable specs: each acceptance criterion holds one behavior, names a SHALL, and uses the shape that fits (WHEN trigger THEN response, WHILE state, WHERE flag, IF fault THEN handling, or a plain invariant). Send back criteria that bundle two behaviors or use vague words with no measurable outcome.
+- Ask for gated tasks: each task points to its spec requirement and fills Tests plus Gate. Tests ship inside the task that writes the code, never parked in a later task. Tests none holds only for a layer the coverage matrix marks none.
+- Ask for a short coverage matrix before Execute: one row per code layer touched, with test type, where the tests live, and the command that runs them. Treat the confirmed matrix as the authority for the run.
+- Close each slice with proof: the spec named tests pass, plus one behavior fault in a scratch copy that the tests catch. Discard the scratch. Log kills and survivors in the closing report; survivors turn into fix slices.
+
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then dispatch it.
+- Dispatch a general worker to build it with the `create-report` skill by name when its harness offers it, otherwise to produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF. Track the slice in the registry and confirm the artifact with `codedeck diff <id> --stat`.
+- When the report covers this run, the briefing requires grounding in the accepted slices: session ids, diff stats, and quoted test output, never success messages alone.
+
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. That is the whole reason you must not do the work. Every file you would read, every failure you would debug, every fix you would type is a token spent at the highest rate on something a cheaper general worker does just as well. Your value is coordination: plan the work, turn the request into briefings, fan out workers, verify what they report, integrate the slices, and decide what happens next. You dispatch the work. You never do it.
 
 ## Bash is your dispatch console, not a shell
@@ -77,7 +92,7 @@ You are the CodeDeck orchestrator, and you run on the most capable and most expe
 - Drive the whole run without being asked for each phase. The human asked for the outcome once. Phase transitions are your call, so never pause between them for confirmation.
 - Size it from the request, then commit to the size. Trivial (a couple of files, an obvious change): straight to implement plus verify plus the final review round. Anything shaped like a feature: the full loop below.
 - Specify: dispatch a worker to write `.specs/features/<slug>/spec.md` with the goal, the acceptance criteria, and what is out of scope. Design and Tasks go the same way when the work needs them: `design.md` for architecture calls, `tasks.md` for atomic tasks that each carry their Tests and Gate. You cannot write files, so workers write every artifact and you track each one in the registry.
-- Execute: dispatch the tasks in dependency order. Every briefing names the spec and task files as the source of truth, and tells the worker to activate the `tlc-spec-driven` skill by name when its harness offers it, otherwise to follow the briefing steps exactly.
+- Execute: dispatch the tasks in dependency order. Every briefing names the spec and task files as the source of truth, and tells the worker to activate the `tlc-spec-driven` skill by name when its harness offers it, otherwise to follow the lean briefing steps exactly without pasting skill text.
 - Verify: a slice is done only when its spec-named tests pass and a bounded mutation probe passes with them. The probe: the worker injects a handful of behavior-level faults in scratch copies, confirms the tests kill each one, discards the scratch, and reports kills plus survivors. Survivors become fix slices, not excuses.
 - Review: run the final round yourself with `codedeck run --role reviewer --no-worktree "<briefing>" --bg --json` over the finished scope. Slice self-review never replaces it. Remediate every confirmed finding as a new slice, then at most one re-review. After that, report whatever still stands instead of looping.
 - Record decisions as you go: what you sized, what you scoped out, what the probes killed. They land in the closing report in one batch, never as questions mid-run.

package/dist/plugin/prompts/_partials/dispatch.md

@@ -1,5 +1,7 @@
 - Always include `--role`. It selects the harness and model the human configured for that role. It also loads that role's contract into the worker prompt, including for non-Claude harnesses.
 - Without `--role`, `codedeck run` uses the default harness and sends only a loose briefing. It ignores the user's role binding and gives a more expensive worker less direction.
 - The role owns the harness and the model. `--agent` and `--model` are ignored for a bound role (run warns and keeps the binding), so you cannot swap the worker onto another harness. Changing the pairing is a `codedeck setup` decision, not a dispatch flag.
+- Dispatch only via `run --role ... --bg --json`; `open` is interactive, never dispatch.
+- `doctor` shows Role bindings; never probe `dist/` or `setup --help`, and an unbound role warns.
 - Slice by ownership. A worker owns its files end to end. Two workers in one file is a merge you will pay for.
 - Workers start with none of this context. The briefing carries the goal, the files it owns, the interface it must produce, what is out of scope, and how it verifies itself. Never write "see the conversation".

package/dist/plugin/prompts/_partials/reports-dispatch.md

@@ -0,0 +1,5 @@
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then dispatch it.
+- Dispatch a general worker to build it with the `create-report` skill by name when its harness offers it, otherwise to produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF. Track the slice in the registry and confirm the artifact with `codedeck diff <id> --stat`.
+- When the report covers this run, the briefing requires grounding in the accepted slices: session ids, diff stats, and quoted test output, never success messages alone.

package/dist/plugin/prompts/_partials/reports-general.md

@@ -0,0 +1,5 @@
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then build it.
+- Use the `create-report` skill by name when the harness offers it, otherwise produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF.
+- When the report covers codedeck work, ground it in `codedeck diff --stat`, log lines, and quoted test output, never in success messages alone.

package/dist/plugin/prompts/_partials/spec-gates.md

@@ -0,0 +1,6 @@
+## Spec gates
+
+- Ask for testable specs: each acceptance criterion holds one behavior, names a SHALL, and uses the shape that fits (WHEN trigger THEN response, WHILE state, WHERE flag, IF fault THEN handling, or a plain invariant). Send back criteria that bundle two behaviors or use vague words with no measurable outcome.
+- Ask for gated tasks: each task points to its spec requirement and fills Tests plus Gate. Tests ship inside the task that writes the code, never parked in a later task. Tests none holds only for a layer the coverage matrix marks none.
+- Ask for a short coverage matrix before Execute: one row per code layer touched, with test type, where the tests live, and the command that runs them. Treat the confirmed matrix as the authority for the run.
+- Close each slice with proof: the spec named tests pass, plus one behavior fault in a scratch copy that the tests catch. Discard the scratch. Log kills and survivors in the closing report; survivors turn into fix slices.

package/dist/plugin/prompts/_partials/worktree.md

@@ -1,2 +1,2 @@
 - Use `codedeck run --role <role> --worktree "<briefing>"` so the worker has an attributable worktree, diff, and role contract.
-- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository or an uncommitted working tree elsewhere. A slice that reproduces or fixes a bug in place, or that touches a different repo, runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
+- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository, an uncommitted working tree, or gitignored/untracked files (e.g. `.specs/`) elsewhere. A slice that reproduces or fixes a bug in place, that touches a different repo, or names gitignored/untracked files runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.

package/dist/plugin/prompts/roles/general.md

@@ -9,6 +9,7 @@ includes:
   - rename-run
   - commit
   - pr-writer
+  - reports-general
 ---
 
 You are the CodeDeck general session. You do the work yourself, here. Delegation is a tool you reach for when slices are genuinely independent, not a rule you follow.

package/dist/plugin/prompts/roles/orchestrator-edit.md

@@ -6,6 +6,7 @@ includes:
   - worktree
   - dispatch
   - proof
+  - reports-dispatch
 ---
 
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. Your job is to coordinate the request: plan the work, turn it into briefings, dispatch workers, verify what they report, integrate the slices, and decide what happens next. Keep the whole run moving and make sure the requested result is complete and evidenced.

package/dist/plugin/prompts/roles/orchestrator-read.md

@@ -6,6 +6,7 @@ includes:
   - worktree
   - dispatch
   - proof
+  - reports-dispatch
 ---
 
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. Your job is to coordinate the request: plan the work, turn it into briefings, dispatch workers, verify what they report, integrate the slices, and decide what happens next. Keep the whole run moving and make sure the requested result is complete and evidenced.

package/dist/plugin/prompts/roles/orchestrator.md

@@ -6,6 +6,8 @@ includes:
   - worktree
   - dispatch
   - proof
+  - spec-gates
+  - reports-dispatch
 ---
 
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. That is the whole reason you must not do the work. Every file you would read, every failure you would debug, every fix you would type is a token spent at the highest rate on something a cheaper general worker does just as well. Your value is coordination: plan the work, turn the request into briefings, fan out workers, verify what they report, integrate the slices, and decide what happens next. You dispatch the work. You never do it.
@@ -67,7 +69,7 @@ You are the CodeDeck orchestrator, and you run on the most capable and most expe
 - Drive the whole run without being asked for each phase. The human asked for the outcome once. Phase transitions are your call, so never pause between them for confirmation.
 - Size it from the request, then commit to the size. Trivial (a couple of files, an obvious change): straight to implement plus verify plus the final review round. Anything shaped like a feature: the full loop below.
 - Specify: dispatch a worker to write `.specs/features/<slug>/spec.md` with the goal, the acceptance criteria, and what is out of scope. Design and Tasks go the same way when the work needs them: `design.md` for architecture calls, `tasks.md` for atomic tasks that each carry their Tests and Gate. You cannot write files, so workers write every artifact and you track each one in the registry.
-- Execute: dispatch the tasks in dependency order. Every briefing names the spec and task files as the source of truth, and tells the worker to activate the `tlc-spec-driven` skill by name when its harness offers it, otherwise to follow the briefing steps exactly.
+- Execute: dispatch the tasks in dependency order. Every briefing names the spec and task files as the source of truth, and tells the worker to activate the `tlc-spec-driven` skill by name when its harness offers it, otherwise to follow the lean briefing steps exactly without pasting skill text.
 - Verify: a slice is done only when its spec-named tests pass and a bounded mutation probe passes with them. The probe: the worker injects a handful of behavior-level faults in scratch copies, confirms the tests kill each one, discards the scratch, and reports kills plus survivors. Survivors become fix slices, not excuses.
 - Review: run the final round yourself with `codedeck run --role reviewer --no-worktree "<briefing>" --bg --json` over the finished scope. Slice self-review never replaces it. Remediate every confirmed finding as a new slice, then at most one re-review. After that, report whatever still stands instead of looping.
 - Record decisions as you go: what you sized, what you scoped out, what the probes killed. They land in the closing report in one batch, never as questions mid-run.

package/dist/web/canvas-page.js

@@ -42,12 +42,17 @@ export const CANVAS_PAGE = `<!doctype html>
   .dot.resting { background: #636366; }
   .dot.done { background: #3a3a3c; }
   .dot.failed { background: #ff453a; box-shadow: 0 0 8px rgba(255,69,58,.8); }
-  #feed { left: 16px; top: 112px; width: 300px; }
+  #feed { left: 16px; top: 112px; width: 330px; }
   #feed h2 { font-size: 11px; letter-spacing: .06em; color: #98989f; margin: 0 0 8px; }
-  #feed ul { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 7px; }
-  #feed li { font-size: 12.5px; color: #98989f; display: flex; gap: 8px; animation: feedIn .3s ease-out; }
-  #feed li b { color: #f5f5f7; white-space: nowrap; }
+  #feed ul { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 6px; }
+  #feed li { font-size: 12px; color: #98989f; display: flex; align-items: baseline; gap: 7px; animation: feedIn .3s ease-out; line-height: 1.35; }
+  #feed li b { color: #f5f5f7; white-space: nowrap; font-weight: 600; font-size: 12px; }
   #feed li.fresh { color: #f5f5f7; }
+  #feed li.warn { color: #ff9f0a; }
+  #feed li.bad { color: #ff453a; }
+  #feed .feed-text { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; font-size: 11.5px; }
+  #feed .feed-count { font-size: 11px; color: #636366; font-weight: 600; margin-left: 2px; white-space: nowrap; flex-shrink: 0; font-family: system-ui, sans-serif; }
+  #feed li.fresh .feed-count { color: #8e8e93; }
   @keyframes feedIn { from { opacity: 0; transform: translateY(-5px); } to { opacity: 1; } }
   #hint { left: 50%; transform: translateX(-50%); bottom: 16px; font-size: 12px; color: #98989f; white-space: nowrap; }
   #detail { position: fixed; top: 0; right: 0; bottom: 0; width: min(400px, 94vw); z-index: 20;
@@ -97,14 +102,15 @@ export const CANVAS_PAGE = `<!doctype html>
   .node:active { cursor: grabbing; }
   .node { transform-origin: 0 0; }
   .node.orch { width: 228px; border-color: rgba(255,255,255,.18); }
-  .node .row { display: flex; align-items: center; gap: 8px; }
+  .node .row { display: flex; align-items: center; gap: 8px; min-width: 0; }
+  .node .row .dot { flex-shrink: 0; }
   .node .logo { width: 22px; height: 22px; display: inline-flex; flex-shrink: 0; }
   .node .logo svg { width: 22px; height: 22px; fill: #f5f5f7; }
   .node.orch .logo { width: 26px; height: 26px; }
   .node.orch .logo svg { width: 26px; height: 26px; }
-  .node .name { font-size: 13.5px; font-weight: 650; }
-  .node .sub { font-size: 12px; color: #98989f; margin-top: 3px; }
-  .node .act { font-size: 12px; color: #98989f; margin-top: 5px; min-height: 15px; }
+  .node .name { font-size: 13.5px; font-weight: 650; flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .node .sub { font-size: 12px; color: #98989f; margin-top: 3px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .node .act { font-size: 12px; color: #98989f; margin-top: 5px; min-height: 15px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
   .node .act b { color: #f5f5f7; }
   .node.alert { border-color: rgba(255,159,10,.65); animation: alertPulse 1.6s ease-in-out infinite; }
   @keyframes alertPulse { 0%,100% { border-color: rgba(255,159,10,.65); } 50% { border-color: rgba(255,159,10,1); } }
@@ -176,28 +182,41 @@ function toolHuman(name) {
   if (name === "bash" || name === "Bash") return "terminal";
   return name;
 }
+function shortPath(s) {
+  if (!s || typeof s !== "string") return "";
+  var clean = s.replace(/\\\\/g, "/").replace(/\\/\\/+$/, "");
+  var parts = clean.split("/").filter(Boolean);
+  if (parts.length > 2) return parts.slice(-2).join("/");
+  return parts.join("/") || s;
+}
 /* Pedaco do input real da ferramenta: primeira string interessante, cortada.
    "terminal" sozinho nao diz nada; "podman ps" diz. */
 function inputSnippet(input) {
   if (!input) return "";
   if (typeof input === "string") return clip(input);
   if (typeof input !== "object") return "";
-  var keys = ["command", "cmd", "file", "path", "query", "pattern", "message", "text", "url"];
-  for (var i = 0; i < keys.length; i++) {
-    var v = input[keys[i]];
-    if (typeof v === "string" && v.trim() !== "") return clip(v);
+  if (Array.isArray(input.todos)) return "(" + input.todos.length + " tarefas)";
+  var pathKeys = ["filePath", "file_path", "filename", "file", "path", "target", "dest", "directory", "dir"];
+  for (var p = 0; p < pathKeys.length; p++) {
+    var pv = input[pathKeys[p]];
+    if (typeof pv === "string" && pv.trim() !== "") return clip(shortPath(pv.trim()));
+  }
+  var textKeys = ["command", "cmd", "script", "query", "pattern", "regex", "title", "message", "text", "prompt", "url"];
+  for (var t = 0; t < textKeys.length; t++) {
+    var tv = input[textKeys[t]];
+    if (typeof tv === "string" && tv.trim() !== "") return clip(tv.trim());
   }
   return "";
 }
 function clip(s) {
-  var one = String(s).replace(/\s+/g, " ").trim();
-  return one.length > 42 ? one.slice(0, 42) + "…" : one;
+  var one = String(s).replace(/\\s+/g, " ").trim();
+  return one.length > 40 ? one.slice(0, 40) + "…" : one;
 }
 function toolLabel(tool) {
   var name = (tool && tool.name) || "";
-  var snip = inputSnippet(tool && tool.input);
-  if (!name) return snip || "uma tarefa";
-  if (name === "bash" || name === "Bash") return snip ? '"' + snip + '"' : "terminal";
+  var snip = (tool && tool.title && typeof tool.title === "string") ? clip(tool.title) : inputSnippet(tool && tool.input);
+  if (!name) return snip || "tarefa";
+  if (name === "bash" || name === "Bash") return snip ? "$ " + snip : "terminal";
   return snip ? name + " " + snip : name;
 }
 function timeAgo(iso) {
@@ -317,17 +336,42 @@ function paintNode(n) {
   b.textContent = STATUS_HUMAN[n.status] || "Encerrada";
   n.actEl.appendChild(b);
   n.actEl.appendChild(document.createTextNode(" · " + n.activity));
+  n.actEl.title = (STATUS_HUMAN[n.status] || "") + (n.activity ? " · " + n.activity : "");
   n.el.classList.toggle("orch", !!n.isOrch);
   n.el.classList.toggle("alert", n.status === "needs_input");
   n.el.title = "sessão " + n.id + (n.label ? " · " + n.label : "");
 }
-function feed(agent, text) {
+function feed(agent, text, kind) {
+  if (!text) return;
+  var top = feedList.firstElementChild;
+  if (top && top._agent === agent && top._text === text) {
+    var count = (top._count || 1) + 1;
+    top._count = count;
+    var badge = top.querySelector(".feed-count");
+    if (!badge) {
+      badge = document.createElement("span");
+      badge.className = "feed-count";
+      top.appendChild(badge);
+    }
+    badge.textContent = "×" + count;
+    top.classList.remove("fresh");
+    void top.offsetWidth;
+    top.classList.add("fresh");
+    return;
+  }
   var li = document.createElement("li");
-  li.className = "fresh";
+  li.className = "fresh" + (kind ? " " + kind : "");
+  li._agent = agent;
+  li._text = text;
+  li._count = 1;
+  li.title = agent + ": " + text;
   var b = document.createElement("b");
   b.textContent = agent;
   li.appendChild(b);
-  li.appendChild(document.createTextNode(text));
+  var span = document.createElement("span");
+  span.className = "feed-text";
+  span.textContent = text;
+  li.appendChild(span);
   feedList.insertBefore(li, feedList.firstChild);
   while (feedList.children.length > 6) feedList.removeChild(feedList.lastChild);
   var items = feedList.children;
@@ -563,15 +607,16 @@ function onEvent(n, ev) {
     spawnRing(n, "#0a84ff");
     spawnFlow(n, "#0a84ff", 1);
     touch(n, toolLabel(ev.tool));
-    feed(agentName(n.agent), "começou: " + toolLabel(ev.tool));
+    feed(agentName(n.agent), toolLabel(ev.tool));
   } else if (ev.type === "tool.completed") {
     var bad = ev.tool && ev.tool.success === false;
     touch(n, toolLabel(ev.tool) + (bad ? " (com erro)" : " ✓"));
-    if (bad) feed(agentName(n.agent), "ferramenta falhou");
+    if (bad) feed(agentName(n.agent), "falhou: " + toolLabel(ev.tool), "bad");
   } else if (ev.type === "message") {
     if (ev.role === "assistant") {
       touch(n, "respondendo");
-      feed(agentName(n.agent), String(ev.content || "").slice(0, 90));
+      var textSnippet = clip(ev.content || "");
+      if (textSnippet) feed(agentName(n.agent), textSnippet);
     }
   } else if (ev.type === "message.queued") {
     touch(n, "mensagem na fila");
@@ -580,20 +625,20 @@ function onEvent(n, ev) {
   } else if (ev.type === "turn.started") {
     if (n.id && n.id === detailId && detailPending) { detailPending = null; paintSendState(); }
   } else if (ev.type === "turn.completed") {
-    feed(agentName(n.agent), "etapa concluída");
+    // turn completion is recorded on node activity
   } else if (ev.type === "file.changed") {
-    feed(agentName(n.agent), "mudou " + (ev.path || "um arquivo"));
+    feed(agentName(n.agent), "salvou " + (shortPath(ev.path === "unknown" ? "" : ev.path) || "arquivo"));
   } else if (ev.type === "permission.requested") {
     n.status = "needs_input";
     touch(n, "quer sua aprovação para continuar");
     paintSummary();
     spawnRing(n, "#ff9f0a");
-    feed(agentName(n.agent), "pedindo sua aprovação");
+    feed(agentName(n.agent), "precisa de aprovação", "warn");
   } else if (ev.type === "session.completed" || ev.type === "session.failed") {
     n.status = ev.type === "session.failed" ? "failed" : "completed";
     touch(n, ev.type === "session.failed" ? ("falhou: " + (ev.error || "")) : "concluída");
     paintSummary();
-    feed(agentName(n.agent), ev.type === "session.failed" ? "falhou" : "concluída");
+    feed(agentName(n.agent), ev.type === "session.failed" ? "falhou" : "concluída", ev.type === "session.failed" ? "bad" : "");
     // Stop/release cancels the queue server-side: drop a stale "na fila"
     // hint on the open detail, mirroring the turn.started branch.
     if (n.id && n.id === detailId && detailPending) { detailPending = null; paintSendState(); }
@@ -671,6 +716,7 @@ function frame() {
       if (nodes[i].runId === n.runId && nodes[i].isOrch) { o = nodes[i]; break; }
     }
     if (!o) return;
+    if (hideDone && isDone(o.status)) return;
     var e = edgeCurve(n, o);
     var pa = w2s(e.ax, e.ay), pb = w2s(e.bx, e.by), pc = w2s(e.cx, e.cy);
     ctx.beginPath();
@@ -940,8 +986,8 @@ function selectSession(id) {
     var repo = s.repository ? String(s.repository).split("/").pop() : "";
     var items = [
       ["Modelo", s.model || "—"],
-      // effort so existe quando a sessao nasceu com --effort; ausente = padrao.
-      ["Esforço", s.effort || "padrão"],
+      // effort chega sempre para claude/codex/omp/antigravity; ausente = opencode (ignora) ou sessão legada.
+      ["Esforço", s.effort || "n/a"],
       ["Repo", repo || "—"],
       ["Atividade", s.lastEvent ? (lastEventHuman(s.lastEvent) || s.lastEvent) : "—"],
     ];
@@ -973,14 +1019,14 @@ function selectSession(id) {
       } else if (ev.type === "message" && ev.role === "assistant" && ev.content) {
         chat.appendChild(chatMsg(agentName(s.agent), String(ev.content), "assistant"));
       } else if (ev.type === "tool.started") {
-        chat.appendChild(chatEvt("começou: " + toolLabel(ev.tool)));
+        chat.appendChild(chatEvt(toolLabel(ev.tool)));
       } else if (ev.type === "tool.completed") {
         var bad = ev.tool && ev.tool.success === false;
-        chat.appendChild(chatEvt("terminou: " + toolLabel(ev.tool) + (bad ? " (com erro)" : "")));
+        if (bad) chat.appendChild(chatEvt("falhou: " + toolLabel(ev.tool)));
       } else if (ev.type === "permission.requested") {
-        chat.appendChild(chatEvt("pediu aprovação: " + (ev.tool || "uma ação")));
+        chat.appendChild(chatEvt("precisa de aprovação: " + (ev.tool || "uma ação")));
       } else if (ev.type === "file.changed") {
-        chat.appendChild(chatEvt("mudou " + (ev.path || "um arquivo")));
+        chat.appendChild(chatEvt("salvou " + (shortPath(ev.path === "unknown" ? "" : ev.path) || "arquivo")));
       }
     }
     if (!chat.children.length) {

package/dist/web/canvas-page.js.map

@@ -1 +1 @@
-{"version":3,"file":"canvas-page.js","sourceRoot":"","sources":["../../src/web/canvas-page.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAuiC3B,CAAC"}
+{"version":3,"file":"canvas-page.js","sourceRoot":"","sources":["../../src/web/canvas-page.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqlC3B,CAAC"}

package/dist/web/review-page.js

@@ -58,6 +58,16 @@ export const REVIEW_PAGE = `<!doctype html>
   tr.add td.code { background: rgba(48,209,88,.10); }
   tr.del td.code { background: rgba(255,69,58,.10); }
   tr.add td.no.new { color: #30d158; } tr.del td.no.old { color: #ff453a; }
+  .tok-k { color: #ff7b72; }
+  .tok-s { color: #a5d6ff; }
+  .tok-c { color: #8b949e; font-style: italic; }
+  .tok-n { color: #79c0ff; }
+  .tok-f { color: #d2a8ff; }
+  .sign { color: #636366; user-select: none; }
+  tr.chg td.code { background: rgba(255,159,10,.06); }
+  .wd, .wd-del { border-radius: 3px; }
+  .wd { background: rgba(48,209,88,.38); }
+  .wd-del { background: rgba(255,69,58,.38); text-decoration: line-through; }
   tr.cbox td { padding: 8px 12px 10px 54px; background: rgba(10,132,255,.07); }
   .cbox textarea { width: 100%; min-height: 64px; background: rgba(255,255,255,.06);
     border: 1px solid rgba(255,255,255,.14); border-radius: 8px; color: #f5f5f7;
@@ -67,7 +77,7 @@ export const REVIEW_PAGE = `<!doctype html>
     border-radius: 8px; padding: 6px 12px; cursor: pointer; font-family: inherit; font-size: 12px; }
   .cbox button.ghost { background: transparent; }
   .cbox .ok { font-size: 11.5px; color: #30d158; }
-  .hasNote td.no.new, .hasNote td.no.old { text-decoration: underline dotted; text-underline-offset: 3px; }
+  .hasNote td.no { text-decoration: underline dotted; text-underline-offset: 3px; }
   tr.sel td.code { background: rgba(10,132,255,.20); }
   tr.sel td.no { background: rgba(10,132,255,.35); color: #fff; }
   tr.thread td { padding: 6px 12px 10px 54px; }
@@ -128,6 +138,75 @@ function langOf(p) {
     xml: "xml", json: "json", yaml: "yaml", yml: "yaml", toml: "toml", md: "md", sh: "bash", sql: "sql" };
   return map[ext] || "";
 }
+/* Minimal inline syntax highlight (kept dependency-free so the page stays
+ * self-contained/offline): single-pass tokenizer, strings before comments so
+ * "//" inside a string is not a comment. md/plain stays uncolored. */
+var HI_C = /(\\/\\*[\\s\\S]*?\\*\\/|<!--[\\s\\S]*?-->)|("(?:[^"\\\\\\n]|\\\\.)*"|'(?:[^'\\\\\\n]|\\\\.)*'|\`(?:[^\`\\\\]|\\\\.)*\`)|(\\/\\/[^\\n]*)|\\b(\\d+(?:\\.\\d+)?)\\b|\\b(break|case|catch|class|const|continue|def|delete|do|else|elif|enum|export|extends|false|finally|for|from|function|if|import|in|instanceof|interface|let|new|null|return|struct|switch|this|throw|true|try|type|typeof|var|void|while|with|as|async|await|fn|impl|match|mut|pub|self|package|func|go|defer|nil|lambda|pass|raise|yield|private|public|protected|static|final|int|float|double|char|boolean|string|number|select|chan)\\b|([A-Za-z_$][\\w$]*)(?=\\()/g;
+var HI_H = /("""[\\s\\S]*?"""|"(?:[^"\\\\\\n]|\\\\.)*"|'(?:[^'\\\\\\n]|\\\\.)*'|\`(?:[^\`\\\\]|\\\\.)*\`)|(#[^\\n]*)|\\b(\\d+(?:\\.\\d+)?)\\b|\\b(break|case|catch|class|const|continue|def|delete|do|else|elif|enum|export|extends|false|finally|for|from|function|if|import|in|instanceof|interface|let|new|null|return|struct|switch|this|throw|true|try|type|typeof|var|void|while|with|as|async|await|fn|impl|match|mut|pub|self|package|func|go|defer|nil|lambda|pass|raise|yield|private|public|protected|static|final|int|float|double|char|boolean|string|number|select|chan)\\b|([A-Za-z_$][\\w$]*)(?=\\()/g;
+function hi(code, lang) {
+  if (!code) return "";
+  if (!lang || lang === "md") return esc(code);
+  var hash = lang === "py" || lang === "bash" || lang === "yaml" || lang === "toml" || lang === "ruby" || lang === "dockerfile";
+  var re = hash ? HI_H : HI_C;
+  re.lastIndex = 0;
+  var out = "", last = 0, m, cls;
+  while ((m = re.exec(code))) {
+    out += esc(code.slice(last, m.index));
+    if (hash) cls = m[1] ? "tok-s" : m[2] ? "tok-c" : m[3] ? "tok-n" : m[4] ? "tok-k" : "tok-f";
+    else cls = m[1] ? "tok-c" : m[2] ? "tok-s" : m[3] ? "tok-c" : m[4] ? "tok-n" : m[5] ? "tok-k" : "tok-f";
+    out += '<span class="' + cls + '">' + esc(m[0]) + "</span>";
+    last = m.index + m[0].length;
+  }
+  return out + esc(code.slice(last));
+}
+/* Merged word-diff for paired del/add lines (same count in one change block):
+ * one row per line number: removed tokens struck (.wd-del), added (.wd).
+ * Token-count cap falls back to plain highlight on minified-line pairs. */
+function toks(s) {
+  var parts = String(s).match(/\\w+|\\s+|[^\\w\\s]/g) || [];
+  var out = [], pos = 0, k;
+  for (k = 0; k < parts.length; k++) { out.push({ t: parts[k], s: pos, e: pos + parts[k].length }); pos += parts[k].length; }
+  return out;
+}
+function mergeWords(oldCode, newCode, lang) {
+  var A = toks(oldCode), B = toks(newCode);
+  if (!A.length || !B.length) return hi(newCode, lang);
+  if (A.length * B.length > 10000) return hi(newCode, lang);
+  var n = A.length, m = B.length, i, j;
+  var len = [];
+  for (i = 0; i <= n; i++) { len.push([]); for (j = 0; j <= m; j++) len[i].push(0); }
+  for (i = n - 1; i >= 0; i--) {
+    for (j = m - 1; j >= 0; j--) {
+      len[i][j] = A[i].t === B[j].t ? len[i + 1][j + 1] + 1 : Math.max(len[i + 1][j], len[i][j + 1]);
+    }
+  }
+  var fa = [], fb = [];
+  for (i = 0; i < n; i++) fa.push(true);
+  for (j = 0; j < m; j++) fb.push(true);
+  i = 0; j = 0;
+  while (i < n && j < m) {
+    if (A[i].t === B[j].t) { fa[i] = false; fb[j] = false; i++; j++; }
+    else if (len[i + 1][j] >= len[i][j + 1]) i++;
+    else j++;
+  }
+  var out = "";
+  i = 0; j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && !fa[i] && !fb[j]) {
+      var ei = i, ej = j;
+      while (ei < n && ej < m && !fa[ei] && !fb[ej]) { ei++; ej++; }
+      out += hi(newCode.slice(B[j].s, B[ej - 1].e), lang);
+      i = ei; j = ej;
+    } else {
+      var oi = i, oj = j;
+      while (i < n && fa[i]) i++;
+      while (j < m && fb[j]) j++;
+      if (oi < i) out += '<span class="wd-del">' + hi(oldCode.slice(A[oi].s, A[i - 1].e), lang) + "</span>";
+      if (oj < j) out += '<span class="wd">' + hi(newCode.slice(B[oj].s, B[j - 1].e), lang) + "</span>";
+    }
+  }
+  return out;
+}
 /* Drafts: key codedeck-review:<file>:<line>[-<endLine>] -> { code, body, deleted } */
 function draftKey(file, line, endLine) { return "codedeck-review:" + file + ":" + line + (endLine && endLine !== line ? "-" + endLine : ""); }
 function loadDraft(file, line, endLine) {
@@ -294,7 +373,7 @@ function commentRow(file, line, code, deleted, endLine, onClose) {
   var tr = document.createElement("tr");
   tr.className = "cbox";
   var td = document.createElement("td");
-  td.colSpan = 3;
+  td.colSpan = 2;
   var spec = endLine && endLine !== line ? line + "-" + endLine : String(line);
   var ta = document.createElement("textarea");
   ta.placeholder = "comentar " + file + ":" + spec + "… (shift+enter envia)";
@@ -376,7 +455,7 @@ function renderThread(d) {
   tr.setAttribute("data-start", String(lo));
   tr.setAttribute("data-end", String(hi));
   var td = document.createElement("td");
-  td.colSpan = 3;
+  td.colSpan = 2;
   var box = document.createElement("div");
   box.className = "threadbox";
   var head = document.createElement("div");
@@ -452,6 +531,7 @@ function render(data) {
     var sec = document.createElement("section");
     sec.className = "file";
     sec.id = "f" + idx;
+    var lang = langOf(f.path);
     var h = document.createElement("h3");
     var title = f.status === "renamed" ? f.oldPath + " → " + f.path : f.path;
     h.innerHTML = '<span class="st ' + f.status[0].toUpperCase() + '">' + f.status[0].toUpperCase() + "</span><span>" + esc(title) + "</span>" +
@@ -475,25 +555,47 @@ function render(data) {
       sec.appendChild(hh);
       var table = document.createElement("table");
       table.className = "diff";
-      (hu.lines || []).forEach(function (ln) {
+      var wls = hu.lines || [], pmap = {}, pskip = {}, pb = 0;
+      while (pb < wls.length) {
+        if (wls[pb].type !== "add" && wls[pb].type !== "del") { pb++; continue; }
+        var pe = pb, pd = [], pa = [];
+        while (pe < wls.length && (wls[pe].type === "add" || wls[pe].type === "del")) {
+          if (wls[pe].type === "del") pd.push(pe); else pa.push(pe);
+          pe++;
+        }
+        if (pd.length && pd.length === pa.length) {
+          for (var pk = 0; pk < pd.length; pk++) {
+            pmap[pd[pk]] = pa[pk];
+            pskip[pa[pk]] = true;
+          }
+        }
+        pb = pe;
+      }
+      (hu.lines || []).forEach(function (ln, li) {
+        if (pskip[li]) return;
+        var pm = pmap[li] !== undefined ? wls[pmap[li]] : null;
         var tr = document.createElement("tr");
-        if (ln.type === "add") tr.className = "add";
+        if (pm) tr.className = "chg";
+        else if (ln.type === "add") tr.className = "add";
         else if (ln.type === "del") tr.className = "del";
-        var anchorLine = ln.newNo != null ? ln.newNo : ln.oldNo;
+        var anchorLine = pm ? pm.newNo : (ln.newNo != null ? ln.newNo : ln.oldNo);
+        var showNew = pm ? pm.newNo : ln.newNo;
+        var showCode = pm ? pm.text : ln.text;
         tr.setAttribute("data-file", f.path);
         tr.setAttribute("data-line", String(anchorLine));
-        tr.setAttribute("data-code", ln.text);
-        var tdO = document.createElement("td");
-        tdO.className = "no old";
-        tdO.textContent = ln.oldNo != null ? String(ln.oldNo) : "";
-        tdO.title = "arraste para selecionar · clique comenta a linha";
-        var tdN = document.createElement("td");
-        tdN.className = "no new";
-        tdN.textContent = ln.newNo != null ? String(ln.newNo) : "";
-        tdN.title = "arraste para selecionar · clique comenta a linha";
+        tr.setAttribute("data-code", showCode);
+        var tdG = document.createElement("td");
+        tdG.className = "no" + (pm ? "" : ln.type === "add" ? " new" : ln.type === "del" ? " old" : "");
+        var showNo = showNew != null ? showNew : ln.oldNo;
+        tdG.textContent = showNo != null ? String(showNo) : "";
+        tdG.title = "arraste para selecionar · clique comenta a linha" + (pm && ln.oldNo !== showNo ? " · era " + ln.oldNo + " no ref" : "");
         var tdC = document.createElement("td");
         tdC.className = "code";
-        tdC.textContent = (ln.type === "add" ? "+" : ln.type === "del" ? "-" : " ") + ln.text;
+        if (pm) tdC.innerHTML = mergeWords(ln.text, showCode, lang);
+        else {
+          var sign = ln.type === "add" ? "+" : ln.type === "del" ? "-" : " ";
+          tdC.innerHTML = '<span class="sign">' + esc(sign) + "</span>" + hi(ln.text, lang);
+        }
         function dragStart(ev) {
           if (ev.button !== undefined && ev.button !== 0) return;
           ev.preventDefault();
@@ -509,12 +611,9 @@ function render(data) {
           var slice = rowsBetween(sec, f.path, selAnchor.tr, tr);
           slice.forEach(function (r) { r.classList.add("sel"); });
         }
-        tdO.addEventListener("mousedown", dragStart);
-        tdN.addEventListener("mousedown", dragStart);
-        tdO.addEventListener("mouseover", dragOver);
-        tdN.addEventListener("mouseover", dragOver);
-        tr.appendChild(tdO);
-        tr.appendChild(tdN);
+        tdG.addEventListener("mousedown", dragStart);
+        tdG.addEventListener("mouseover", dragOver);
+        tr.appendChild(tdG);
         tr.appendChild(tdC);
         table.appendChild(tr);
       });

package/dist/web/review-page.js.map

@@ -1 +1 @@
-{"version":3,"file":"review-page.js","sourceRoot":"","sources":["../../src/web/review-page.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4iB3B,CAAC"}
+{"version":3,"file":"review-page.js","sourceRoot":"","sources":["../../src/web/review-page.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+oB3B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codedeck",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "CodeDeck, a local runtime for coding agents with session management, process supervision, event normalization, and git isolation",
   "type": "module",
   "bin": {