create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/walle-transcript.js

@@ -39,6 +39,40 @@ function textBlocks(text) {
   return [{ type: 'text', text: String(text || '') }];
 }
 
+function attachmentMetadata(attachments) {
+  if (!Array.isArray(attachments) || attachments.length === 0) return [];
+  return attachments
+    .filter((attachment) => attachment && typeof attachment === 'object')
+    .map((attachment, index) => {
+      const out = {
+        type: attachment.type || 'image',
+        label: attachment.label || `[Image #${index + 1}]`,
+      };
+      const copy = [
+        'name',
+        'filename',
+        'mediaType',
+        'mimeType',
+        'url',
+        'path',
+        'file_path',
+        'id',
+        'imageWidth',
+        'imageHeight',
+        'originalWidth',
+        'originalHeight',
+        'resizedForProvider',
+        'byteSize',
+      ];
+      for (const key of copy) {
+        if (attachment[key] !== undefined && attachment[key] !== null && attachment[key] !== '') {
+          out[key] = attachment[key];
+        }
+      }
+      return out;
+    });
+}
+
 function appendRecord(filePath, record) {
   ensureDirForFile(filePath);
   const offset = fs.existsSync(filePath) ? fs.statSync(filePath).size : 0;
@@ -105,6 +139,8 @@ function appendUserMessage(filePath, opts = {}) {
   const record = baseMessage(opts, 'user', 'user');
   if (opts.modelId) record.modelId = opts.modelId;
   if (opts.modelProvider) record.modelProvider = opts.modelProvider;
+  const attachments = attachmentMetadata(opts.attachments);
+  if (attachments.length) record.attachments = attachments;
   return appendRecord(filePath, record);
 }
 
@@ -165,6 +201,21 @@ function readLastUuid(filePath) {
   return '';
 }
 
+function readSessionMeta(filePath) {
+  let raw;
+  try { raw = fs.readFileSync(filePath, 'utf8'); } catch { return null; }
+  const lines = raw.split('\n').filter(Boolean);
+  for (const line of lines) {
+    try {
+      const row = JSON.parse(line);
+      if (row && row.type === 'session_meta') return row;
+    } catch {
+      // Ignore malformed tail rows; the transcript writer is append-only.
+    }
+  }
+  return null;
+}
+
 module.exports = {
   VERSION,
   WALLE_PROJECT_ENTRY,
@@ -177,4 +228,5 @@ module.exports = {
   appendPart,
   extractText,
   readLastUuid,
+  readSessionMeta,
 };

package/template/claude-task-manager/lib/worktree-active-sync.js

@@ -1,11 +1,12 @@
 'use strict';
 
 function normalizeLiveStatus(status) {
-  const text = String(status || '').toLowerCase();
+  const text = String(status || '').toLowerCase().replace(/[-\s]+/g, '_');
   if (!text) return '';
-  if (text === 'busy') return 'running';
-  if (text === 'waiting-for-input') return 'waiting_input';
-  if (['running', 'waiting', 'waiting_input', 'idle', 'exited'].includes(text)) return text;
+  if (text === 'busy' || text === 'active' || text === 'working' || text === 'thinking') return 'running';
+  if (text === 'restoring' || text === 'resuming' || text === 'restore_starting' || text === 'restarting') return 'resuming';
+  if (text === 'waiting_for_input') return 'waiting_input';
+  if (['running', 'resuming', 'waiting', 'waiting_input', 'idle', 'exited'].includes(text)) return text;
   return '';
 }
 
@@ -59,8 +60,11 @@ function activeSyncWorktreePolicy(wt, quiescence, opts = {}) {
   if (!wt.branch || wt.branch === 'HEAD' || wt.state === 'detached') {
     return { ok: false, status: quiescence.status, reason: 'Recover this worktree onto a branch before syncing from main.' };
   }
-  if ((wt.dirtyFiles || 0) > 0) {
-    return { ok: false, status: quiescence.status, reason: 'Commit or stash dirty files before syncing from main.' };
+  const trackedDirty = wt.trackedDirtyFiles != null
+    ? Number(wt.trackedDirtyFiles || 0)
+    : Math.max(0, Number(wt.dirtyFiles || 0) - Number(wt.untrackedFiles || 0));
+  if (trackedDirty > 0) {
+    return { ok: false, status: quiescence.status, reason: 'Commit or stash tracked dirty files before syncing from main.' };
   }
   if ((wt.ahead || 0) > 0 || wt.state === 'diverged') {
     return {
@@ -75,7 +79,7 @@ function activeSyncWorktreePolicy(wt, quiescence, opts = {}) {
   return {
     ok: true,
     status: quiescence.status,
-    reason: 'Active session is idle and the worktree is clean; sync can proceed with confirmation.',
+    reason: 'Active session is idle and tracked files are clean; sync can proceed with confirmation.',
   };
 }
 

package/template/claude-task-manager/lib/worktree-cwd.js

@@ -32,9 +32,19 @@ function realpathOrResolve(p) {
   }
 }
 
+// resolveWorktreeRepoRoot does 2 synchronous git execs (rev-parse --show-toplevel +
+// worktree list --porcelain) plus realpath/stat. It's hit on the worktree API hot path
+// (~per request), and a CPU profile showed these synchronous execFileSync calls blocking
+// the event loop. The repo root for a given cwd is invariant (always the primary checkout,
+// regardless of worktrees being added/removed), so cache successful resolutions briefly.
+const _repoRootCache = new Map(); // raw cwd -> { at, result }
+const _REPO_ROOT_CACHE_TTL_MS = Number(process.env.CTM_WORKTREE_REPO_ROOT_CACHE_TTL_MS || 60000);
+
 function resolveWorktreeRepoRoot(cwd) {
   if (typeof cwd !== 'string' || !cwd.trim()) return fail('cwd is required');
   const raw = cwd.trim();
+  const cached = _repoRootCache.get(raw);
+  if (cached && (Date.now() - cached.at) < _REPO_ROOT_CACHE_TTL_MS) return cached.result;
   if (raw.includes('~')) {
     return fail('cwd must be an absolute path with no `~` (the literal-tilde is the source of ghost worktrees).');
   }
@@ -70,13 +80,34 @@ function resolveWorktreeRepoRoot(cwd) {
     primaryRoot = '';
   }
 
-  return {
+  const result = {
     ok: true,
     cwd: realpathOrResolve(primaryRoot || topLevel),
     requestedCwd: realCwd,
   };
+  // Cache only successful resolutions (a failing cwd may be created later). Bound the map.
+  if (_repoRootCache.size > 200) _repoRootCache.clear();
+  _repoRootCache.set(raw, { at: Date.now(), result });
+  return result;
+}
+
+function resolveWorktreeRepoRootWithFallback(cwd, fallbackCwd) {
+  const primary = resolveWorktreeRepoRoot(cwd);
+  if (primary.ok) return { ...primary, fallbackUsed: false };
+
+  const fallback = resolveWorktreeRepoRoot(fallbackCwd);
+  if (!fallback.ok) return primary;
+
+  return {
+    ...fallback,
+    fallbackUsed: true,
+    fallbackReason: primary.error,
+    fallbackStatus: primary.status || 400,
+    requestedCwd: primary.requestedCwd || cwd,
+  };
 }
 
 module.exports = {
   resolveWorktreeRepoRoot,
+  resolveWorktreeRepoRootWithFallback,
 };

package/template/claude-task-manager/package.json

@@ -32,7 +32,7 @@
     "@simplewebauthn/server": "^13.3.0",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
-    "better-sqlite3": "^12.8.0",
+    "better-sqlite3": "^12.10.0",
     "node-pty": "^1.2.0-beta.12",
     "puppeteer": "^24.41.0",
     "qrcode": "^1.5.4",

package/template/claude-task-manager/prompt-harvest.js

@@ -177,8 +177,16 @@ function harvestSession(filePath, projectPath) {
   `);
 
   let count = 0;
-  const txn = d.transaction(() => {
-    for (const msg of parsed.messages) {
+  // Insert in BOUNDED BATCHES, each its OWN transaction. A long active session can carry
+  // thousands of messages; wrapping them all in a single transaction held the db-owner
+  // write lock for tens of seconds (observed 34–59s), which busy-waits CTM's main-loop
+  // synchronous reads and freezes the loop — long enough that the Wall-E MCP readiness
+  // probe times out 3× and CTM raises a false "MCP never became ready". Committing in
+  // small batches releases the lock between batches so the main loop + other writers can
+  // interleave. INSERT OR IGNORE keeps it idempotent across batches/runs.
+  const BATCH = Math.max(1, Number(process.env.CTM_HARVEST_MSG_BATCH || 250));
+  const insertBatch = d.transaction((slice) => {
+    for (const msg of slice) {
       // Save images and collect refs
       const imageRefs = [];
       if (msg.images) {
@@ -219,7 +227,11 @@ function harvestSession(filePath, projectPath) {
       }
     }
   });
-  txn();
+
+  const msgs = parsed.messages;
+  for (let i = 0; i < msgs.length; i += BATCH) {
+    insertBatch(msgs.slice(i, i + BATCH));
+  }
   return count;
 }
 
@@ -1003,84 +1015,95 @@ function refreshLifecycleStatuses() {
   const now = Date.now();
   const STALE_DAYS = 30;
 
-  const updateStmt = d.prepare(`UPDATE prompts SET lifecycle_status = ?, updated_at = datetime('now') WHERE id = ?`);
-
-  const txn = d.transaction(() => {
-    for (const prompt of prompts) {
-      const currentStatus = prompt.lifecycle_status || 'draft';
-      // Skip manually managed statuses
-      if (currentStatus === 'template' || currentStatus === 'archived') continue;
-
-      const content = (prompt.content || '').trim();
-      if (content.length < 15) continue;
-
-      // Find sessions where this prompt's text appears
-      const matchedSessions = new Set();
-      let latestMatch = null;
-
-      // 1. Check explicit sends via prompt_usage
-      const explicitSessions = usageByPrompt.get(prompt.id);
-      if (explicitSessions) {
-        for (const sid of explicitSessions) matchedSessions.add(sid);
-      }
+  // Phase 1 — MATCH (read + CPU only, NO write lock). This nested loop is
+  // O(prompts × execs × words) substring matching over arrays already loaded
+  // above; it touches no DB and must not hold the SQLite write lock. It used to
+  // run inside d.transaction(), which pinned the write lock for 80-90s on the
+  // db-owner worker and fail-fasted every main-thread write — most visibly the
+  // hotkey screenshot INSERT ("took screenshot, nothing happens"). Computing the
+  // status changes here and applying them in a separate short transaction below
+  // drops the lock hold from ~90s to milliseconds.
+  for (const prompt of prompts) {
+    const currentStatus = prompt.lifecycle_status || 'draft';
+    // Skip manually managed statuses
+    if (currentStatus === 'template' || currentStatus === 'archived') continue;
+
+    const content = (prompt.content || '').trim();
+    if (content.length < 15) continue;
+
+    // Find sessions where this prompt's text appears
+    const matchedSessions = new Set();
+    let latestMatch = null;
+
+    // 1. Check explicit sends via prompt_usage
+    const explicitSessions = usageByPrompt.get(prompt.id);
+    if (explicitSessions) {
+      for (const sid of explicitSessions) matchedSessions.add(sid);
+    }
 
-      // 2. Text-match against harvested session messages
-      const contentWords = content.toLowerCase().split(/\s+/).filter(w => w.length > 4);
-      if (contentWords.length >= 3) {
-        const contentNorm = normalizePrompt(content);
-        const minMatchCount = Math.max(3, Math.ceil(contentWords.length * 0.5));
+    // 2. Text-match against harvested session messages
+    const contentWords = content.toLowerCase().split(/\s+/).filter(w => w.length > 4);
+    if (contentWords.length >= 3) {
+      const contentNorm = normalizePrompt(content);
+      const minMatchCount = Math.max(3, Math.ceil(contentWords.length * 0.5));
 
-        for (const exec of allExecs) {
-          if (matchedSessions.has(exec.session_id) && latestMatch) continue;
+      for (const exec of allExecs) {
+        if (matchedSessions.has(exec.session_id) && latestMatch) continue;
 
-          const execLower = exec.message_text.toLowerCase();
+        const execLower = exec.message_text.toLowerCase();
 
-          let matchCount = 0;
-          for (const w of contentWords) {
-            if (execLower.includes(w)) matchCount++;
-          }
+        let matchCount = 0;
+        for (const w of contentWords) {
+          if (execLower.includes(w)) matchCount++;
+        }
 
-          const matched = matchCount >= minMatchCount;
-          let substringMatched = false;
-          if (!matched) {
-            const execNorm = normalizePrompt(exec.message_text);
-            substringMatched = execNorm.length >= 30 && (execNorm.includes(contentNorm.slice(0, 80)) || contentNorm.includes(execNorm.slice(0, 80)));
-          }
+        const matched = matchCount >= minMatchCount;
+        let substringMatched = false;
+        if (!matched) {
+          const execNorm = normalizePrompt(exec.message_text);
+          substringMatched = execNorm.length >= 30 && (execNorm.includes(contentNorm.slice(0, 80)) || contentNorm.includes(execNorm.slice(0, 80)));
+        }
 
-          if (matched || substringMatched) {
-            matchedSessions.add(exec.session_id);
-            if (!latestMatch || (exec.executed_at && exec.executed_at > latestMatch)) {
-              latestMatch = exec.executed_at;
-            }
+        if (matched || substringMatched) {
+          matchedSessions.add(exec.session_id);
+          if (!latestMatch || (exec.executed_at && exec.executed_at > latestMatch)) {
+            latestMatch = exec.executed_at;
           }
         }
       }
+    }
 
-      const sessionCount = matchedSessions.size;
-      let newStatus = currentStatus;
+    const sessionCount = matchedSessions.size;
+    let newStatus = currentStatus;
 
-      if (sessionCount >= 3 && (currentStatus === 'draft' || currentStatus === 'used')) {
-        newStatus = 'frequent';
-      } else if (sessionCount >= 1 && currentStatus === 'draft') {
-        newStatus = 'used';
-      }
+    if (sessionCount >= 3 && (currentStatus === 'draft' || currentStatus === 'used')) {
+      newStatus = 'frequent';
+    } else if (sessionCount >= 1 && currentStatus === 'draft') {
+      newStatus = 'used';
+    }
 
-      if (newStatus !== currentStatus) {
-        updateStmt.run(newStatus, prompt.id);
-        updated.push({ id: prompt.id, title: prompt.title, from: currentStatus, to: newStatus, sessions: sessionCount });
-      }
+    if (newStatus !== currentStatus) {
+      updated.push({ id: prompt.id, title: prompt.title, from: currentStatus, to: newStatus, sessions: sessionCount });
+    }
 
-      // Check staleness (for used/frequent prompts only)
-      if ((newStatus === 'used' || newStatus === 'frequent') && latestMatch) {
-        const lastUsedDate = new Date(latestMatch);
-        const daysSince = (now - lastUsedDate.getTime()) / 86400000;
-        if (daysSince > STALE_DAYS) {
-          stale.push({ id: prompt.id, title: prompt.title, status: newStatus, daysSinceUsed: Math.round(daysSince), lastUsed: latestMatch });
-        }
+    // Check staleness (for used/frequent prompts only)
+    if ((newStatus === 'used' || newStatus === 'frequent') && latestMatch) {
+      const lastUsedDate = new Date(latestMatch);
+      const daysSince = (now - lastUsedDate.getTime()) / 86400000;
+      if (daysSince > STALE_DAYS) {
+        stale.push({ id: prompt.id, title: prompt.title, status: newStatus, daysSinceUsed: Math.round(daysSince), lastUsed: latestMatch });
       }
     }
-  });
-  txn();
+  }
+
+  // Phase 2 — APPLY (write lock held only for the handful of status UPDATEs).
+  if (updated.length > 0) {
+    const updateStmt = d.prepare(`UPDATE prompts SET lifecycle_status = ?, updated_at = datetime('now') WHERE id = ?`);
+    const applyTxn = d.transaction((rows) => {
+      for (const u of rows) updateStmt.run(u.to, u.id);
+    });
+    applyTxn(updated);
+  }
 
   // Update last_lifecycle_refresh_at watermark
   const refreshedAt = new Date().toISOString().replace('T', ' ').replace('Z', '');

package/template/claude-task-manager/providers/claude-code.js

@@ -5,12 +5,43 @@
 
 const APPROVAL_RE = /Do you want to (proceed|make this edit to .+|create .+|overwrite .+)\??/;
 const BROAD_APPROVAL_RE = /Do you want to .+\?/;
+// File-operation prompts render only the diff above them — no "Write"/"Edit"
+// tool header. Derive the operation + target file from the prompt line itself so
+// the approver treats it as a normal Edit/Write instead of an "Unknown" shell
+// command that risk-scores the file's CODE CONTENT (and so never cleanly
+// auto-approves / mis-routes to the verifier).
+const FILE_OP_RE = /Do you want to (make this edit to|overwrite|create)\s+(.+?)\s*\??$/i;
+function deriveFileOpTool(proceedLine) {
+  const m = FILE_OP_RE.exec(String(proceedLine || ''));
+  if (!m) return null;
+  return {
+    toolName: /make this edit/i.test(m[1]) ? 'Edit' : 'Write',
+    command: m[2].trim(),
+  };
+}
 const YES_RE = /^\D*1\.\s*Yes\b/;
 const ESC_CANCEL_RE = /Esc to cancel/;
+// MCP tool-use prompts have no "Bash command"-style header; the tool identity
+// is the line ending in "(MCP)" (e.g. `plugin:playwright:playwright – Navigate
+// to a URL(url: "…") (MCP)`) or a raw `mcp__…` / `plugin:…` tool name.
+const MCP_TOOL_LINE_RE = /\(MCP\)\s*$/i;
+const MCP_TOOL_NAME_RE = /^(?:[⏺●]\s*)?(?:plugin:|mcp__)/i;
+
+// Reduce an MCP tool line to a stable tool name for rule-matching / display:
+// drop the leading bullet, the trailing "(MCP)", and the volatile "(args…)".
+function cleanMcpToolName(line) {
+  let s = String(line || '').trim().replace(/^[⏺●]\s*/, '');
+  s = s.replace(/\s*\(MCP\)\s*$/i, '');
+  const argIdx = s.indexOf('(');
+  if (argIdx > 0) s = s.slice(0, argIdx).trim();
+  return s || 'MCP tool';
+}
+const DURABLE_YES_OPTION_RE = /^\s*(?:[❯›▶▸>]\s*)?2\.\s*Yes,\s*(allow all|allow\b.*\b(?:for|from) this project\b|(?:and\s+)?allow\s+access\s+to\b.*\b(?:and\s+similar\s+commands|for\s+this\s+session)\b|and\s+allow\s+Claude\b.*\bthis\s+session\b|and don't ask again|and always allow)/i;
 
 module.exports = {
   id: 'claude-code',
   name: 'Claude Code',
+  deriveFileOpTool,
 
   detect(text) {
     const allLines = text.split('\n');
@@ -56,7 +87,7 @@ module.exports = {
     for (let i = proceedIdx - 1; i >= Math.max(proceedIdx - 3, 0); i--) {
       const line = lines[i];
       if (!line) continue;
-      if (/command contains|could write|could modify|could delete|could overwrite|which can|permission|dangerous|destructive|overwrite|will modify|will delete|will overwrite|execute arbitrary|shell command substitution/i.test(line)) {
+      if (/command contains|could write|could modify|could delete|could overwrite|which can|permission|dangerous|destructive|overwrite|will modify|will delete|will overwrite|execute arbitrary|executes commands|modifies files|cannot be auto-allowed|shell command substitution/i.test(line)) {
         warning = line;
         break;
       }
@@ -79,10 +110,27 @@ module.exports = {
         toolName = line.trim();
         break;
       }
+      // MCP tool-use prompt: capture the real tool name (no longer "Unknown") so
+      // the heuristic, learned rules, and "don't ask again" can target it. Keep
+      // the full descriptor (with args/URL) in the command for the reviewer.
+      if (MCP_TOOL_LINE_RE.test(line) || MCP_TOOL_NAME_RE.test(line)) {
+        toolName = cleanMcpToolName(line);
+        contextLines.unshift(line.trim());
+        break;
+      }
       contextLines.unshift(line);
     }
 
-    const command = contextLines.join('\n').trim();
+    // No tool header above the diff → this is one of Claude's file-operation
+    // prompts ("overwrite/create/make this edit to <file>?"). Use the operation
+    // and target file as tool/command so it auto-approves as a normal Edit/Write.
+    let fileOpCommand = '';
+    if (!toolName) {
+      const fileOp = deriveFileOpTool(lines[proceedIdx]);
+      if (fileOp) { toolName = fileOp.toolName; fileOpCommand = fileOp.command; }
+    }
+
+    const command = (fileOpCommand || contextLines.join('\n')).trim();
 
     const ctxStart = Math.max(0, endIdx - (contextLines.length + 1));
     const ctxEnd = Math.min(lines.length, proceedIdx + 5);
@@ -90,7 +138,7 @@ module.exports = {
 
     let hasAllowAll = false;
     for (let i = proceedIdx + 1; i < Math.min(proceedIdx + 8, lines.length); i++) {
-      if (/^\s*(?:[❯›▶▸>]\s*)?2\.\s*Yes,\s*(allow all|allow\b.*\b(?:for|from) this project\b|and don't ask again|and always allow)/i.test(lines[i])) { hasAllowAll = true; break; }
+      if (DURABLE_YES_OPTION_RE.test(lines[i])) { hasAllowAll = true; break; }
     }
 
     return {