choda-deck 0.1.1 → 0.2.0

package/dist/mcp-server.cjs

@@ -2234,8 +2234,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize2) {
-      if (normalize2 !== false)
+    function getFullPath(resolver, id = "", normalize3) {
+      if (normalize3 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -3225,8 +3225,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path7) {
-      let input = path7;
+    function removeDotSegments(path11) {
+      let input = path11;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3425,8 +3425,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path7, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path7 && path7 !== "/" ? path7 : void 0;
+        const [path11, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path11 && path11 !== "/" ? path11 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3575,7 +3575,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize2(uri, options) {
+    function normalize3(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         serialize(parse3(uri, options), options);
@@ -3811,7 +3811,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize: normalize2,
+      normalize: normalize3,
       resolve: resolve3,
       resolveComponent,
       equal,
@@ -6788,12 +6788,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs6, exportName) {
+    function addFormats(ajv, list, fs8, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs6[f]);
+        ajv.addFormat(f, fs8[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -6864,6 +6864,10 @@ var init_local_embedding_provider = __esm({
   }
 });
 
+// src/adapters/mcp/server-bootstrap.ts
+var fs7 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+
 // node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
@@ -7223,8 +7227,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path7, errorMaps, issueData } = params;
-  const fullPath = [...path7, ...issueData.path || []];
+  const { data, path: path11, errorMaps, issueData } = params;
+  const fullPath = [...path11, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7339,11 +7343,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path7, key) {
+  constructor(parent, value, path11, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path7;
+    this._path = path11;
     this._key = key;
   }
   get path() {
@@ -11266,10 +11270,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11652,11 +11656,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -11839,7 +11843,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path7 = []) => {
+  const processError = (error49, path11 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -11849,7 +11853,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -11881,8 +11885,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24288,13 +24292,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.length === 0) {
+  const path11 = ref.slice(1).split("/").filter(Boolean);
+  if (path11.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path11[0] === defsKey) {
+    const key = path11[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -27465,13 +27469,13 @@ var zodToJsonSchema = (schema, options) => {
     }, true) ?? parseAnyDef(refs)
   }), {}) : void 0;
   const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
-  const main2 = parseDef(schema._def, name === void 0 ? refs : {
+  const main = parseDef(schema._def, name === void 0 ? refs : {
     ...refs,
     currentPath: [...refs.basePath, refs.definitionPath, name]
   }, false) ?? parseAnyDef(refs);
   const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
   if (title !== void 0) {
-    main2.title = title;
+    main.title = title;
   }
   if (refs.flags.hasReferencedOpenAiAnyType) {
     if (!definitions) {
@@ -27492,9 +27496,9 @@ var zodToJsonSchema = (schema, options) => {
     }
   }
   const combined = name === void 0 ? definitions ? {
-    ...main2,
+    ...main,
     [refs.definitionPath]: definitions
-  } : main2 : {
+  } : main : {
     $ref: [
       ...refs.$refStrategy === "relative" ? [] : refs.basePath,
       refs.definitionPath,
@@ -27502,7 +27506,7 @@ var zodToJsonSchema = (schema, options) => {
     ].join("/"),
     [refs.definitionPath]: {
       ...definitions,
-      [name]: main2
+      [name]: main
     }
   };
   if (refs.target === "jsonSchema7") {
@@ -30406,6 +30410,16 @@ var WorkspaceResolutionError = class extends LifecycleError {
     this.name = "WorkspaceResolutionError";
   }
 };
+var QueueDirtyTreeError = class extends LifecycleError {
+  constructor(cwd, porcelain) {
+    super(
+      "QUEUE_DIRTY_TREE",
+      `Queue refuses to start: working tree at ${cwd} is dirty. Commit or stash first.
+${porcelain.trim()}`
+    );
+    this.name = "QueueDirtyTreeError";
+  }
+};
 
 // src/core/domain/lifecycle/inbox-lifecycle-service.ts
 var InboxLifecycleService = class {
@@ -30510,32 +30524,6 @@ function generateId(prefix) {
   return `${prefix}-${Date.now()}-${idCounter}`;
 }
 
-// src/core/domain/lifecycle/sanitize.ts
-var LEAK_MARKERS = [
-  "</resumePoint>",
-  "<parameter name",
-  "<parameter ",
-  "<invoke ",
-  "<invoke>",
-  "</invoke>",
-  "<",
-  "</",
-  "<function_calls>",
-  "</function_calls>"
-];
-function stripToolCallLeak(text) {
-  if (!text) return "";
-  let earliest = -1;
-  for (const marker of LEAK_MARKERS) {
-    const idx = text.indexOf(marker);
-    if (idx !== -1 && (earliest === -1 || idx < earliest)) {
-      earliest = idx;
-    }
-  }
-  if (earliest === -1) return text;
-  return text.slice(0, earliest).trimEnd();
-}
-
 // src/core/domain/lifecycle/conversation-lifecycle-service.ts
 var ConversationLifecycleService = class {
   constructor(db, conversations, tasks, sessions) {
@@ -30608,17 +30596,16 @@ var ConversationLifecycleService = class {
     const tx = this.db.transaction(() => {
       const conv = this.conversations.get(id);
       if (!conv) throw new ConversationNotFoundError(id);
-      const cleanDecision = stripToolCallLeak(input.decision);
       this.conversations.addMessage({
         conversationId: id,
         authorName: input.author,
-        content: cleanDecision,
+        content: input.decision,
         messageType: "decision"
       });
       const decidedAt = now();
       const updated = this.conversations.update(id, {
         status: "decided",
-        decisionSummary: cleanDecision,
+        decisionSummary: input.decision,
         decidedAt
       });
       const actions = (input.actions ?? []).map(
@@ -30654,7 +30641,12 @@ var ConversationLifecycleService = class {
           "only decided or closed conversations can reopen"
         );
       }
-      const updated = this.conversations.update(id, { status: "discussing" });
+      const updated = this.conversations.update(id, {
+        status: "discussing",
+        closedAt: null,
+        decidedAt: null,
+        decisionSummary: null
+      });
       this.conversations.emitLifecycleEvent(id, "conversation.reopen", "system", now());
       return updated;
     });
@@ -30740,8 +30732,7 @@ var SessionLifecycleService = class {
         throw new SessionStatusError(id, session.status, "only active sessions can end");
       }
       const endedAt = now();
-      const rawSummary = input.decisionSummary ?? input.handoff.resumePoint ?? "Session ended";
-      const decisionSummary = stripToolCallLeak(rawSummary) || "Session ended";
+      const decisionSummary = input.decisionSummary ?? input.handoff.resumePoint ?? "Session ended";
       const closedConversationIds = [];
       const linkedConvs = this.conversations.findByLink("session", id);
       for (const conv of linkedConvs) {
@@ -30770,6 +30761,36 @@ var SessionLifecycleService = class {
     });
     return tx();
   }
+  abandonSession(id, reason) {
+    const tx = this.db.transaction(() => {
+      const session = this.sessions.get(id);
+      if (!session) throw new SessionNotFoundError(id);
+      if (session.status !== "active") {
+        throw new SessionStatusError(id, session.status, "only active sessions can be abandoned");
+      }
+      const endedAt = now();
+      const decisionSummary = `Abandoned: ${reason}`;
+      const closedConversationIds = [];
+      const linkedConvs = this.conversations.findByLink("session", id);
+      for (const conv of linkedConvs) {
+        if (conv.status === "closed") continue;
+        this.conversations.update(conv.id, {
+          status: "closed",
+          decisionSummary,
+          closedAt: endedAt
+        });
+        closedConversationIds.push(conv.id);
+      }
+      const handoff = { ...session.handoff ?? {}, failureReason: reason };
+      const updated = this.sessions.update(id, {
+        status: "completed",
+        endedAt,
+        handoff
+      });
+      return { session: updated, closedConversationIds };
+    });
+    return tx();
+  }
   checkpointSession(id, input) {
     const session = this.sessions.get(id);
     if (!session) throw new SessionNotFoundError(id);
@@ -30796,9 +30817,947 @@ var SessionLifecycleService = class {
   }
 };
 
+// src/core/domain/lifecycle/queue-lifecycle-service.ts
+var path2 = __toESM(require("node:path"));
+
+// src/core/utils/lines.ts
+function splitLines(content) {
+  return content.split(/\r?\n/);
+}
+
+// src/core/domain/auto-safe-validator.ts
+var AUTO_SAFE_LABEL = "auto-safe";
+var AUTO_SAFE_SCOPE_HOURS_CEILING = 3;
+function validateAutoSafeTask(task) {
+  const errors = [];
+  const body = (task.body ?? "").trim();
+  if (!body) {
+    errors.push("Task body is empty \u2014 auto-safe requires AC, File Pointers, and Scope sections");
+    return { valid: false, errors };
+  }
+  const ac = extractSection(body, /^acceptance(?:\s+criteria)?$/i);
+  const filePointers = extractSection(body, /^file\s+pointers$/i);
+  const scope = extractSection(body, /^scope$/i);
+  if (!ac.trim()) {
+    errors.push("Missing ## Acceptance (or ## Acceptance Criteria) section");
+  } else if (!hasVerifiableShellCommand(ac)) {
+    errors.push(
+      "## Acceptance has no verifiable shell command (need `pnpm `, `node `, or a ```bash code block)"
+    );
+  }
+  if (!filePointers.trim()) {
+    errors.push("Missing ## File Pointers section");
+  } else if (!hasConcretePath(filePointers)) {
+    errors.push("## File Pointers has no concrete path (need at least one .ts/.md/.json/etc)");
+  }
+  if (!scope.trim()) {
+    errors.push("Missing ## Scope section");
+  } else {
+    const upper = parseScopeHours(scope);
+    if (upper === null) {
+      errors.push('## Scope has no parseable hour estimate (e.g. "~2-3h", "2h", "1.5h")');
+    } else if (upper > AUTO_SAFE_SCOPE_HOURS_CEILING) {
+      errors.push(
+        `## Scope estimate ${upper}h exceeds auto-safe ceiling of ${AUTO_SAFE_SCOPE_HOURS_CEILING}h`
+      );
+    }
+  }
+  if (mentionsBuildSensitive(body) && !hasSmokeStep(ac)) {
+    errors.push(
+      "## Acceptance must include a smoke step (body mentions build:mcp / build:cli / loader / asset copy)"
+    );
+  }
+  return { valid: errors.length === 0, errors };
+}
+function extractSection(body, headingMatcher) {
+  const lines = body.split(/\r?\n/);
+  const out = [];
+  let inSection = false;
+  for (const line of lines) {
+    const headingMatch = /^##\s+(.+?)\s*$/.exec(line);
+    if (headingMatch) {
+      if (inSection) break;
+      if (headingMatcher.test(headingMatch[1])) {
+        inSection = true;
+        continue;
+      }
+    }
+    if (inSection) out.push(line);
+  }
+  return out.join("\n");
+}
+function hasVerifiableShellCommand(section) {
+  if (/(?:^|[\s`])(?:pnpm|node)\s+\S/m.test(section)) return true;
+  if (/```bash[\s\S]*?```/.test(section)) return true;
+  return false;
+}
+function hasConcretePath(section) {
+  return /[\w./\\-]+\.(?:ts|tsx|js|mjs|cjs|mts|json|md|sh|yml|yaml)\b/.test(section);
+}
+function parseScopeHours(section) {
+  const match = /(\d+(?:\.\d+)?)\s*(?:[-–]\s*(\d+(?:\.\d+)?))?\s*h\b/i.exec(section);
+  if (!match) return null;
+  return parseFloat(match[2] ?? match[1]);
+}
+function mentionsBuildSensitive(body) {
+  return /build:(?:mcp|cli)|\bloader\b|asset\s+cop/i.test(body);
+}
+function hasSmokeStep(ac) {
+  return /\bsmoke\b/i.test(ac) || /pnpm\s+run\s+build:(?:mcp|cli)/i.test(ac);
+}
+
+// src/core/domain/lifecycle/ac-parser.ts
+function parseAcCommands(body) {
+  const section = extractAcSection(body);
+  if (!section) return [];
+  const commands = [];
+  const bashBlockRe = /```bash\s*\n([\s\S]*?)```/g;
+  let cursor = 0;
+  let match;
+  while ((match = bashBlockRe.exec(section)) !== null) {
+    const before = section.slice(cursor, match.index);
+    extractFromProse(before, commands);
+    extractFromBashBlock(match[1], commands);
+    cursor = match.index + match[0].length;
+  }
+  extractFromProse(section.slice(cursor), commands);
+  return commands;
+}
+function extractAcSection(body) {
+  const lines = splitLines(body);
+  const startIdx = lines.findIndex((l) => /^##\s+Acceptance\b/i.test(l));
+  if (startIdx === -1) return null;
+  let endIdx = lines.length;
+  let inFence = false;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (/^```/.test(lines[i])) {
+      inFence = !inFence;
+      continue;
+    }
+    if (!inFence && /^#{1,2}\s+/.test(lines[i])) {
+      endIdx = i;
+      break;
+    }
+  }
+  return lines.slice(startIdx + 1, endIdx).join("\n");
+}
+function extractFromBashBlock(content, out) {
+  for (const raw of splitLines(content)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    out.push(line);
+  }
+}
+function extractFromProse(prose, out) {
+  const inlineRe = /`((?:pnpm|node)\s[^`]+)`/g;
+  for (const line of splitLines(prose)) {
+    let matched = false;
+    let m;
+    inlineRe.lastIndex = 0;
+    while ((m = inlineRe.exec(line)) !== null) {
+      out.push(m[1].trim());
+      matched = true;
+    }
+    if (matched) continue;
+    const stripped = line.replace(/^\s*(?:[-*]\s+(?:\[[xX\s]?\]\s+)?)?/, "");
+    if (/^(pnpm|node)\s/.test(stripped)) out.push(stripped.trim());
+  }
+}
+
+// src/core/executor/prewarm-compose.ts
+function extractFilePointersSection(taskBody) {
+  const headingIdx = taskBody.indexOf("## File Pointers");
+  if (headingIdx === -1) return null;
+  const afterHeading = taskBody.slice(headingIdx + "## File Pointers".length);
+  const nextHeadingMatch = afterHeading.match(/\n##\s/);
+  const sectionEnd = nextHeadingMatch?.index ?? afterHeading.length;
+  return afterHeading.slice(0, sectionEnd);
+}
+function parseFilePointers(section) {
+  const pointers = [];
+  const lineRe = /^-\s+(?:`([^`]+)`|(\S+))/gm;
+  let m;
+  while ((m = lineRe.exec(section)) !== null) {
+    const raw = m[1] ?? m[2];
+    if (!raw) continue;
+    const colonIdx = raw.lastIndexOf(":");
+    if (colonIdx === -1) {
+      pointers.push({ filePath: raw, startLine: void 0, endLine: void 0 });
+      continue;
+    }
+    const afterColon = raw.slice(colonIdx + 1);
+    const rangeMatch = afterColon.match(/^(\d+)(?:-(\d+))?$/);
+    if (!rangeMatch) {
+      pointers.push({ filePath: raw, startLine: void 0, endLine: void 0 });
+      continue;
+    }
+    const filePath = raw.slice(0, colonIdx);
+    const startLine = parseInt(rangeMatch[1], 10);
+    const endLine = rangeMatch[2] ? parseInt(rangeMatch[2], 10) : startLine;
+    pointers.push({ filePath, startLine, endLine });
+  }
+  return pointers;
+}
+
+// src/core/executor/queue-claude-spawn.ts
+var QUEUE_SPAWN_TOOLS = "Read,Edit,Write,Bash,Grep,Glob";
+var QUEUE_SPAWN_ALLOWED_TOOLS = "Bash(pnpm *) Bash(node *) Bash(git diff*) Bash(git status*)";
+var TOKENS_PER_CHAR = 3.5;
+function computeToolSchemaTokens() {
+  const totalChars = QUEUE_SPAWN_TOOLS.length + QUEUE_SPAWN_ALLOWED_TOOLS.length;
+  return Math.ceil(totalChars / TOKENS_PER_CHAR);
+}
+
+// src/core/domain/lifecycle/queue-start-preflight.ts
+var path = __toESM(require("node:path"));
+async function validateQueueStartPreflight(input) {
+  const { tasks, repoCwd, baseRef, worktreesParentDir, branchPrefix, fns } = input;
+  const globalErrors = [];
+  const [baseSha, parentExists, ghOk] = await Promise.all([
+    fns.resolveRef(repoCwd, baseRef),
+    fns.pathExists(worktreesParentDir),
+    fns.ghAuthStatus()
+  ]);
+  if (baseSha === null) {
+    globalErrors.push(`baseRef "${baseRef}" is unresolvable in ${repoCwd}`);
+  }
+  if (!parentExists) {
+    globalErrors.push(`worktrees parent dir does not exist: ${worktreesParentDir}`);
+  } else {
+    const writable = await fns.isWritable(worktreesParentDir);
+    if (!writable) {
+      globalErrors.push(`worktrees parent dir is not writable: ${worktreesParentDir}`);
+    }
+  }
+  if (!ghOk) {
+    globalErrors.push("gh auth status failed \u2014 `gh` is not authenticated (queue start ends with PR create)");
+  }
+  const failures = [];
+  for (const task of tasks) {
+    const reasons = await validateTask(task, repoCwd, baseSha, worktreesParentDir, branchPrefix, fns);
+    if (reasons.length > 0) {
+      failures.push({ taskId: task.id, reasons });
+    }
+  }
+  return {
+    ok: globalErrors.length === 0 && failures.length === 0,
+    baseSha,
+    failures,
+    globalErrors
+  };
+}
+async function validateTask(task, repoCwd, baseSha, worktreesParentDir, branchPrefix, fns) {
+  const reasons = [];
+  if (!task.labels.includes(AUTO_SAFE_LABEL)) {
+    reasons.push(`missing label "${AUTO_SAFE_LABEL}"`);
+  }
+  const structural = validateAutoSafeTask(task);
+  if (!structural.valid) {
+    for (const err of structural.errors) {
+      reasons.push(`structural: ${err}`);
+    }
+  }
+  const worktreePath = path.join(worktreesParentDir, task.id);
+  const branchName = `${branchPrefix}${task.id}`;
+  const [worktreeExists, branchAlreadyThere] = await Promise.all([
+    fns.pathExists(worktreePath),
+    fns.branchExists(repoCwd, branchName)
+  ]);
+  if (worktreeExists) {
+    reasons.push(`worktree path already exists: ${worktreePath} (run cleanup_worktree_orphans first)`);
+  }
+  if (branchAlreadyThere) {
+    reasons.push(`branch already exists: ${branchName}`);
+  }
+  if (baseSha !== null && structural.valid) {
+    const section = extractFilePointersSection(task.body ?? "");
+    if (section !== null) {
+      const pointers = parseFilePointers(section);
+      for (const pointer of pointers) {
+        if (pointer.startLine === void 0) continue;
+        const exists = await fns.fileExistsAtSha(repoCwd, baseSha, pointer.filePath);
+        if (!exists) {
+          reasons.push(`File Pointer with range references missing file at baseSha: ${pointer.filePath}`);
+        }
+      }
+    }
+  }
+  return reasons;
+}
+
+// src/core/domain/lifecycle/queue-lifecycle-service.ts
+var DEFAULT_MAX_COST_PER_TASK = 1.5;
+var DEFAULT_MODEL = "claude-sonnet-4-6";
+var DEFAULT_AC_TIMEOUT_MS = 10 * 60 * 1e3;
+var AUTO_FAILED_LABEL = "auto-failed";
+var TOKENS_PER_CHAR2 = 3.5;
+function estimateMcpTokens(content) {
+  return Math.ceil(content.length / TOKENS_PER_CHAR2);
+}
+var TRANSIENT_PATTERNS = [
+  /rate.?limit/i,
+  /overloaded/i,
+  /service unavailable/i,
+  /\bECONNRESET\b/,
+  /\bETIMEDOUT\b/,
+  /\bECONNREFUSED\b/,
+  /out of memory/i,
+  /\bOOM\b/,
+  /timed out/i
+];
+function isTransientMessage(msg) {
+  return TRANSIENT_PATTERNS.some((p) => p.test(msg));
+}
+var QueueLifecycleService = class {
+  constructor(tasks, workspaces, conversations, sessions, runtime) {
+    this.tasks = tasks;
+    this.workspaces = workspaces;
+    this.conversations = conversations;
+    this.sessions = sessions;
+    this.runtime = runtime;
+  }
+  tasks;
+  workspaces;
+  conversations;
+  sessions;
+  runtime;
+  async runQueue(opts) {
+    const ws = this.workspaces.get(opts.workspaceId);
+    if (!ws) {
+      throw new WorkspaceResolutionError(`workspace ${opts.workspaceId} not found`);
+    }
+    const porcelain = await this.runtime.gitStatusPorcelain(ws.cwd);
+    if (porcelain.trim()) throw new QueueDirtyTreeError(ws.cwd, porcelain);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const branch = await this.runtime.gitCurrentBranch(ws.cwd);
+    const commitSha = await this.runtime.gitHeadSha(ws.cwd);
+    const eligible = this.collectEligibleTasks(ws);
+    const taskCap = opts.maxTasks ?? eligible.length;
+    const tasks = eligible.slice(0, taskCap);
+    const queueRunId = `${Date.now()}-${Math.floor(Math.random() * 1e6).toString(36)}`;
+    const artifactDir = path2.join(this.runtime.artifactsDir, `queue-${queueRunId}`);
+    if (opts.dryRun) {
+      return {
+        done: [],
+        failed: [],
+        skipped: tasks,
+        totalCostUsd: 0,
+        halted: false,
+        haltReason: null,
+        haltCode: null,
+        queueRunId,
+        artifactDir
+      };
+    }
+    await this.runtime.mkdir(artifactDir);
+    const maxCostPerTask = opts.maxCostPerTask ?? DEFAULT_MAX_COST_PER_TASK;
+    const maxBudgetUsd = round2(maxCostPerTask * 0.95);
+    const model = opts.model ?? DEFAULT_MODEL;
+    const claudeBin = opts.claudeBin ?? "claude";
+    const acTimeoutMs = opts.acTimeoutMs ?? DEFAULT_AC_TIMEOUT_MS;
+    let mcpTokensPerSpawn = 0;
+    try {
+      const mcpConfig = await this.runtime.readFile(this.runtime.queueMcpEmptyPath);
+      mcpTokensPerSpawn = estimateMcpTokens(mcpConfig);
+    } catch {
+      mcpTokensPerSpawn = 0;
+    }
+    const taskOutcomes = [];
+    const done = [];
+    const failed = [];
+    let totalCostUsd = 0;
+    let halted = false;
+    let haltReason = null;
+    let haltCode = null;
+    let skipped = [];
+    const profile = this.runtime.mcpProfile;
+    let queueCacheReadTokens = 0;
+    let queueTotalInputTokens = 0;
+    let hasTokenData = false;
+    let queueFilesTouched = 0;
+    let queueNewFilesCreated = 0;
+    const profileOutcomes = {};
+    const bumpProfile = (outcome) => {
+      if (!profileOutcomes[profile]) profileOutcomes[profile] = { success: 0, failed: 0 };
+      profileOutcomes[profile][outcome] += 1;
+    };
+    try {
+      for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        if (opts.maxQueueCost !== void 0 && totalCostUsd + maxCostPerTask > opts.maxQueueCost) {
+          halted = true;
+          haltCode = "queue-cost-cap";
+          haltReason = `queue-cost-cap-exceeded: cumulative ${totalCostUsd.toFixed(
+            2
+          )} + per-task ${maxCostPerTask.toFixed(2)} > ${opts.maxQueueCost.toFixed(2)}`;
+          break;
+        }
+        const taskDir = path2.join(artifactDir, "tasks", task.id);
+        await this.runtime.mkdir(taskDir);
+        const promptText = task.body ?? "";
+        await this.runtime.writeFile(path2.join(taskDir, "prompt.md"), promptText);
+        const startResult = this.sessions.startSession({
+          projectId: ws.projectId,
+          workspaceId: ws.id,
+          taskId: task.id
+        });
+        const sessionId = startResult.session.id;
+        const taskModel = resolveModelForTask(task, model);
+        const spawnAttempt = await this.spawnWithRetry({
+          taskBody: promptText,
+          cwd: ws.cwd,
+          model: taskModel,
+          maxBudgetUsd,
+          queueMcpEmptyPath: this.runtime.queueMcpEmptyPath,
+          claudeBin
+        });
+        if (spawnAttempt.error) {
+          const reason = `spawn-error: ${spawnAttempt.error.message}`;
+          const errStats = await this.writeDiffArtifact(taskDir, ws.cwd);
+          queueFilesTouched += errStats.filesTouched;
+          queueNewFilesCreated += errStats.newFiles;
+          await this.failTask(task, sessionId, reason, taskDir);
+          bumpProfile("failed");
+          taskOutcomes.push({ id: task.id, outcome: "FAILED", reason });
+          failed.push(task);
+          halted = true;
+          haltCode = "spawn-error";
+          haltReason = reason;
+          break;
+        }
+        const spawn = spawnAttempt.output;
+        const cacheRead = spawn.cacheReadInputTokens ?? null;
+        const inputTokens = spawn.totalInputTokens ?? null;
+        if (cacheRead !== null) queueCacheReadTokens += cacheRead;
+        if (inputTokens !== null) {
+          queueTotalInputTokens += inputTokens;
+          hasTokenData = true;
+        }
+        await this.runtime.writeFile(path2.join(taskDir, "claude.json"), spawn.rawJson);
+        const diffStats = await this.writeDiffArtifact(taskDir, ws.cwd);
+        queueFilesTouched += diffStats.filesTouched;
+        queueNewFilesCreated += diffStats.newFiles;
+        totalCostUsd = round4(totalCostUsd + spawn.totalCostUsd);
+        if (spawn.isError) {
+          const reason = `claude-error: ${spawn.resultText.slice(0, 500)}`;
+          await this.failTask(task, sessionId, reason, taskDir);
+          bumpProfile("failed");
+          taskOutcomes.push({ id: task.id, outcome: "FAILED", costUsd: spawn.totalCostUsd, reason });
+          failed.push(task);
+          halted = true;
+          haltCode = "claude-error";
+          haltReason = reason;
+          break;
+        }
+        const acReason = await this.runAcCommands(promptText, ws.cwd, taskDir, acTimeoutMs);
+        if (acReason) {
+          await this.failTask(task, sessionId, acReason, taskDir);
+          bumpProfile("failed");
+          taskOutcomes.push({ id: task.id, outcome: "FAILED", costUsd: spawn.totalCostUsd, reason: acReason });
+          failed.push(task);
+          halted = true;
+          haltCode = "ac-failed";
+          haltReason = acReason;
+          break;
+        }
+        if (spawn.totalCostUsd > maxCostPerTask) {
+          const reason = `cost-cap-exceeded: ${spawn.totalCostUsd.toFixed(
+            2
+          )} > ${maxCostPerTask.toFixed(2)}`;
+          await this.failTask(task, sessionId, reason, taskDir);
+          bumpProfile("failed");
+          taskOutcomes.push({ id: task.id, outcome: "FAILED", costUsd: spawn.totalCostUsd, reason });
+          failed.push(task);
+          halted = true;
+          haltCode = "cost-cap";
+          haltReason = reason;
+          break;
+        }
+        this.sessions.endSession(sessionId, {
+          handoff: {
+            resumePoint: `auto-completed by queue runner (queue ${queueRunId})`,
+            decisions: [`Queue ${queueRunId} marked ${task.id} DONE \u2014 diff at ${taskDir}/diff.patch`]
+          }
+        });
+        bumpProfile("success");
+        taskOutcomes.push({ id: task.id, outcome: "DONE", costUsd: spawn.totalCostUsd, numTurns: spawn.numTurns });
+        done.push(task);
+      }
+    } finally {
+      skipped = tasks.slice(done.length + failed.length);
+      for (const t of skipped) {
+        taskOutcomes.push({ id: t.id, outcome: "SKIPPED" });
+      }
+      const cacheHitEstimate = hasTokenData ? Math.min(1, Math.max(0, queueCacheReadTokens / Math.max(queueTotalInputTokens, 1))) : null;
+      const runMeta = {
+        queueRunId,
+        workspaceId: opts.workspaceId,
+        branch,
+        commitSha,
+        model,
+        claudeBin,
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        maxCostPerTask,
+        maxQueueCost: opts.maxQueueCost ?? null,
+        maxTasks: opts.maxTasks ?? null,
+        totalCostUsd,
+        halted,
+        haltReason,
+        haltCode,
+        mcp_tokens_per_spawn: mcpTokensPerSpawn,
+        tool_schema_tokens_total: computeToolSchemaTokens(),
+        mcp_profile_used: profile,
+        cache_read_input_tokens: queueCacheReadTokens,
+        cache_hit_estimate: cacheHitEstimate,
+        spawn_mode: profile === "empty" ? "zero-mcp" : "selective",
+        task_outcome_per_mcp_profile: profileOutcomes,
+        files_touched_count: queueFilesTouched,
+        new_files_created_count: queueNewFilesCreated,
+        tasks: taskOutcomes
+      };
+      await this.runtime.writeFile(path2.join(artifactDir, "queue-run.json"), JSON.stringify(runMeta, null, 2));
+    }
+    return {
+      done,
+      failed,
+      skipped,
+      totalCostUsd,
+      halted,
+      haltReason,
+      haltCode,
+      queueRunId,
+      artifactDir
+    };
+  }
+  /**
+   * `choda-deck queue start` orchestration per ADR-019 Phase 3 / TASK-728.
+   *
+   * Differs from `runQueue` on three axes:
+   *  - Pre-flight halt-all (`validateQueueStartPreflight`) before any spawn — global error
+   *    aborts the whole batch; per-task failure aborts unless `forceContinue` is set.
+   *  - Each task spawns in its own `git worktree add -b auto/<taskId> <baseSha>` cwd so
+   *    diffs and branches don't collide. Worktrees are left intact regardless of outcome —
+   *    cleanup is the orphan-cleaner's job (TASK-687).
+   *  - Mid-run policy is CONTINUE: a failure writes artifacts + marks AUTO_FAILED + moves
+   *    on. There is no `haltCode`; the runner only stops at end-of-list.
+   */
+  async runQueueStart(opts) {
+    const ws = this.workspaces.get(opts.workspaceId);
+    if (!ws) {
+      throw new WorkspaceResolutionError(`workspace ${opts.workspaceId} not found`);
+    }
+    const branchPrefix = opts.branchPrefix ?? "auto/";
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const eligible = this.collectEligibleTasks(ws);
+    const taskCap = opts.maxTasks ?? eligible.length;
+    const allTasks = eligible.slice(0, taskCap);
+    const queueRunId = `${Date.now()}-${Math.floor(Math.random() * 1e6).toString(36)}`;
+    const artifactDir = path2.join(this.runtime.artifactsDir, `queue-start-${queueRunId}`);
+    const preflight = await validateQueueStartPreflight({
+      tasks: allTasks,
+      repoCwd: ws.cwd,
+      baseRef: opts.baseRef,
+      worktreesParentDir: opts.worktreesParentDir,
+      branchPrefix,
+      fns: this.runtime
+    });
+    if (opts.dryRun) {
+      return this.emptyQueueStartResult({
+        workspaceId: opts.workspaceId,
+        queueRunId,
+        artifactDir,
+        baseRef: opts.baseRef,
+        baseSha: preflight.baseSha,
+        preflightAborted: !preflight.ok && !opts.forceContinue,
+        preflightAbortReason: preflightAbortMessage(preflight),
+        taskOutcomes: allTasks.map((t) => ({
+          taskId: t.id,
+          worktreePath: null,
+          branch: null,
+          headSha: null,
+          outcome: "SKIPPED_PREFLIGHT"
+        }))
+      });
+    }
+    if (preflight.globalErrors.length > 0 || !preflight.ok && !opts.forceContinue) {
+      await this.runtime.mkdir(artifactDir);
+      const taskOutcomes2 = allTasks.map((task) => {
+        const fail = preflight.failures.find((f) => f.taskId === task.id);
+        return {
+          taskId: task.id,
+          worktreePath: null,
+          branch: null,
+          headSha: null,
+          outcome: "SKIPPED_PREFLIGHT",
+          reason: fail ? `preflight: ${fail.reasons.join("; ")}` : "preflight: aborted by global error"
+        };
+      });
+      await this.writeQueueStartMeta(artifactDir, {
+        queueRunId,
+        workspaceId: opts.workspaceId,
+        baseRef: opts.baseRef,
+        baseSha: preflight.baseSha,
+        midRunPolicy: "continue",
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        model: opts.model ?? DEFAULT_MODEL,
+        claudeBin: opts.claudeBin ?? "claude",
+        totalCostUsd: 0,
+        preflightAborted: true,
+        preflightAbortReason: preflightAbortMessage(preflight),
+        taskOutcomes: taskOutcomes2
+      });
+      return {
+        workspaceId: opts.workspaceId,
+        queueRunId,
+        artifactDir,
+        baseRef: opts.baseRef,
+        baseSha: preflight.baseSha,
+        taskOutcomes: taskOutcomes2,
+        totalCostUsd: 0,
+        preflightAborted: true,
+        preflightAbortReason: preflightAbortMessage(preflight),
+        doneCount: 0,
+        failedCount: 0,
+        preflightSkippedCount: taskOutcomes2.length
+      };
+    }
+    const baseSha = preflight.baseSha;
+    await this.runtime.mkdir(artifactDir);
+    const failedTaskIds = new Set(preflight.failures.map((f) => f.taskId));
+    const maxCostPerTask = opts.maxCostPerTask ?? DEFAULT_MAX_COST_PER_TASK;
+    const maxBudgetUsd = round2(maxCostPerTask * 0.95);
+    const model = opts.model ?? DEFAULT_MODEL;
+    const claudeBin = opts.claudeBin ?? "claude";
+    const acTimeoutMs = opts.acTimeoutMs ?? DEFAULT_AC_TIMEOUT_MS;
+    const taskOutcomes = [];
+    let totalCostUsd = 0;
+    for (const task of allTasks) {
+      if (failedTaskIds.has(task.id)) {
+        const fail = preflight.failures.find((f) => f.taskId === task.id);
+        taskOutcomes.push({
+          taskId: task.id,
+          worktreePath: null,
+          branch: null,
+          headSha: null,
+          outcome: "SKIPPED_PREFLIGHT",
+          reason: `preflight: ${fail.reasons.join("; ")}`
+        });
+        continue;
+      }
+      const worktreePath = path2.join(opts.worktreesParentDir, task.id);
+      const branch = `${branchPrefix}${task.id}`;
+      const taskDir = path2.join(artifactDir, "tasks", task.id);
+      await this.runtime.mkdir(taskDir);
+      const promptText = task.body ?? "";
+      await this.runtime.writeFile(path2.join(taskDir, "prompt.md"), promptText);
+      try {
+        await this.runtime.gitWorktreeAdd({
+          repoCwd: ws.cwd,
+          worktreePath,
+          branch,
+          baseSha
+        });
+      } catch (err) {
+        const reason = `worktree-add-failed: ${err instanceof Error ? err.message : String(err)}`;
+        const startResult2 = this.sessions.startSession({
+          projectId: ws.projectId,
+          workspaceId: ws.id,
+          taskId: task.id
+        });
+        await this.failTask(task, startResult2.session.id, reason, taskDir);
+        taskOutcomes.push({
+          taskId: task.id,
+          worktreePath,
+          branch,
+          headSha: null,
+          outcome: "FAILED",
+          reason
+        });
+        continue;
+      }
+      const startResult = this.sessions.startSession({
+        projectId: ws.projectId,
+        workspaceId: ws.id,
+        taskId: task.id
+      });
+      const sessionId = startResult.session.id;
+      const taskModel = resolveModelForTask(task, model);
+      const spawnAttempt = await this.spawnWithRetry({
+        taskBody: promptText,
+        cwd: worktreePath,
+        model: taskModel,
+        maxBudgetUsd,
+        queueMcpEmptyPath: this.runtime.queueMcpEmptyPath,
+        claudeBin
+      });
+      if (spawnAttempt.error) {
+        const reason = `spawn-error: ${spawnAttempt.error.message}`;
+        await this.writeDiffArtifact(taskDir, worktreePath);
+        await this.failTask(task, sessionId, reason, taskDir);
+        const headSha2 = await this.safeHeadSha(worktreePath);
+        taskOutcomes.push({
+          taskId: task.id,
+          worktreePath,
+          branch,
+          headSha: headSha2,
+          outcome: "FAILED",
+          reason
+        });
+        continue;
+      }
+      const spawn = spawnAttempt.output;
+      await this.runtime.writeFile(path2.join(taskDir, "claude.json"), spawn.rawJson);
+      await this.writeDiffArtifact(taskDir, worktreePath);
+      totalCostUsd = round4(totalCostUsd + spawn.totalCostUsd);
+      if (spawn.isError) {
+        const reason = `claude-error: ${spawn.resultText.slice(0, 500)}`;
+        await this.failTask(task, sessionId, reason, taskDir);
+        const headSha2 = await this.safeHeadSha(worktreePath);
+        taskOutcomes.push({
+          taskId: task.id,
+          worktreePath,
+          branch,
+          headSha: headSha2,
+          outcome: "FAILED",
+          costUsd: spawn.totalCostUsd,
+          reason
+        });
+        continue;
+      }
+      const acReason = await this.runAcCommands(promptText, worktreePath, taskDir, acTimeoutMs);
+      if (acReason) {
+        await this.failTask(task, sessionId, acReason, taskDir);
+        const headSha2 = await this.safeHeadSha(worktreePath);
+        taskOutcomes.push({
+          taskId: task.id,
+          worktreePath,
+          branch,
+          headSha: headSha2,
+          outcome: "FAILED",
+          costUsd: spawn.totalCostUsd,
+          reason: acReason
+        });
+        continue;
+      }
+      if (spawn.totalCostUsd > maxCostPerTask) {
+        const reason = `cost-cap-exceeded: ${spawn.totalCostUsd.toFixed(
+          2
+        )} > ${maxCostPerTask.toFixed(2)}`;
+        await this.failTask(task, sessionId, reason, taskDir);
+        const headSha2 = await this.safeHeadSha(worktreePath);
+        taskOutcomes.push({
+          taskId: task.id,
+          worktreePath,
+          branch,
+          headSha: headSha2,
+          outcome: "FAILED",
+          costUsd: spawn.totalCostUsd,
+          reason
+        });
+        continue;
+      }
+      this.sessions.endSession(sessionId, {
+        handoff: {
+          resumePoint: `auto-completed by queue start (run ${queueRunId})`,
+          decisions: [
+            `Queue start ${queueRunId} marked ${task.id} DONE \u2014 worktree ${worktreePath}, branch ${branch}`
+          ]
+        }
+      });
+      const headSha = await this.safeHeadSha(worktreePath);
+      taskOutcomes.push({
+        taskId: task.id,
+        worktreePath,
+        branch,
+        headSha,
+        outcome: "DONE",
+        costUsd: spawn.totalCostUsd,
+        numTurns: spawn.numTurns
+      });
+    }
+    const doneCount = taskOutcomes.filter((o) => o.outcome === "DONE").length;
+    const failedCount = taskOutcomes.filter((o) => o.outcome === "FAILED").length;
+    const preflightSkippedCount = taskOutcomes.filter((o) => o.outcome === "SKIPPED_PREFLIGHT").length;
+    await this.writeQueueStartMeta(artifactDir, {
+      queueRunId,
+      workspaceId: opts.workspaceId,
+      baseRef: opts.baseRef,
+      baseSha,
+      midRunPolicy: "continue",
+      startedAt,
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      model,
+      claudeBin,
+      totalCostUsd,
+      preflightAborted: false,
+      preflightAbortReason: null,
+      taskOutcomes
+    });
+    return {
+      workspaceId: opts.workspaceId,
+      queueRunId,
+      artifactDir,
+      baseRef: opts.baseRef,
+      baseSha,
+      taskOutcomes,
+      totalCostUsd,
+      preflightAborted: false,
+      preflightAbortReason: null,
+      doneCount,
+      failedCount,
+      preflightSkippedCount
+    };
+  }
+  /**
+   * `gitHeadSha` may throw if the worktree disappeared between spawn and query; swallow
+   * that into a `null` outcome rather than failing the whole loop.
+   */
+  async safeHeadSha(cwd) {
+    try {
+      return await this.runtime.gitHeadSha(cwd);
+    } catch {
+      return null;
+    }
+  }
+  async writeQueueStartMeta(artifactDir, meta3) {
+    await this.runtime.writeFile(
+      path2.join(artifactDir, "queue-run.json"),
+      JSON.stringify(meta3, null, 2)
+    );
+  }
+  emptyQueueStartResult(seed) {
+    return {
+      ...seed,
+      totalCostUsd: 0,
+      doneCount: 0,
+      failedCount: 0,
+      preflightSkippedCount: seed.taskOutcomes.length
+    };
+  }
+  /**
+   * Spawn with at most one retry for transient errors. The same prompt is sent on retry —
+   * Claude is stateless across `-p` invocations so this is safe. Final attempt's output
+   * (success or last failure) is what flows into per-task artifact writing and post-hoc
+   * cost accounting; no double-counting because we only act on the final result.
+   */
+  async spawnWithRetry(input) {
+    let lastOutput = null;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const output = await this.runtime.spawnClaude(input);
+        lastOutput = output;
+        if (output.isError && attempt === 0 && isTransientMessage(output.resultText)) {
+          continue;
+        }
+        return { output, error: null };
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        if (attempt === 0 && isTransientMessage(e.message)) continue;
+        return { output: null, error: e };
+      }
+    }
+    if (lastOutput) return { output: lastOutput, error: null };
+    return { output: null, error: new Error("spawn retry loop produced no result") };
+  }
+  collectEligibleTasks(ws) {
+    const candidates = this.tasks.find({ projectId: ws.projectId, status: "READY" });
+    return candidates.filter(
+      (t) => t.labels.includes(AUTO_SAFE_LABEL) && !t.labels.includes(AUTO_FAILED_LABEL) && validateAutoSafeTask(t).valid
+    ).sort((x, y) => x.id.localeCompare(y.id));
+  }
+  async runAcCommands(body, cwd, taskDir, timeoutMs) {
+    const cmds = parseAcCommands(body);
+    for (let i = 0; i < cmds.length; i++) {
+      const cmd = cmds[i];
+      const r = await this.runtime.execShell(cmd, { cwd, timeoutMs });
+      const log = `$ ${cmd}
+exit ${r.exitCode}
+--- stdout ---
+${r.stdout}
+--- stderr ---
+${r.stderr}
+`;
+      await this.runtime.writeFile(path2.join(taskDir, `ac-${i}.log`), log);
+      if (r.exitCode !== 0) {
+        return `ac-failed: \`${cmd}\` exit ${r.exitCode}`;
+      }
+    }
+    return null;
+  }
+  async writeDiffArtifact(taskDir, cwd) {
+    const diff = await this.runtime.gitDiff(cwd);
+    await this.runtime.writeFile(path2.join(taskDir, "diff.patch"), diff);
+    const stats = parseDiffStats(diff);
+    const untracked = await this.runtime.gitUntrackedFiles(cwd);
+    return { filesTouched: stats.filesTouched, newFiles: stats.newFiles + untracked.length };
+  }
+  async failTask(task, sessionId, reason, taskDir) {
+    const refreshed = this.tasks.get(task.id);
+    if (!refreshed) throw new TaskNotFoundError(task.id);
+    const nextLabels = refreshed.labels.includes(AUTO_FAILED_LABEL) ? refreshed.labels : [...refreshed.labels, AUTO_FAILED_LABEL];
+    this.tasks.update(task.id, { labels: nextLabels, status: "READY" });
+    const linkedConvs = this.conversations.findByLink("task", task.id);
+    for (const conv of linkedConvs) {
+      if (conv.status === "closed") continue;
+      this.conversations.addMessage({
+        conversationId: conv.id,
+        authorName: "queue-runner",
+        content: `Auto-failed: ${reason}
+Diff: ${path2.join(taskDir, "diff.patch")}`,
+        messageType: "comment"
+      });
+    }
+    this.sessions.abandonSession(sessionId, reason);
+  }
+};
+function resolveModelForTask(task, defaultModel) {
+  for (const label of task.labels) {
+    const m = label.match(/^model:(.+)$/);
+    if (m) {
+      const value = m[1];
+      if (!value.startsWith("claude-")) {
+        process.stderr.write(`[queue] warning: model label "${label}" value does not start with "claude-"
+`);
+      }
+      return value;
+    }
+  }
+  return defaultModel;
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function round4(n) {
+  return Math.round(n * 1e4) / 1e4;
+}
+function preflightAbortMessage(preflight) {
+  if (preflight.ok) return null;
+  const parts = [];
+  if (preflight.globalErrors.length > 0) {
+    parts.push(`global: ${preflight.globalErrors.join("; ")}`);
+  }
+  if (preflight.failures.length > 0) {
+    parts.push(
+      `tasks: ${preflight.failures.map((f) => `${f.taskId} (${f.reasons.join(", ")})`).join("; ")}`
+    );
+  }
+  return parts.join(" | ");
+}
+function parseDiffStats(diff) {
+  let totalFiles = 0;
+  let newFiles = 0;
+  for (const line of splitLines(diff)) {
+    if (line.startsWith("diff --git ")) totalFiles += 1;
+    else if (line.startsWith("new file mode")) newFiles += 1;
+  }
+  return { filesTouched: totalFiles - newFiles, newFiles };
+}
+
 // src/core/domain/knowledge-service.ts
 var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 
 // src/core/domain/knowledge-git.ts
 var import_child_process = require("child_process");
@@ -31012,6 +31971,15 @@ function quoteIfNeeded(s) {
   return s;
 }
 
+// src/core/worktree-path.ts
+var path3 = __toESM(require("path"));
+var WORKTREE_SEGMENT_RE = /\.worktrees([\\/]|$)/i;
+function isLikelyWorktreePath(absPath) {
+  if (!absPath) return false;
+  const normalized = path3.normalize(absPath);
+  return WORKTREE_SEGMENT_RE.test(normalized);
+}
+
 // src/core/domain/knowledge-service.ts
 var KnowledgeNotFoundError = class extends Error {
   constructor(slug) {
@@ -31064,6 +32032,11 @@ var KnowledgeService = class {
     }
     const stalenessCwd = workspaceCwd ?? project.cwd;
     const filePath = this.resolveFilePath(input.scope, project.cwd, slug, workspaceCwd);
+    if (isLikelyWorktreePath(filePath)) {
+      throw new KnowledgeValidationError(
+        `target path is inside a git worktree (${filePath}) \u2014 knowledge there would be orphaned when the worktree is removed. Create knowledge from the main checkout instead.`
+      );
+    }
     if (fs.existsSync(filePath)) {
       throw new KnowledgeConflictError(slug, `file already exists at ${filePath}`);
     }
@@ -31080,7 +32053,7 @@ var KnowledgeService = class {
       lastVerifiedAt: isoDate
     };
     const content = serializeFrontmatter(frontmatter, input.body);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.mkdirSync(path4.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, content, "utf8");
     const indexRow = {
       slug,
@@ -31131,7 +32104,7 @@ var KnowledgeService = class {
         `frontmatter workspaceId (${frontmatter.workspaceId ?? "null"}) does not match input (${input.workspaceId ?? "null"})`
       );
     }
-    const slug = path.basename(input.filePath, ".md");
+    const slug = path4.basename(input.filePath, ".md");
     if (!slug) throw new KnowledgeValidationError(`cannot derive slug from path: ${input.filePath}`);
     const indexRow = {
       slug,
@@ -31329,9 +32302,9 @@ var KnowledgeService = class {
   resolveFilePath(scope, projectCwd, slug, workspaceCwd) {
     if (scope === "project") {
       const cwd = workspaceCwd ?? projectCwd;
-      return path.join(cwd, "docs", "knowledge", `${slug}.md`);
+      return path4.join(cwd, "docs", "knowledge", `${slug}.md`);
     }
-    return path.join(this.contentRoot, "30-Knowledge", `${slug}.md`);
+    return path4.join(this.contentRoot, "30-Knowledge", `${slug}.md`);
   }
   materializeRefs(inputRefs, projectCwd, scope) {
     if (inputRefs.length === 0) return [];
@@ -31363,11 +32336,12 @@ var KnowledgeService = class {
     this.writeIndexMd(projectCwd, `Knowledge \u2014 ${projectId}`, rows);
   }
   regenerateWorkspaceIndexMd(projectId, workspaceId, workspaceCwd) {
+    if (!fs.existsSync(workspaceCwd)) return;
     const rows = this.knowledge.list({ projectId, workspaceId, scope: "project" });
     this.writeIndexMd(workspaceCwd, `Knowledge \u2014 ${projectId}/${workspaceId}`, rows);
   }
   writeIndexMd(cwd, heading, rows) {
-    const indexPath = path.join(cwd, "docs", "knowledge", "INDEX.md");
+    const indexPath = path4.join(cwd, "docs", "knowledge", "INDEX.md");
     const lines = ["# " + heading, ""];
     if (rows.length === 0) {
       lines.push("_No entries yet._");
@@ -31382,7 +32356,7 @@ var KnowledgeService = class {
       }
     }
     lines.push("");
-    fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+    fs.mkdirSync(path4.dirname(indexPath), { recursive: true });
     fs.writeFileSync(indexPath, lines.join("\n") + "\n", "utf8");
   }
   isEntryStale(row, projectCwd) {
@@ -31908,6 +32882,16 @@ function createM1Tables(db) {
     db.exec("ALTER TABLE knowledge_index ADD COLUMN workspace_id TEXT REFERENCES workspaces(id)");
   } catch {
   }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tool_invocations (
+      id INTEGER PRIMARY KEY,
+      tool_name TEXT NOT NULL,
+      ts TEXT NOT NULL,
+      duration_ms INTEGER NOT NULL,
+      ok INTEGER NOT NULL,
+      error_kind TEXT
+    )
+  `);
 }
 function createIndexes(db) {
   db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id)");
@@ -31940,6 +32924,9 @@ function createIndexes(db) {
   db.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_type ON knowledge_index(project_id, type)");
   db.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_scope ON knowledge_index(project_id, scope)");
   db.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_workspace ON knowledge_index(workspace_id)");
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_tool_invocations_tool_ts ON tool_invocations(tool_name, ts)"
+  );
 }
 function cleanupPoisonedTaskIds(db) {
   const rows = db.prepare("SELECT id FROM tasks WHERE id GLOB 'TASK-[0-9]*'").all();
@@ -32620,43 +33607,43 @@ var ContextSourceRepository = class {
 
 // src/core/domain/services/event-emitter.ts
 var fs2 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 
 // src/core/paths.ts
 var os = __toESM(require("os"));
-var path2 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 function resolveDataPaths(electronDataDir) {
   const legacyDbPath = process.env.CHODA_DB_PATH;
   const envDataDir = process.env.CHODA_DATA_DIR;
-  let dataDir2;
-  let dbPath2;
+  let dataDir;
+  let dbPath;
   if (legacyDbPath) {
     if (envDataDir) {
       console.warn("[paths] Both CHODA_DB_PATH and CHODA_DATA_DIR set \u2014 CHODA_DB_PATH wins for dbPath");
     }
-    dbPath2 = path2.resolve(legacyDbPath);
-    dataDir2 = electronDataDir ?? envDataDir ?? path2.dirname(dbPath2);
+    dbPath = path5.resolve(legacyDbPath);
+    dataDir = electronDataDir ?? envDataDir ?? path5.dirname(dbPath);
   } else if (envDataDir) {
-    dataDir2 = path2.resolve(envDataDir);
-    dbPath2 = path2.join(dataDir2, "database", "choda-deck.db");
+    dataDir = path5.resolve(envDataDir);
+    dbPath = path5.join(dataDir, "database", "choda-deck.db");
   } else if (electronDataDir) {
-    dataDir2 = electronDataDir;
-    dbPath2 = path2.join(dataDir2, "database", "choda-deck.db");
+    dataDir = electronDataDir;
+    dbPath = path5.join(dataDir, "database", "choda-deck.db");
   } else {
-    dataDir2 = path2.join(process.cwd(), "data");
-    dbPath2 = path2.join(dataDir2, "database", "choda-deck.db");
+    dataDir = path5.join(process.cwd(), "data");
+    dbPath = path5.join(dataDir, "database", "choda-deck.db");
   }
   return {
-    dataDir: dataDir2,
-    dbPath: dbPath2,
-    artifactsDir: path2.join(dataDir2, "artifacts"),
-    backupsDir: path2.join(dataDir2, "backups")
+    dataDir,
+    dbPath,
+    artifactsDir: path5.join(dataDir, "artifacts"),
+    backupsDir: path5.join(dataDir, "backups")
   };
 }
 function resolveEventDir() {
   const envDir = process.env.CHODA_EVENT_DIR;
-  if (envDir) return path2.resolve(envDir);
-  return path2.join(os.tmpdir(), "choda-events");
+  if (envDir) return path5.resolve(envDir);
+  return path5.join(os.tmpdir(), "choda-events");
 }
 
 // src/core/domain/services/event-emitter.ts
@@ -32668,7 +33655,7 @@ function emitConversationEvent(projectId, event) {
   try {
     const dir = resolveEventDir();
     fs2.mkdirSync(dir, { recursive: true });
-    const file2 = path3.join(dir, `${projectId}.jsonl`);
+    const file2 = path6.join(dir, `${projectId}.jsonl`);
     const normalized = {
       ...event,
       timestamp: normalizeEventTimestamp(event.timestamp)
@@ -32678,6 +33665,15 @@ function emitConversationEvent(projectId, event) {
     console.warn("[conversation-event-emitter] emit failed:", err);
   }
 }
+function emitConversationEventFanout(ownerProjectId, targetProjectIds, event) {
+  emitConversationEvent(ownerProjectId, event);
+  const seen = /* @__PURE__ */ new Set([ownerProjectId]);
+  for (const target of targetProjectIds) {
+    if (seen.has(target)) continue;
+    seen.add(target);
+    emitConversationEvent(target, event);
+  }
+}
 
 // src/core/domain/repositories/conversation-repository.ts
 function rowToConversation(row) {
@@ -32868,7 +33864,8 @@ var ConversationRepository = class {
       if (allRoles.length === 0) return;
       roles = allRoles;
     }
-    emitConversationEvent(conv.projectId, {
+    const targetProjectIds = this.resolveFanoutTargets(roles, conv.projectId);
+    emitConversationEventFanout(conv.projectId, targetProjectIds, {
       type,
       conversationId,
       roles,
@@ -32877,6 +33874,32 @@ var ConversationRepository = class {
       timestamp
     });
   }
+  // ADR-021 Phase 3: parse "<projectId>/<workspaceId>" address strings from
+  // roles[] and return the unique, validated set of fan-out target projectIds
+  // (owner excluded). Unknown projectIds are logged and skipped — never throw.
+  resolveFanoutTargets(roles, ownerProjectId) {
+    const candidates = /* @__PURE__ */ new Set();
+    for (const role of roles) {
+      const slash = role.indexOf("/");
+      if (slash <= 0) continue;
+      const projectId = role.slice(0, slash);
+      if (projectId === ownerProjectId) continue;
+      candidates.add(projectId);
+    }
+    if (candidates.size === 0) return [];
+    const targets = [];
+    for (const projectId of candidates) {
+      const exists = this.db.prepare("SELECT 1 FROM projects WHERE id = ?").get(projectId);
+      if (exists) {
+        targets.push(projectId);
+      } else {
+        console.warn(
+          `[conversation-event-emitter] unknown target projectId in role address: ${projectId}`
+        );
+      }
+    }
+    return targets;
+  }
   getMessages(conversationId) {
     const rows = this.db.prepare(
       "SELECT * FROM conversation_messages WHERE conversation_id = ? ORDER BY created_at, id"
@@ -33053,6 +34076,52 @@ var CounterRepository = class {
   }
 };
 
+// src/core/domain/repositories/tool-invocations-repository.ts
+var ToolInvocationsRepository = class {
+  insertStmt;
+  countStmt;
+  queryStmt;
+  constructor(db) {
+    this.insertStmt = db.prepare(
+      `INSERT INTO tool_invocations (tool_name, ts, duration_ms, ok, error_kind)
+       VALUES (?, ?, ?, ?, ?)`
+    );
+    this.countStmt = db.prepare("SELECT COUNT(*) AS n FROM tool_invocations");
+    this.queryStmt = db.prepare(
+      `SELECT
+         tool_name AS tool,
+         COUNT(*) AS calls,
+         SUM(1 - ok) AS errors,
+         AVG(duration_ms) AS avgDurationMs,
+         MAX(ts) AS lastUsedAt
+       FROM tool_invocations
+       WHERE (@since IS NULL OR ts >= @since)
+         AND (@until IS NULL OR ts <= @until)
+       GROUP BY tool_name`
+    );
+  }
+  recordToolInvocation(invocation) {
+    this.insertStmt.run(
+      invocation.toolName,
+      invocation.ts,
+      invocation.durationMs,
+      invocation.ok ? 1 : 0,
+      invocation.errorKind
+    );
+  }
+  countToolInvocations() {
+    const row = this.countStmt.get();
+    return row.n;
+  }
+  queryToolInvocations(window) {
+    const rows = this.queryStmt.all({
+      since: window.since,
+      until: window.until
+    });
+    return rows;
+  }
+};
+
 // src/core/domain/sqlite-task-service.ts
 var SqliteTaskService = class {
   db;
@@ -33067,6 +34136,7 @@ var SqliteTaskService = class {
   conversations;
   inbox;
   counters;
+  toolInvocations;
   inboxLifecycle;
   conversationLifecycle;
   sessionLifecycle;
@@ -33075,8 +34145,8 @@ var SqliteTaskService = class {
   embeddingStore;
   embeddingProviderPromise;
   embeddingReadyPromise = null;
-  constructor(dbPath2) {
-    this.db = new import_better_sqlite3.default(dbPath2);
+  constructor(dbPath) {
+    this.db = new import_better_sqlite3.default(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
     const vecLoaded = loadVecExtension(this.db);
@@ -33090,6 +34160,7 @@ var SqliteTaskService = class {
     this.workspaces = new WorkspaceRepository(this.db);
     this.relationships = new RelationshipRepository(this.db);
     this.counters = new CounterRepository(this.db);
+    this.toolInvocations = new ToolInvocationsRepository(this.db);
     this.tasks = new TaskRepository(this.db, this.relationships, this.counters);
     this.documents = new DocumentRepository(this.db);
     this.tagsRepo = new TagRepository(this.db);
@@ -33154,6 +34225,16 @@ var SqliteTaskService = class {
     const escaped = absolutePath.replace(/'/g, "''");
     this.db.exec(`VACUUM INTO '${escaped}'`);
   }
+  // ── Tool invocations (TASK-681) ────────────────────────────────────────────
+  recordToolInvocation(invocation) {
+    this.toolInvocations.recordToolInvocation(invocation);
+  }
+  countToolInvocations() {
+    return this.toolInvocations.countToolInvocations();
+  }
+  queryToolInvocations(window) {
+    return this.toolInvocations.queryToolInvocations(window);
+  }
   ensureProject(id, name, cwd) {
     this.projects.ensure(id, name, cwd);
   }
@@ -33178,12 +34259,6 @@ var SqliteTaskService = class {
   unarchiveWorkspace(id) {
     return this.workspaces.unarchive(id);
   }
-  deleteWorkspace(id) {
-    this.workspaces.delete(id);
-  }
-  countWorkspaceReferences(id) {
-    return this.workspaces.countReferences(id);
-  }
   // ── Task operations ────────────────────────────────────────────────────────
   createTask(input) {
     return this.tasks.create(input);
@@ -33393,12 +34468,25 @@ var SqliteTaskService = class {
   endSession(id, input) {
     return this.sessionLifecycle.endSession(id, input);
   }
+  abandonSession(id, reason) {
+    return this.sessionLifecycle.abandonSession(id, reason);
+  }
   checkpointSession(id, input) {
     return this.sessionLifecycle.checkpointSession(id, input);
   }
   resumeSession(id) {
     return this.sessionLifecycle.resumeSession(id);
   }
+  // ── Queue lifecycle (autonomous queue runner per ADR-019) ─────────────────
+  createQueueLifecycle(runtime) {
+    return new QueueLifecycleService(
+      this.tasks,
+      this.workspaces,
+      this.conversations,
+      this.sessionLifecycle,
+      runtime
+    );
+  }
   // ── Knowledge ─────────────────────────────────────────────────────────────
   createKnowledge(input) {
     return this.knowledgeService.createKnowledge(input);
@@ -33438,6 +34526,45 @@ function loadVecExtension(db) {
   }
 }
 
+// src/adapters/mcp/instrumented-server.ts
+function createInstrumentedServer(server, sink) {
+  const names = [];
+  const registerTool = ((name, config2, cb) => {
+    names.push(name);
+    const wrappedCb = async (...callArgs) => {
+      const start = Date.now();
+      let ok = true;
+      let errorKind = null;
+      try {
+        return await cb(...callArgs);
+      } catch (e) {
+        ok = false;
+        errorKind = e?.name ?? "Error";
+        throw e;
+      } finally {
+        try {
+          sink.recordToolInvocation({
+            toolName: name,
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            durationMs: Date.now() - start,
+            ok,
+            errorKind
+          });
+        } catch (logErr) {
+          console.warn("[choda-deck] tool invocation insert failed", logErr);
+        }
+      }
+    };
+    return server.registerTool(name, config2, wrappedCb);
+  });
+  return {
+    registerTool,
+    get registeredToolNames() {
+      return names;
+    }
+  };
+}
+
 // src/adapters/mcp/mcp-tools/types.ts
 function textResponse(payload) {
   const text = typeof payload === "string" ? payload : JSON.stringify(payload, null, 2);
@@ -33446,7 +34573,7 @@ function textResponse(payload) {
 
 // src/adapters/mcp/mcp-tools/task-context-graphify.ts
 var fs3 = __toESM(require("node:fs"));
-var path4 = __toESM(require("node:path"));
+var path7 = __toESM(require("node:path"));
 var STALE_DAYS = 7;
 var BFS_DEPTH = 2;
 var MAX_AFFECTED_FILES = 15;
@@ -33487,7 +34614,33 @@ var KEYWORD_STOPWORDS = /* @__PURE__ */ new Set([
   "feature",
   "work",
   "change",
-  "changes"
+  "changes",
+  "trong",
+  "kh\xF4ng",
+  "tr\xEAn",
+  "d\u01B0\u1EDBi",
+  "ch\u1EE9a",
+  "\u0111\xFAng",
+  "ng\u01B0\u1EE3c",
+  "ph\u1EA3i",
+  "c\u1EA7n",
+  "n\u1EBFu",
+  "khi",
+  "nh\u01B0",
+  "theo",
+  "sau",
+  "tr\u01B0\u1EDBc"
+]);
+var LABEL_KEY_PREFIX = /^(assignee|adr|phase)[:-]/i;
+var LABEL_EXACT_DROP = /* @__PURE__ */ new Set([
+  "auto-safe",
+  "bug",
+  "feat",
+  "fix",
+  "test",
+  "metrics",
+  "chore",
+  "docs"
 ]);
 function buildGraphifyContext(task, svc) {
   const graphPath = findGraphPath(task.projectId, svc);
@@ -33498,20 +34651,21 @@ function buildGraphifyContext(task, svc) {
     };
   }
   const keywords = extractKeywords(task);
-  if (keywords.length === 0) {
+  const filePointerPaths = extractFilePointers(task.body ?? "");
+  if (keywords.length === 0 && filePointerPaths.length === 0) {
     return {
       status: "no-matches",
-      message: "Task title/AC/labels produced no usable keywords."
+      message: "Task title/AC/labels/file-pointers produced no usable signal."
     };
   }
   const data = JSON.parse(fs3.readFileSync(graphPath, "utf8"));
   const nodeIndex = new Map(data.nodes.map((n) => [n.id, n]));
   const adj = buildAdjacency(data.links);
-  const startNodes = findStartNodes(data.nodes, keywords, 3);
+  const startNodes = findStartNodes(data.nodes, keywords, filePointerPaths, 3);
   if (startNodes.length === 0) {
     return {
       status: "no-matches",
-      message: `No graph nodes matched keywords: ${keywords.join(", ")}`
+      message: filePointerPaths.length > 0 ? `File pointers not in graph: ${filePointerPaths.join(", ")}; keywords: ${keywords.join(", ")}` : `No graph nodes matched keywords: ${keywords.join(", ")}`
     };
   }
   const subgraph = bfs(
@@ -33542,12 +34696,12 @@ function buildGraphifyContext(task, svc) {
 function findGraphPath(projectId, svc) {
   const workspaces = svc.findWorkspaces(projectId);
   for (const ws of workspaces) {
-    const p = path4.join(ws.cwd, "graphify-out", "graph.json");
+    const p = path7.join(ws.cwd, "graphify-out", "graph.json");
     if (fs3.existsSync(p)) return p;
   }
   const project = svc.getProject(projectId);
   if (project) {
-    const p = path4.join(project.cwd, "graphify-out", "graph.json");
+    const p = path7.join(project.cwd, "graphify-out", "graph.json");
     if (fs3.existsSync(p)) return p;
   }
   return null;
@@ -33555,7 +34709,7 @@ function findGraphPath(projectId, svc) {
 function extractKeywords(task) {
   const acSection = extractAcceptanceSection(task.body ?? "");
   const raw = `${task.title} ${acSection}`.split(/\s+/);
-  const fromLabels = (task.labels ?? []).map((l) => l.toLowerCase());
+  const fromLabels = (task.labels ?? []).map((l) => l.toLowerCase()).filter((l) => !LABEL_KEY_PREFIX.test(l) && !LABEL_EXACT_DROP.has(l));
   const all = [...raw.map((t) => t.toLowerCase()), ...fromLabels];
   const deduped = /* @__PURE__ */ new Set();
   for (const t of all) {
@@ -33566,15 +34720,51 @@ function extractKeywords(task) {
   }
   return Array.from(deduped);
 }
+function extractFilePointers(body) {
+  const match = body.match(/(?:^|\n)##\s*File Pointers\s*\n[\s\S]*?(?=\n##\s|$)/i);
+  if (!match) return [];
+  const paths = [];
+  for (const line of splitLines(match[0])) {
+    if (/\(NEW\)/i.test(line)) continue;
+    const pathMatch = line.match(/^\s*-\s+`([^`]+)`/);
+    if (!pathMatch) continue;
+    paths.push(pathMatch[1].replace(/\\/g, "/"));
+  }
+  return paths;
+}
 function cleanToken(t) {
   return t.replace(/^[^a-z0-9_-]+|[^a-z0-9_-]+$/gi, "");
 }
 function extractAcceptanceSection(body) {
-  const match = body.match(/##\s*Acceptance[\s\S]*?(?=\n##\s|\n$|$)/i);
+  const match = body.match(/(?:^|\n)##\s*Acceptance\s*\n[\s\S]*?(?=\n##\s|$)/i);
   if (!match) return "";
   return match[0].slice(0, 500);
 }
-function findStartNodes(nodes, keywords, topK) {
+function findStartNodes(nodes, keywords, filePointerPaths, topK) {
+  if (filePointerPaths.length > 0) {
+    const fileMatches = findStartNodesByFile(nodes, filePointerPaths);
+    if (fileMatches.length > 0) return fileMatches;
+  }
+  return findStartNodesByKeyword(nodes, keywords, topK);
+}
+function findStartNodesByFile(nodes, paths) {
+  const targets = new Set(paths.map((p) => p.replace(/\\/g, "/")));
+  const matches = [];
+  for (const n of nodes) {
+    if (!n.source_file) continue;
+    const normalized = n.source_file.replace(/\\/g, "/");
+    if (targets.has(normalized)) {
+      matches.push({ id: n.id, score: 100 });
+    }
+  }
+  matches.sort((a, b) => {
+    if (a.id < b.id) return -1;
+    if (a.id > b.id) return 1;
+    return 0;
+  });
+  return matches;
+}
+function findStartNodesByKeyword(nodes, keywords, topK) {
   const scored = [];
   for (const n of nodes) {
     const label = (n.label ?? "").toLowerCase();
@@ -33662,87 +34852,6 @@ function computeStaleness(graphPath) {
   };
 }
 
-// src/core/domain/auto-safe-validator.ts
-var AUTO_SAFE_LABEL = "auto-safe";
-var AUTO_SAFE_SCOPE_HOURS_CEILING = 3;
-function validateAutoSafeTask(task) {
-  const errors = [];
-  const body = (task.body ?? "").trim();
-  if (!body) {
-    errors.push("Task body is empty \u2014 auto-safe requires AC, File Pointers, and Scope sections");
-    return { valid: false, errors };
-  }
-  const ac = extractSection(body, /^acceptance(?:\s+criteria)?$/i);
-  const filePointers = extractSection(body, /^file\s+pointers$/i);
-  const scope = extractSection(body, /^scope$/i);
-  if (!ac.trim()) {
-    errors.push("Missing ## Acceptance (or ## Acceptance Criteria) section");
-  } else if (!hasVerifiableShellCommand(ac)) {
-    errors.push(
-      "## Acceptance has no verifiable shell command (need `pnpm `, `node `, or a ```bash code block)"
-    );
-  }
-  if (!filePointers.trim()) {
-    errors.push("Missing ## File Pointers section");
-  } else if (!hasConcretePath(filePointers)) {
-    errors.push("## File Pointers has no concrete path (need at least one .ts/.md/.json/etc)");
-  }
-  if (!scope.trim()) {
-    errors.push("Missing ## Scope section");
-  } else {
-    const upper = parseScopeHours(scope);
-    if (upper === null) {
-      errors.push('## Scope has no parseable hour estimate (e.g. "~2-3h", "2h", "1.5h")');
-    } else if (upper > AUTO_SAFE_SCOPE_HOURS_CEILING) {
-      errors.push(
-        `## Scope estimate ${upper}h exceeds auto-safe ceiling of ${AUTO_SAFE_SCOPE_HOURS_CEILING}h`
-      );
-    }
-  }
-  if (mentionsBuildSensitive(body) && !hasSmokeStep(ac)) {
-    errors.push(
-      "## Acceptance must include a smoke step (body mentions build:mcp / loader / asset copy)"
-    );
-  }
-  return { valid: errors.length === 0, errors };
-}
-function extractSection(body, headingMatcher) {
-  const lines = body.split(/\r?\n/);
-  const out = [];
-  let inSection = false;
-  for (const line of lines) {
-    const headingMatch = /^##\s+(.+?)\s*$/.exec(line);
-    if (headingMatch) {
-      if (inSection) break;
-      if (headingMatcher.test(headingMatch[1])) {
-        inSection = true;
-        continue;
-      }
-    }
-    if (inSection) out.push(line);
-  }
-  return out.join("\n");
-}
-function hasVerifiableShellCommand(section) {
-  if (/(?:^|[\s`])(?:pnpm|node)\s+\S/m.test(section)) return true;
-  if (/```bash[\s\S]*?```/.test(section)) return true;
-  return false;
-}
-function hasConcretePath(section) {
-  return /[\w./\\-]+\.(?:ts|tsx|js|mjs|cjs|mts|json|md|sh|yml|yaml)\b/.test(section);
-}
-function parseScopeHours(section) {
-  const match = /(\d+(?:\.\d+)?)\s*(?:[-–]\s*(\d+(?:\.\d+)?))?\s*h\b/i.exec(section);
-  if (!match) return null;
-  return parseFloat(match[2] ?? match[1]);
-}
-function mentionsBuildSensitive(body) {
-  return /build:mcp|\bloader\b|asset\s+cop/i.test(body);
-}
-function hasSmokeStep(ac) {
-  return /\bsmoke\b/i.test(ac) || /pnpm\s+run\s+build:mcp/i.test(ac);
-}
-
 // src/adapters/mcp/mcp-tools/task-tools.ts
 function defaultBody(id, title) {
   return `# ${id}: ${title}
@@ -33880,24 +34989,6 @@ var register = (server, svc) => {
       return textResponse(svc.updateTask(id, input));
     }
   );
-  server.registerTool(
-    "tasks_update_batch",
-    {
-      description: "Update multiple tasks with the same patch (e.g. bulk mark DONE)",
-      inputSchema: {
-        ids: external_exports3.array(external_exports3.string()).describe("List of task IDs to update"),
-        status: external_exports3.enum(["TODO", "READY", "IN-PROGRESS", "DONE", "CANCELLED"]).optional(),
-        priority: external_exports3.enum(["critical", "high", "medium", "low"]).nullable().optional(),
-        labels: external_exports3.array(external_exports3.string()).optional(),
-        pinned: external_exports3.boolean().optional()
-      }
-    },
-    async ({ ids, ...patch }) => {
-      for (const id of ids) enforceAutoSafe(svc, id, patch);
-      const results = ids.map((id) => svc.updateTask(id, patch));
-      return textResponse(results);
-    }
-  );
 };
 function enforceAutoSafe(svc, id, input) {
   if (!input.labels?.includes(AUTO_SAFE_LABEL)) return;
@@ -33917,6 +35008,58 @@ function enforceAutoSafe(svc, id, input) {
   }
 }
 
+// src/adapters/mcp/rules/mcp-rules-loader.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var RULES_FILENAME = "mcp-rules.md";
+function rulesPath() {
+  return (0, import_path.join)(__dirname, RULES_FILENAME);
+}
+function parseSection(content, heading) {
+  const headingRe = new RegExp(`^##\\s+${heading}\\s*$`, "m");
+  const head = content.match(headingRe);
+  if (!head || head.index === void 0) return "";
+  const startIdx = head.index + head[0].length;
+  const rest = content.slice(startIdx);
+  const next = rest.match(/^##\s/m);
+  const endIdx = next && next.index !== void 0 ? startIdx + next.index : content.length;
+  return content.slice(startIdx, endIdx).trim();
+}
+var EMPTY_RULES = {
+  sessionStart: "",
+  sessionCheckpoint: "",
+  sessionResume: "",
+  sessionEnd: "",
+  conversationRead: ""
+};
+function loadMcpRules(path11 = rulesPath()) {
+  if (!(0, import_fs.existsSync)(path11)) {
+    console.warn(`[mcp-rules] file not found at ${path11} \u2014 returning empty rules`);
+    return { ...EMPTY_RULES };
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(path11, "utf-8");
+    const sessionStart = parseSection(content, "On session_start");
+    const sessionCheckpoint = parseSection(content, "On session_checkpoint");
+    const sessionResume = parseSection(content, "On session_resume");
+    const sessionEnd = parseSection(content, "On session_end");
+    const conversationRead = parseSection(content, "On conversation_read");
+    for (const [name, value] of [
+      ["On session_start", sessionStart],
+      ["On session_checkpoint", sessionCheckpoint],
+      ["On session_resume", sessionResume],
+      ["On session_end", sessionEnd],
+      ["On conversation_read", conversationRead]
+    ]) {
+      if (!value) console.warn(`[mcp-rules] "## ${name}" section missing in ${path11}`);
+    }
+    return { sessionStart, sessionCheckpoint, sessionResume, sessionEnd, conversationRead };
+  } catch (err) {
+    console.error(`[mcp-rules] failed to read ${path11}:`, err);
+    return { ...EMPTY_RULES };
+  }
+}
+
 // src/adapters/mcp/mcp-tools/conversation-tools.ts
 var participantTypeSchema = external_exports3.enum(["human", "agent", "role"]);
 var messageTypeSchema = external_exports3.enum([
@@ -33961,6 +35104,21 @@ function tryLifecycle(fn) {
     throw e;
   }
 }
+function shouldInjectConversationEtiquette(status) {
+  return status === "open" || status === "discussing";
+}
+function readConversation(svc, conversationId) {
+  const conv = svc.getConversation(conversationId);
+  if (!conv) return null;
+  return {
+    ...conv,
+    participants: svc.getConversationParticipants(conversationId),
+    messages: svc.getConversationMessages(conversationId),
+    actions: svc.getConversationActions(conversationId),
+    links: svc.getConversationLinks(conversationId),
+    etiquette: shouldInjectConversationEtiquette(conv.status) ? loadMcpRules().conversationRead : null
+  };
+}
 var register2 = (server, svc) => {
   server.registerTool(
     "conversation_open",
@@ -34124,22 +35282,16 @@ var register2 = (server, svc) => {
       inputSchema: { conversationId: external_exports3.string() }
     },
     async ({ conversationId }) => {
-      const conv = svc.getConversation(conversationId);
-      if (!conv) return textResponse(`Conversation ${conversationId} not found`);
-      return textResponse({
-        ...conv,
-        participants: svc.getConversationParticipants(conversationId),
-        messages: svc.getConversationMessages(conversationId),
-        actions: svc.getConversationActions(conversationId),
-        links: svc.getConversationLinks(conversationId)
-      });
+      const result = readConversation(svc, conversationId);
+      if (!result) return textResponse(`Conversation ${conversationId} not found`);
+      return textResponse(result);
     }
   );
 };
 
 // src/adapters/mcp/mcp-tools/project-context-builder.ts
 var fs4 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
 var SUMMARY_MAX_CHARS = 600;
 function buildProjectContext(svc, projectId, depth = "full", contentRoot = process.env.CHODA_CONTENT_ROOT || "") {
   const project = fetchProject(svc, projectId);
@@ -34222,7 +35374,7 @@ function loadRecentDecisions(sources, contentRoot, depth) {
   }).filter((d) => d.excerpt.length > 0);
 }
 function readMarkdown(contentRoot, sourcePath, depth) {
-  const absolute = path5.isAbsolute(sourcePath) ? sourcePath : path5.join(contentRoot, sourcePath);
+  const absolute = path8.isAbsolute(sourcePath) ? sourcePath : path8.join(contentRoot, sourcePath);
   if (!fs4.existsSync(absolute)) return null;
   try {
     const raw = fs4.readFileSync(absolute, "utf-8");
@@ -34350,37 +35502,6 @@ var register4 = (server, svc) => {
       return textResponse(result);
     }
   );
-  server.registerTool(
-    "workspace_remove",
-    {
-      description: "Remove a workspace. Default soft (archive). Pass hard=true for permanent DELETE \u2014 rejected if any sessions still reference the workspace.",
-      inputSchema: {
-        projectId: external_exports3.string().describe("Parent project ID"),
-        workspaceId: external_exports3.string().describe("Workspace ID to remove"),
-        hard: external_exports3.boolean().optional().describe("true = permanent DELETE (rejected if referenced); default false = soft archive")
-      }
-    },
-    async ({ projectId, workspaceId, hard }) => {
-      if (!hard) {
-        return textResponse(archiveOrError(svc, projectId, workspaceId));
-      }
-      const ws = svc.getWorkspace(workspaceId);
-      if (!ws) return textResponse(`Workspace ${workspaceId} not found`);
-      if (ws.projectId !== projectId) {
-        return textResponse(
-          `Workspace ${workspaceId} belongs to project ${ws.projectId}, not ${projectId}`
-        );
-      }
-      const refs = svc.countWorkspaceReferences(workspaceId);
-      if (refs.sessions > 0) {
-        return textResponse(
-          `Cannot hard-delete workspace ${workspaceId} \u2014 ${refs.sessions} session(s) still reference it. Use workspace_archive instead.`
-        );
-      }
-      svc.deleteWorkspace(workspaceId);
-      return textResponse({ ok: true, hard: true });
-    }
-  );
 };
 function archiveOrError(svc, projectId, workspaceId) {
   const ws = svc.getWorkspace(workspaceId);
@@ -34398,68 +35519,19 @@ function archiveOrError(svc, projectId, workspaceId) {
   return { ok: true, archivedAt: archived.archivedAt };
 }
 
-// src/adapters/mcp/rules/session-rules-loader.ts
-var import_fs = require("fs");
-var import_path = require("path");
-var RULES_FILENAME = "session-rules.md";
-function rulesPath() {
-  return (0, import_path.join)(__dirname, RULES_FILENAME);
-}
-function parseSection(content, heading) {
-  const headingRe = new RegExp(`^##\\s+${heading}\\s*$`, "m");
-  const head = content.match(headingRe);
-  if (!head || head.index === void 0) return "";
-  const startIdx = head.index + head[0].length;
-  const rest = content.slice(startIdx);
-  const next = rest.match(/^##\s/m);
-  const endIdx = next && next.index !== void 0 ? startIdx + next.index : content.length;
-  return content.slice(startIdx, endIdx).trim();
-}
-var EMPTY_RULES = {
-  sessionStart: "",
-  sessionCheckpoint: "",
-  sessionResume: "",
-  sessionEnd: ""
-};
-function loadSessionRules(path7 = rulesPath()) {
-  if (!(0, import_fs.existsSync)(path7)) {
-    console.warn(`[session-rules] file not found at ${path7} \u2014 returning empty rules`);
-    return { ...EMPTY_RULES };
-  }
-  try {
-    const content = (0, import_fs.readFileSync)(path7, "utf-8");
-    const sessionStart = parseSection(content, "On session_start");
-    const sessionCheckpoint = parseSection(content, "On session_checkpoint");
-    const sessionResume = parseSection(content, "On session_resume");
-    const sessionEnd = parseSection(content, "On session_end");
-    for (const [name, value] of [
-      ["On session_start", sessionStart],
-      ["On session_checkpoint", sessionCheckpoint],
-      ["On session_resume", sessionResume],
-      ["On session_end", sessionEnd]
-    ]) {
-      if (!value) console.warn(`[session-rules] "## ${name}" section missing in ${path7}`);
-    }
-    return { sessionStart, sessionCheckpoint, sessionResume, sessionEnd };
-  } catch (err) {
-    console.error(`[session-rules] failed to read ${path7}:`, err);
-    return { ...EMPTY_RULES };
-  }
-}
-
 // src/adapters/mcp/mcp-tools/workspace-resolver.ts
-var path6 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 var isWindows = process.platform === "win32";
-function normalize(p) {
-  const resolved = path6.resolve(p).replace(/[\\/]+$/, "");
+function normalize2(p) {
+  const resolved = path9.resolve(p).replace(/[\\/]+$/, "");
   return isWindows ? resolved.toLowerCase().replace(/\//g, "\\") : resolved;
 }
 function isDescendantOrEqual(parent, child) {
   if (parent === child) return true;
-  const rel = path6.relative(parent, child);
+  const rel = path9.relative(parent, child);
   if (rel === "") return true;
   if (rel.startsWith("..")) return false;
-  return !path6.isAbsolute(rel);
+  return !path9.isAbsolute(rel);
 }
 function resolveWorkspaceId(input) {
   const { explicitWorkspaceId, cwd, workspaces } = input;
@@ -34472,8 +35544,8 @@ function resolveWorkspaceId(input) {
 ${list}`
     );
   }
-  const normalizedCwd = normalize(cwd);
-  const matches = workspaces.map((w) => ({ workspace: w, normalized: normalize(w.cwd) })).filter((m) => isDescendantOrEqual(m.normalized, normalizedCwd)).sort((a, b) => b.normalized.length - a.normalized.length);
+  const normalizedCwd = normalize2(cwd);
+  const matches = workspaces.map((w) => ({ workspace: w, normalized: normalize2(w.cwd) })).filter((m) => isDescendantOrEqual(m.normalized, normalizedCwd)).sort((a, b) => b.normalized.length - a.normalized.length);
   if (matches.length === 0) {
     const list = workspaces.map((w) => `  - ${w.id} (${w.cwd})`).join("\n");
     throw new WorkspaceResolutionError(
@@ -34639,7 +35711,7 @@ var register5 = (server, svc, git = new GitOpsImpl()) => {
       });
       const lastSession = loadLastSession(svc, projectId, resolvedWorkspaceId);
       const bundle = buildProjectContext(svc, projectId, "summary");
-      const rules = loadSessionRules();
+      const rules = loadMcpRules();
       return {
         sessionId: session.id,
         workspaceId: session.workspaceId,
@@ -34731,7 +35803,7 @@ var register5 = (server, svc, git = new GitOpsImpl()) => {
     },
     async ({ sessionId }) => tryLifecycle2(() => {
       const result = svc.resumeSession(sessionId);
-      const rules = loadSessionRules();
+      const rules = loadMcpRules();
       return {
         session: result.session,
         checkpoint: result.checkpoint,
@@ -34799,7 +35871,7 @@ function buildProjectSummary(bundle) {
   if (!bundle) return null;
   const pieces = [];
   if (bundle.architecture) {
-    pieces.push(bundle.architecture.split("\n").slice(0, 3).join(" ").slice(0, 200));
+    pieces.push(splitLines(bundle.architecture).slice(0, 3).join(" ").slice(0, 200));
   }
   return pieces.length > 0 ? pieces.join(" \u2014 ") : null;
 }
@@ -34975,24 +36047,6 @@ var register6 = (server, svc) => {
     },
     async ({ id, reason }) => tryLifecycle3(() => svc.archiveInbox(id, reason))
   );
-  server.registerTool(
-    "inbox_delete",
-    {
-      description: "Hard delete an inbox item. Only allowed for raw or archived items.",
-      inputSchema: { id: external_exports3.string() }
-    },
-    async ({ id }) => {
-      const item = svc.getInbox(id);
-      if (!item) return textResponse(`Inbox ${id} not found`);
-      if (item.status !== "raw" && item.status !== "archived") {
-        return textResponse(
-          `Inbox ${id} is ${item.status} \u2014 only raw or archived items can be deleted`
-        );
-      }
-      svc.deleteInbox(id);
-      return textResponse({ deleted: id });
-    }
-  );
 };
 
 // src/adapters/mcp/mcp-tools/backup-tools.ts
@@ -35057,22 +36111,22 @@ function runBackup(db, userData, now2 = /* @__PURE__ */ new Date()) {
 }
 
 // src/adapters/mcp/mcp-tools/backup-tools.ts
-function register7(server, svc, dataDir2, dbPath2) {
+function register7(server, svc, dataDir, dbPath) {
   server.registerTool(
     "backup_list",
     {
       description: "List existing SQLite backups under <dataDir>/backups, newest first. Use before destructive batch ops to confirm a recent backup exists.",
       inputSchema: {}
     },
-    async () => textResponse(listBackups(dataDir2))
+    async () => textResponse(listBackups(dataDir))
   );
   server.registerTool(
     "backup_create",
     {
-      description: "Create a SQLite backup at <dataDir>/backups/choda-deck-<YYYY-MM-DD>.db (overwrites same-day file, prunes to 7 newest). Returns the new BackupInfo. Run before risky operations like tasks_update_batch.",
+      description: "Create a SQLite backup at <dataDir>/backups/choda-deck-<YYYY-MM-DD>.db (overwrites same-day file, prunes to 7 newest). Returns the new BackupInfo. Run before risky bulk operations.",
       inputSchema: {}
     },
-    async () => textResponse(runBackup(svc, dataDir2))
+    async () => textResponse(runBackup(svc, dataDir))
   );
   server.registerTool(
     "backup_restore",
@@ -35083,13 +36137,13 @@ function register7(server, svc, dataDir2, dbPath2) {
       }
     },
     async ({ filename }) => {
-      const source = (0, import_path3.join)(backupDir(dataDir2), filename);
+      const source = (0, import_path3.join)(backupDir(dataDir), filename);
       if (!(0, import_fs3.existsSync)(source)) {
         return textResponse({ ok: false, error: `Backup file not found: ${filename}` });
       }
       try {
         svc.close();
-        (0, import_fs3.copyFileSync)(source, dbPath2);
+        (0, import_fs3.copyFileSync)(source, dbPath);
       } catch (err) {
         return textResponse({ ok: false, error: err.message });
       }
@@ -35142,18 +36196,6 @@ var register8 = (server, svc) => {
       })
     )
   );
-  server.registerTool(
-    "knowledge_register_existing",
-    {
-      description: "Index an existing knowledge MD file without writing/overwriting it. Reads frontmatter, INSERTs (or upserts on slug match) into knowledge_index, schedules embedding. Use for backfill of pre-existing ADRs (e.g. workspace ADRs migrated under a multi-repo project). Frontmatter projectId + workspaceId must match the arguments.",
-      inputSchema: {
-        filePath: external_exports3.string().describe("Absolute path to the existing .md file"),
-        projectId: external_exports3.string().describe("Project ID (must match frontmatter)"),
-        workspaceId: external_exports3.string().optional().describe("Workspace ID (must match frontmatter; omit for project-level entries)")
-      }
-    },
-    async ({ filePath, projectId, workspaceId }) => textResponse(svc.registerExistingKnowledge({ filePath, projectId, workspaceId }))
-  );
   server.registerTool(
     "knowledge_get",
     {
@@ -35240,27 +36282,189 @@ var register8 = (server, svc) => {
   );
 };
 
-// src/adapters/mcp/server.ts
-var { dbPath, dataDir } = resolveDataPaths();
-async function main() {
+// src/core/domain/stats-service.ts
+var FLOOR_CALLS = 5;
+var BROKEN_ERROR_RATE = 0.2;
+var MVP_ERROR_RATE = 0.05;
+var MVP_TOP_FRACTION = 0.25;
+function computeStatsReport(input) {
+  const merged = mergeWithCanonical(input.rows, input.canonical);
+  const totalCalls = merged.reduce((sum, t) => sum + t.calls, 0);
+  const mvpThreshold = computeMvpThreshold(merged);
+  const perTool = merged.map((t) => ({
+    tool: t.tool,
+    calls: t.calls,
+    errorRate: t.calls === 0 ? 0 : t.errors / t.calls,
+    avgDurationMs: t.avgDurationMs,
+    lastUsedAt: t.lastUsedAt,
+    classification: classify(t, mvpThreshold)
+  }));
+  perTool.sort((a, b) => b.calls - a.calls || a.tool.localeCompare(b.tool));
+  return {
+    period: input.period,
+    totalCalls,
+    perTool,
+    deadInWindow: perTool.filter((t) => t.classification === "dead-in-window").map((t) => t.tool),
+    brokenTools: perTool.filter((t) => t.classification === "broken").map((t) => t.tool)
+  };
+}
+function mergeWithCanonical(rows, canonical) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    seen.set(r.tool, {
+      tool: r.tool,
+      calls: r.calls,
+      errors: r.errors,
+      avgDurationMs: r.avgDurationMs,
+      lastUsedAt: r.lastUsedAt
+    });
+  }
+  for (const name of canonical) {
+    if (!seen.has(name)) {
+      seen.set(name, {
+        tool: name,
+        calls: 0,
+        errors: 0,
+        avgDurationMs: 0,
+        lastUsedAt: null
+      });
+    }
+  }
+  return Array.from(seen.values());
+}
+function computeMvpThreshold(merged) {
+  const active = merged.filter((t) => t.calls > 0).map((t) => t.calls);
+  if (active.length === 0) return Infinity;
+  active.sort((a, b) => b - a);
+  const topN = Math.max(1, Math.ceil(active.length * MVP_TOP_FRACTION));
+  return active[topN - 1];
+}
+function classify(t, mvpThreshold) {
+  if (t.calls === 0) return "dead-in-window";
+  const errorRate = t.errors / t.calls;
+  if (t.calls >= FLOOR_CALLS && errorRate > BROKEN_ERROR_RATE) return "broken";
+  if (t.calls >= FLOOR_CALLS && errorRate < MVP_ERROR_RATE && t.calls >= mvpThreshold) {
+    return "mvp";
+  }
+  return "emerging";
+}
+
+// src/adapters/mcp/mcp-tools/stats-tools.ts
+var register9 = (server, svc) => {
+  server.registerTool(
+    "stats_report",
+    {
+      description: "Report MCP tool usage stats over an optional ISO time window \u2014 returns per-tool calls / errorRate / avgDurationMs / lastUsedAt + classification (mvp / broken / dead-in-window / emerging) plus deadInWindow + brokenTools name lists. No projectId/session breakdown V0. Self-records (this call appears in the next stats_report).",
+      inputSchema: {
+        since: external_exports3.string().optional().describe("Inclusive lower bound (ISO 8601). Omit for all-time."),
+        until: external_exports3.string().optional().describe("Inclusive upper bound (ISO 8601). Omit for now.")
+      }
+    },
+    async ({ since, until }) => {
+      const period = { since: since ?? null, until: until ?? null };
+      const rows = svc.queryToolInvocations(period);
+      const report = computeStatsReport({
+        rows,
+        canonical: server.registeredToolNames,
+        period
+      });
+      return textResponse(report);
+    }
+  );
+};
+
+// src/adapters/mcp/mcp-tools/cleanup-tools.ts
+var fs6 = __toESM(require("node:fs"));
+var KNOWLEDGE_ACTION_ENUM = ["delete", "leave"];
+var register10 = (server, svc) => {
+  server.registerTool(
+    "cleanup_worktree_orphans",
+    {
+      description: "Detect and clean orphan workspaces + knowledge entries left by deleted git worktrees. Detection: cwd / filePath matches `.worktrees` segment AND the path no longer exists on disk. Default dry-run \u2014 pass dryRun=false to mutate. Workspaces are archived (idempotent); knowledge action is configurable: `delete` removes the row + INDEX entry, `leave` (default) reports them for manual recovery without mutating.",
+      inputSchema: {
+        projectId: external_exports3.string().describe("Project ID to scan"),
+        dryRun: external_exports3.boolean().optional().describe("Default true \u2014 list candidates without mutating. Pass false to apply."),
+        knowledgeAction: external_exports3.enum(KNOWLEDGE_ACTION_ENUM).optional().describe("How to handle orphan knowledge when not dry-run. Default `leave`.")
+      }
+    },
+    async ({ projectId, dryRun, knowledgeAction }) => {
+      const project = svc.getProject(projectId);
+      if (!project) return textResponse(`Project ${projectId} not found`);
+      const isDryRun = dryRun ?? true;
+      const action = knowledgeAction ?? "leave";
+      const orphanWorkspaces = svc.findWorkspaces(projectId, false).filter((ws) => isLikelyWorktreePath(ws.cwd) && !fs6.existsSync(ws.cwd)).map((ws) => ({ id: ws.id, label: ws.label, cwd: ws.cwd }));
+      const orphanKnowledge = svc.listKnowledge({ projectId }).filter((k) => isLikelyWorktreePath(k.filePath) && !fs6.existsSync(k.filePath)).map((k) => ({ slug: k.slug, filePath: k.filePath, workspaceId: k.workspaceId }));
+      const candidates = { workspaces: orphanWorkspaces, knowledge: orphanKnowledge };
+      if (isDryRun) {
+        const result2 = {
+          dryRun: true,
+          knowledgeAction: action,
+          archivedWorkspaces: [],
+          deletedKnowledge: [],
+          leftKnowledge: [],
+          candidates
+        };
+        return textResponse(result2);
+      }
+      const archivedWorkspaces = [];
+      for (const ws of orphanWorkspaces) {
+        const archived = svc.archiveWorkspace(ws.id);
+        if (archived) archivedWorkspaces.push(ws);
+      }
+      const deletedKnowledge = [];
+      const leftKnowledge = [];
+      if (action === "delete") {
+        for (const k of orphanKnowledge) {
+          svc.deleteKnowledge(k.slug);
+          deletedKnowledge.push(k);
+        }
+      } else {
+        for (const k of orphanKnowledge) leftKnowledge.push(k);
+      }
+      const result = {
+        dryRun: false,
+        knowledgeAction: action,
+        archivedWorkspaces,
+        deletedKnowledge,
+        leftKnowledge,
+        candidates
+      };
+      return textResponse(result);
+    }
+  );
+};
+
+// src/adapters/mcp/server-bootstrap.ts
+async function startMcpServer() {
+  const { dbPath, dataDir } = resolveDataPaths();
+  fs7.mkdirSync(path10.dirname(dbPath), { recursive: true });
   const svc = new SqliteTaskService(dbPath);
   await svc.initializeAsync();
   const server = new McpServer(
     { name: "choda-tasks", version: "0.2.0" },
     { capabilities: { tools: {} } }
   );
-  register(server, svc);
-  register2(server, svc);
-  register3(server, svc);
-  register4(server, svc);
-  register5(server, svc);
-  register6(server, svc);
-  register7(server, svc, dataDir, dbPath);
-  register8(server, svc);
+  const instrumented = createInstrumentedServer(server, svc);
+  register(instrumented, svc);
+  register2(instrumented, svc);
+  register3(instrumented, svc);
+  register4(instrumented, svc);
+  register5(instrumented, svc);
+  register6(instrumented, svc);
+  register7(instrumented, svc, dataDir, dbPath);
+  register8(instrumented, svc);
+  register9(instrumented, svc);
+  register10(instrumented, svc);
+  console.error(`[choda-deck] registered ${instrumented.registeredToolNames.length} MCP tools`);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
-main().catch((err) => {
+
+// src/adapters/mcp/server.ts
+process.stderr.write(
+  "[choda-deck] DEPRECATED: dist/mcp-server.cjs will be removed in v0.2. Update your MCP config to run `choda-deck mcp serve` instead.\n"
+);
+startMcpServer().catch((err) => {
   console.error("MCP Task Server failed:", err);
   process.exit(1);
 });