mixdog 0.9.0 → 0.9.2

package/vendor/ink/build/output.js

@@ -1,6 +1,41 @@
 import sliceAnsi from 'slice-ansi';
-import stringWidth from 'string-width';
 import { styledCharsFromTokens, styledCharsToString, tokenize, } from '@alcalzone/ansi-tokenize';
+// [mixdog fork] use the shared display-width policy so ink's per-character
+// advance + width cache treat circled digits / arrows as 2 cells under Windows
+// Terminal, matching OUR wrap/row math. See display-width.js (kept in sync with
+// src/tui/display-width.mjs).
+import { displayStringWidth as stringWidth } from './display-width.js';
+const RGB_COLOR_RE = /^rgb\(\s*(\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\s*\)$/;
+const rgbStyle = (value, type, fallback) => {
+    const match = RGB_COLOR_RE.exec(String(value || ''));
+    const parts = match
+        ? match.slice(1, 4).map(part => Math.max(0, Math.min(255, Number(part) || 0)))
+        : fallback;
+    const sgr = type === 'foreground' ? 38 : 48;
+    const reset = type === 'foreground' ? '\x1b[39m' : '\x1b[49m';
+    return { code: `\x1b[${sgr};2;${parts[0]};${parts[1]};${parts[2]}m`, endCode: reset };
+};
+const intersectClips = (clips) => {
+    if (clips.length === 0) {
+        return undefined;
+    }
+    const out = {};
+    for (const clip of clips) {
+        if (typeof clip?.x1 === 'number') {
+            out.x1 = typeof out.x1 === 'number' ? Math.max(out.x1, clip.x1) : clip.x1;
+        }
+        if (typeof clip?.x2 === 'number') {
+            out.x2 = typeof out.x2 === 'number' ? Math.min(out.x2, clip.x2) : clip.x2;
+        }
+        if (typeof clip?.y1 === 'number') {
+            out.y1 = typeof out.y1 === 'number' ? Math.max(out.y1, clip.y1) : clip.y1;
+        }
+        if (typeof clip?.y2 === 'number') {
+            out.y2 = typeof out.y2 === 'number' ? Math.min(out.y2, clip.y2) : clip.y2;
+        }
+    }
+    return out;
+};
 class OutputCaches {
     widths = new Map();
     blockWidths = new Map();
@@ -112,10 +147,19 @@ export default class Output {
                 const { text, transformers } = operation;
                 let { x, y } = operation;
                 let lines = text.split('\n');
-                const clip = clips.at(-1);
+                // [mixdog fork] Nested overflow:hidden boxes must be clipped to
+                // the INTERSECTION of every active ancestor clip. Using only the
+                // innermost clip lets child components such as ToolExecution /
+                // TurnDone (which have their own overflow hidden rows) escape the
+                // transcript viewport and paint over command/prompt/status rows.
+                const clip = intersectClips(clips);
                 if (clip) {
                     const clipHorizontally = typeof clip?.x1 === 'number' && typeof clip?.x2 === 'number';
                     const clipVertically = typeof clip?.y1 === 'number' && typeof clip?.y2 === 'number';
+                    if ((clipHorizontally && clip.x2 <= clip.x1) ||
+                        (clipVertically && clip.y2 <= clip.y1)) {
+                        continue;
+                    }
                     // If text is positioned outside of clipping area altogether,
                     // skip to the next operation to avoid unnecessary calculations
                     if (clipHorizontally) {
@@ -218,15 +262,34 @@ export default class Output {
         // dim text, and status colors do not bleed through.
         const sel = this.selection;
         let selectedText = null;
+        // [mixdog fork] noSelect exclusion (claude-code skips gutter / line-number
+        // / diff-sigil cells from both highlight and copy via screen.noSelect):
+        // mixdog's cell model has NO noSelect marker — the Output grid stores only
+        // {value, styles} per cell, with no flag distinguishing gutter cells from
+        // content. Inferring gutters from position/content would be a fragile
+        // heuristic (line numbers, diff +/- sigils, and real content are
+        // indistinguishable at the cell level), so this is deliberately NOT
+        // implemented. It needs a noSelect bit threaded through the render
+        // pipeline before it can be done cleanly.
         if (sel) {
             const captureSelectedText = sel.captureText !== false;
             if (!captureSelectedText) {
                 selectedText = undefined;
             }
-            const selectionStyles = [
-                { code: '', endCode: '' },
-                { code: '', endCode: '' },
-            ];
+            // [mixdog fork] Port applySelectionOverlay's fg-preserving principle
+            // from claude-code's selection.ts: REPLACE only the background and
+            // PRESERVE each cell's own foreground/attribute styles, so syntax
+            // highlighting, OSC-8 links, and dim text stay readable under the
+            // selection. The old code forced a black fg + light bg, flattening
+            // every colored glyph to one color. selectionForeground is now
+            // intentionally unused (kept in the setter API for compatibility).
+            const selectionBg = rgbStyle(sel.selectionBackground, 'background', [245, 245, 245]);
+            // A style entry sets the background when its opening SGR code begins
+            // with a background parameter: 40-47 (basic), 48 (256/truecolor),
+            // 49 (default), or 100-107 (bright). ansi-tokenize emits one entry
+            // per SGR attribute, so a prefix test on `.code` cleanly isolates the
+            // bg-only entries we want to drop before appending the selection bg.
+            const isBackgroundStyle = (s) => typeof s?.code === 'string' && /^\x1b\[(?:4[0-9]|10[0-7])[;m]/.test(s.code);
             const linear = sel.mode === 'linear';
             const start = linear && (sel.y1 > sel.y2 || (sel.y1 === sel.y2 && sel.x1 > sel.x2))
                 ? { x: sel.x2, y: sel.y2 }
@@ -281,9 +344,16 @@ export default class Output {
                     if (contentStart === -1 || x < contentStart || x > contentEnd) {
                         continue;
                     }
+                    // [mixdog fork] fg-preserving highlight: keep the cell's own
+                    // style entries (foreground color, bold/dim/underline, link
+                    // attrs) and swap ONLY the background. Drop any existing
+                    // background entry so the two bgs don't fight, then append the
+                    // selection bg last so it wins for this cell.
+                    const baseStyles = Array.isArray(cell.styles) ? cell.styles : [];
+                    const preserved = baseStyles.filter(style => !isBackgroundStyle(style));
                     row[x] = {
                         ...cell,
-                        styles: selectionStyles,
+                        styles: [...preserved, selectionBg],
                     };
                 }
                 // Trailing spaces in a selected row are padding, not content.
@@ -302,6 +372,20 @@ export default class Output {
                 while (selRows.length > 0 && selRows[selRows.length - 1].trim() === '') {
                     selRows.pop();
                 }
+                // [mixdog fork] SOFT-WRAP JOIN (claude-code getSelectedText):
+                // claude-code rejoins word-wrapped continuation rows into one
+                // logical line using screen.softWrap, a per-row bitmap set at
+                // wrap time marking a row as a continuation of the one above.
+                // mixdog's rect(linear) render model carries NO softWrap metadata
+                // — the Output grid is a flat array of visual rows with no record
+                // of which line breaks were inserted by wrapping vs. present in
+                // the source. Detecting "this row filled to content width AND the
+                // next continues the same logical block" from cell values alone is
+                // a guess (a source line that legitimately fills the width would be
+                // wrongly glued to the next). Per the correctness-over-cleverness
+                // rule we keep the honest per-visual-row '\n' join rather than
+                // fabricate wrap boundaries. Revisit if the render pipeline starts
+                // emitting a softWrap bit per row.
                 selectedText = selRows.join('\n');
             }
         }
@@ -317,8 +401,30 @@ export default class Output {
         const generatedOutput = output
             .map(line => {
             // See https://github.com/vadimdemedes/ink/pull/564#issuecomment-1637022742
-            const lineWithoutEmptyItems = line.filter(item => item !== undefined);
-            return styledCharsToString(lineWithoutEmptyItems).trimEnd();
+            // [mixdog fork] Keep the serialized row inside Output.width as a
+            // final invariant. Component-level width budgeting can miss
+            // background fills, resize races, or wide-char edge cases; if the
+            // terminal receives a row wider than its modeled width it may
+            // soft-wrap/scroll outside Ink's cursor-origin model.
+            const lineWithinWidth = [];
+            let usedWidth = 0;
+            for (const item of line) {
+                if (item === undefined) {
+                    continue;
+                }
+                const value = item.value ?? '';
+                if (value === '') {
+                    lineWithinWidth.push(item);
+                    continue;
+                }
+                const itemWidth = Math.max(1, this.caches.getStringWidth(value));
+                if (usedWidth + itemWidth > this.width) {
+                    break;
+                }
+                lineWithinWidth.push(item);
+                usedWidth += itemWidth;
+            }
+            return styledCharsToString(lineWithinWidth).trimEnd();
         })
             .join('\n');
         return {

package/vendor/ink/build/render-node-to-output.js

@@ -1,4 +1,7 @@
-import widestLine from 'widest-line';
+// [mixdog fork] use the shared display-width policy so the wrap decision here
+// agrees with measure-text.js and output.js. Kept in sync with
+// src/tui/display-width.mjs.
+import { displayWidestLine as widestLine } from './display-width.js';
 import indentString from 'indent-string';
 import Yoga from 'yoga-layout';
 import wrapText from './wrap-text.js';

package/vendor/ink/build/render.js

@@ -41,6 +41,10 @@ const render = (node, options) => {
         getSelectionText: () => instance.selectedText,
         // [mixdog fork] resolve the word rect at a cell for double-click select.
         getWordRectAt: (x, y) => instance.getWordRectAt(x, y),
+        // [mixdog fork] resolve the whole-line rect at a row for triple-click /
+        // line select. Symmetric to getWordRectAt; index.jsx wires it into the
+        // store as store.getLineRectAt.
+        getLineRectAt: (y) => instance.getLineRectAt(y),
     };
 };
 export default render;

package/src/hooks/lib/permission-rules.cjs

@@ -1,170 +0,0 @@
-'use strict';
-/**
- * permission-rules.cjs
- * Pattern matcher and priority evaluator. Priority order and Tool(content)
- * parsing mirror Claude Code native logic; specifier matching uses a local
- * path/command glob (native delegates per-tool content matching to each tool).
- *
- * Priority (highest → lowest): deny > ask > allow > mode default
- *
- * Pattern forms:
- *   mcp__*              → toolName starts with "mcp__"
- *   ToolName            → exact toolName match (no parens)
- *   ToolName(*)         → toolName matches AND specifier glob matches any
- *   ToolName(specifier) → toolName matches AND specifier glob matches
- *                         toolInput.path / .command / .file
- *   Glob chars: * (any chars within segment), ** (any segments)
- *
- * No external deps; no eval/Function.
- */
-
-// Read-only tool set (mixdog tool names).
-const READ_ONLY_TOOLS = new Set([
-  'read', 'list', 'glob', 'grep', 'find_symbol', 'find_references', 'find_callers', 'explore',
-  'recall', 'search', 'fetch', 'web_fetch',
-  'schedule_status', 'list_models', 'job_wait', 'download_attachment',
-]);
-
-/**
- * Find the index of the first/last UNescaped occurrence of a char.
- * A char is escaped when preceded by an odd number of backslashes.
- * Mirrors native permissionRuleParser.findFirst/LastUnescapedChar.
- */
-function findFirstUnescapedChar(str, char) {
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] !== char) continue;
-    let bs = 0, j = i - 1;
-    while (j >= 0 && str[j] === '\\') { bs++; j--; }
-    if (bs % 2 === 0) return i;
-  }
-  return -1;
-}
-
-function findLastUnescapedChar(str, char) {
-  for (let i = str.length - 1; i >= 0; i--) {
-    if (str[i] !== char) continue;
-    let bs = 0, j = i - 1;
-    while (j >= 0 && str[j] === '\\') { bs++; j--; }
-    if (bs % 2 === 0) return i;
-  }
-  return -1;
-}
-
-/** Reverse escapeRuleContent: \( -> (, \) -> ), \\ -> \ (order matters). */
-function unescapeRuleContent(content) {
-  return content
-    .replace(/\\\(/g, '(')
-    .replace(/\\\)/g, ')')
-    .replace(/\\\\/g, '\\');
-}
-
-/**
- * Convert a glob pattern string to a RegExp.
- * Supports: * (non-slash wildcard), ** (any), ? (single char).
- * Safe: no eval.
- */
-function globToRegex(glob) {
-  let src = '';
-  let i = 0;
-  while (i < glob.length) {
-    const ch = glob[i];
-    if (ch === '*' && glob[i + 1] === '*') {
-      src += '.*';
-      i += 2;
-      if (glob[i] === '/') i++; // consume trailing slash
-    } else if (ch === '*') {
-      src += '[^/\\\\]*';
-      i++;
-    } else if (ch === '?') {
-      src += '[^/\\\\]';
-      i++;
-    } else {
-      // Escape regex metacharacters
-      src += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-      i++;
-    }
-  }
-  return new RegExp('^' + src + '$', 'i');
-}
-
-/**
- * Match a single pattern entry against (toolName, toolInput).
- * Returns true if the pattern applies.
- */
-function matchesPattern(pattern, toolName, toolInput) {
-  if (typeof pattern !== 'string') return false;
-
-  // Detect Tool(specifier) form. Escape-aware, mirroring native
-  // permissionRuleValueFromString: only UNescaped parens delimit the
-  // specifier, and the close paren must be the final char.
-  const parenIdx = findFirstUnescapedChar(pattern, '(');
-  const closeIdx = findLastUnescapedChar(pattern, ')');
-  if (parenIdx > 0 && closeIdx === pattern.length - 1 && closeIdx > parenIdx) {
-    const namePart = pattern.slice(0, parenIdx);
-    const rawSpecifier = pattern.slice(parenIdx + 1, closeIdx);
-
-    if (toolName !== namePart) return false;
-
-    // Empty "()" or wildcard "(*)" specifier → tool-wide rule, match any
-    if (rawSpecifier === '' || rawSpecifier === '*') return true;
-
-    // Unescape \( \) before glob matching
-    const specifier = unescapeRuleContent(rawSpecifier);
-    // Match specifier against known path-bearing fields
-    const specRe = globToRegex(specifier);
-    const inp = toolInput || {};
-    const candidates = [...new Set([
-      inp.path, inp.command, inp.file, inp.file_path, inp.base_path, inp.cwd,
-      ...(Array.isArray(inp.path)      ? inp.path.map(p => (p && typeof p === 'object' ? p.path : p)) : []),
-      ...(Array.isArray(inp.reads)     ? inp.reads.map(r => r?.path)                              : []),
-      ...(Array.isArray(inp.edits)     ? inp.edits.flatMap(e => [e?.path, e?.file_path])          : []),
-      ...(Array.isArray(inp.writes)    ? inp.writes.flatMap(w => [w?.path, w?.file_path])         : []),
-    ].filter(v => typeof v === 'string'))];
-
-    return candidates.some(c => specRe.test(c));
-  }
-
-  // Prefix wildcard: e.g. "mcp__*"
-  if (pattern.endsWith('*')) {
-    const prefix = pattern.slice(0, -1);
-    return toolName.startsWith(prefix);
-  }
-
-  // Glob on toolName itself (may contain * or **)
-  if (pattern.includes('*') || pattern.includes('?')) {
-    return globToRegex(pattern).test(toolName);
-  }
-
-  // Exact match
-  return toolName === pattern;
-}
-
-/**
- * Evaluate priority rules against a tool call.
- *
- * @param {string}   toolName
- * @param {object}   toolInput
- * @param {string[]} allowList
- * @param {string[]} denyList
- * @param {string[]} askList
- * @returns {'deny'|'ask'|'allow'|null}  null = no list matched (use mode default)
- */
-function evaluateRules(toolName, toolInput, allowList, denyList, askList) {
-  if (denyList.some(p => matchesPattern(p, toolName, toolInput))) return 'deny';
-  if (askList.some(p => matchesPattern(p, toolName, toolInput)))  return 'ask';
-  if (allowList.some(p => matchesPattern(p, toolName, toolInput))) return 'allow';
-  return null;
-}
-
-/**
- * Determine whether a tool is considered read-only.
- * For mcp__ tools: strip the mcp__ prefix chain and check the short tool name.
- */
-function isReadOnlyTool(toolName) {
-  // Strip mcp__plugin_...__  prefix (one or more double-underscore segments)
-  const parts = toolName.split('__');
-  const shortName = parts[parts.length - 1];
-  return READ_ONLY_TOOLS.has(shortName);
-}
-
-module.exports = { matchesPattern, evaluateRules, isReadOnlyTool, READ_ONLY_TOOLS };

package/src/hooks/lib/settings-loader.cjs

@@ -1,112 +0,0 @@
-'use strict';
-/**
- * settings-loader.cjs
- * Loads and merges Mixdog settings from three tiers (lowest → highest):
- *   1. User global:   $MIXDOG_CONFIG_DIR/settings.json (or ~/.mixdog/settings.json)
- *   2. Project:       $MIXDOG_PROJECT_DIR/.mixdog/settings.json  (or cwd/.mixdog/settings.json)
- *   3. Project local: $MIXDOG_PROJECT_DIR/.mixdog/settings.local.json
- *
- * Only `permissions` sub-tree is returned; the rest is ignored.
- * Pure fs/path — no external deps.
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// ── In-process mtime-driven cache ────────────────────────────────────────────
-// Keyed by resolved file path. Each entry: { mtime: number|null, data: any }.
-// Invalidated per-tier independently when mtime changes.
-// TTL: never-expire by default (mtime-driven only).
-const _fileCache = new Map();
-
-function readJsonCached(filePath) {
-  let entry = _fileCache.get(filePath);
-  let mtime = null;
-  try { mtime = fs.statSync(filePath).mtimeMs; } catch { /* file absent */ }
-  if (entry && entry.mtime === mtime) return entry.data;
-  let data = null;
-  if (mtime !== null) {
-    try { data = JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { data = null; }
-  }
-  _fileCache.set(filePath, { mtime, data });
-  return data;
-}
-
-/** Clear the entire settings cache (for test isolation). */
-function clearSettingsCache() {
-  _fileCache.clear();
-}
-
-/**
- * Merge two permissions objects (base then overlay).
- * Arrays are concatenated and de-duped; scalar fields are overwritten.
- */
-function mergePermissions(base, overlay) {
-  if (!overlay) return base || {};
-  if (!base) return overlay || {};
-
-  const merged = Object.assign({}, base);
-
-  for (const key of ['allow', 'deny', 'ask']) {
-    const b = Array.isArray(base[key]) ? base[key] : [];
-    const o = Array.isArray(overlay[key]) ? overlay[key] : [];
-    const combined = [...b, ...o];
-    if (combined.length) merged[key] = [...new Set(combined)];
-  }
-
-  // scalar: overlay wins
-  if (overlay.defaultMode !== undefined) merged.defaultMode = overlay.defaultMode;
-
-  return merged;
-}
-
-/**
- * Load and merge settings from all three tiers.
- * Returns `{ allow: string[], deny: string[], ask: string[], defaultMode: string }`.
- */
-function loadPermissions(projectDir) {
-  const userConfigDir = process.env.MIXDOG_CONFIG_DIR ||
-    path.join(os.homedir(), '.mixdog');
-  const projDir = projectDir ||
-    process.env.MIXDOG_PROJECT_DIR ||
-    process.cwd();
-
-  const userSettings    = readJsonCached(path.join(userConfigDir, 'settings.json'));
-  const projectSettings = readJsonCached(path.join(projDir, '.mixdog', 'settings.json'));
-  const localSettings   = readJsonCached(path.join(projDir, '.mixdog', 'settings.local.json'));
-
-  // Accept permissions from `settings.permissions` (canonical) OR top-level
-  // `allow`/`deny`/`ask`/`defaultMode` fields (common user shorthand).
-  function extractPerms(s) {
-    if (!s) return {};
-    const nested = (s.permissions && typeof s.permissions === 'object') ? s.permissions : {};
-    const topLevel = {};
-    for (const key of ['allow', 'deny', 'ask']) {
-      if (Array.isArray(s[key])) topLevel[key] = s[key];
-    }
-    if (typeof s.defaultMode === 'string') topLevel.defaultMode = s.defaultMode;
-    return mergePermissions(nested, topLevel);
-  }
-  const userPerms    = extractPerms(userSettings);
-  const projectPerms = extractPerms(projectSettings);
-  const localPerms   = extractPerms(localSettings);
-
-  let merged = mergePermissions({}, userPerms);
-  merged = mergePermissions(merged, projectPerms);
-  merged = mergePermissions(merged, localPerms);
-
-  const VALID_MODES = new Set(['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions', 'auto']);
-  const rawMode = merged.defaultMode;
-  const resolvedMode = (typeof rawMode === 'string' && VALID_MODES.has(rawMode))
-    ? rawMode
-    : 'default';
-  return {
-    allow:       Array.isArray(merged.allow)       ? merged.allow       : [],
-    deny:        Array.isArray(merged.deny)        ? merged.deny        : [],
-    ask:         Array.isArray(merged.ask)         ? merged.ask         : [],
-    defaultMode: resolvedMode,
-  };
-}
-
-module.exports = { loadPermissions, clearSettingsCache };

package/src/lib/hook-pipe-path.cjs

@@ -1,10 +0,0 @@
-'use strict';
-
-// Single source for the hook IPC path. Centralizes an existing platform
-// contract (not new heuristic). Rust mirror native/mixdog-shim/src/main.rs:34-43
-// must stay in sync.
-module.exports = function hookPipePath() {
-  return process.platform === 'win32'
-    ? '\\\\.\\pipe\\mixdog-hooks'
-    : require('path').join(process.env.XDG_RUNTIME_DIR || '/tmp', 'mixdog-hooks.sock');
-};

package/src/output-styles/extreme-simple.md

@@ -1,20 +0,0 @@
----
-name: extreme-simple
-title: Extreme Simple
-description: Ultra-short completion sentence
-aliases: extreme, extreme simple
-keep-coding-instructions: true
----
-
-# Output Style
-
-Extreme — one ultra-short completion sentence. The most minimal of the styles.
-
-- Reply with a single completion sentence whenever possible.
-- Preferred pattern: `<target> 변경되었습니다. <verification> 통과 완료입니다.`
-- If verification was not run, use one short sentence saying the change is done
-  and verification was not run.
-- No headings, bullets, labels, explanations, tool traces, or metadata unless
-  the user explicitly asks.
-- Preserve only the single decisive path, command, symbol, API name, code, or
-  error verbatim.

package/src/rules/lead/04-workflow.md

@@ -1,51 +0,0 @@
-# Workflow
-
-Priority:
-- When an `# Active Workflow` block is present, it is the binding session
-  workflow and takes precedence over all other workflow guidance.
-
-Delegation:
-- Lead is the supervisor of agents, responsible for task delegation,
-  coordination, judgment, and final decisions.
-- As supervisor, prefer delegating implementation work to an agent; keep direct
-  work limited to coordination and User Workflow exceptions such as
-  one-or-two-step edits, pre-planning, config changes, and final git deployment.
-- Implementation edits to product/runtime/TUI code MUST be delegated to a
-  Worker/Heavy Worker, even when small. Lead may directly edit only rules, docs,
-  config, and final deployment/git steps, unless the user explicitly asks Lead
-  to patch directly.
-- Delegation split: different code paths / entry points / file groups are
-  separate scopes — implementation AND analysis, review, debugging split the
-  same way. With 2+ independent scopes, spawn each scoped agent in the
-  SAME turn, not one after another. Shared functions or cross-cutting concerns
-  do NOT justify collapsing them into one delegation: split per path, and Lead
-  verifies the cross-cutting parts (shared state, telemetry consistency, etc.)
-  directly. "One agent must see the whole context" is not a valid reason to
-  merge; the only legitimate single-scope case is a genuinely inseparable
-  dependency — and then state the reason.
-- Follow-up work on the same path or scope MUST reuse the existing agent (same
-  tag). Spawn a new agent only for a genuinely separate scope.
-- Pick the agent role defined in the User Workflow section that fits the task
-  (worker, heavy-worker, reviewer, debugger, …) when spawning.
-- Write agent-facing briefs and follow-up task messages in English.
-- Agent briefs must be bounded: state the goal/success criteria, known starting
-  files or anchors if available, allowed/forbidden changes, expected
-  deliverable, and verification boundary. For heavy-worker, include known first
-  components to inspect and the stopping condition; complex work must not
-  become open-ended.
-
-Agent lifecycle:
-- After spawning async agent(s), END THE TURN immediately. Do not poll
-  status/read, guess the outcome, or start dependent work — treat the result as
-  unknown until the completion notification resumes you. status/read are manual
-  recovery only, never progress checks.
-- Unless instructed otherwise, wait for the spawned agent(s); once their results
-  are collected, automatically continue with the next turn.
-
-Agent result handling:
-- Cross-check material agent responses before using them for decisions or
-  summarizing them to the user.
-- When an agent returns, always synthesize its result into a concise report for
-  the user (outcome + key changes/evidence). Never forward the raw agent output.
-- If anything here conflicts with the User Workflow section, this Workflow takes
-  precedence, except that the `# Active Workflow` block always wins.