create-walle 0.9.13 → 0.9.15

package/template/claude-task-manager/db.js

@@ -2141,7 +2141,7 @@ function listSessionConversations({ search, limit, offset, hostname, allDevices
   }
   if (search) {
     sql += ' AND (title LIKE ? OR first_message LIKE ? OR project_path LIKE ? OR messages LIKE ?)';
-    const q = `%${search}%`;
+    const q = `%${normalizeSessionSearchValue(search) || search}%`;
     params.push(q, q, q, q);
   }
   sql += ' ORDER BY imported_at DESC';
@@ -2154,6 +2154,14 @@ function getSessionConversation(sessionId) {
   return getDb().prepare('SELECT * FROM session_conversations WHERE ctm_session_id = ?').get(sessionId);
 }
 
+function normalizeSessionSearchValue(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/(^|[\s([{])[$/]+(?=[a-z0-9_-])/g, '$1')
+    .replace(/\s+/g, ' ');
+}
+
 function updateSessionModel(sessionId, modelProvider, modelId) {
   getDb().prepare(
     'UPDATE session_conversations SET model_provider = ?, model_id = ? WHERE ctm_session_id = ?'
@@ -2215,10 +2223,25 @@ function checkpointWal(mode) {
   const m = (mode || 'PASSIVE').toUpperCase();
   if (!_VALID_CHECKPOINT_MODES.has(m)) return;
   try {
-    db.pragma(`wal_checkpoint(${m})`);
+    return db.pragma(`wal_checkpoint(${m})`);
   } catch {}
 }
 
+function checkpointWalOrThrow(mode) {
+  if (!db) throw new Error('Database not initialized');
+  const m = (mode || 'PASSIVE').toUpperCase();
+  if (!_VALID_CHECKPOINT_MODES.has(m)) throw new Error(`Invalid WAL checkpoint mode: ${mode}`);
+  const rows = db.pragma(`wal_checkpoint(${m})`);
+  const row = Array.isArray(rows) ? rows[0] : rows;
+  const busy = Number(row?.busy ?? row?.[0] ?? 0);
+  if (busy > 0) {
+    const log = row?.log ?? row?.[1] ?? 'unknown';
+    const checkpointed = row?.checkpointed ?? row?.[2] ?? 'unknown';
+    throw new Error(`WAL checkpoint ${m} could not complete: busy=${busy}, log=${log}, checkpointed=${checkpointed}`);
+  }
+  return rows;
+}
+
 // Gzip a .db file to .db.gz and remove the original.
 // Returns the actual output path (destPath if gzip succeeded, srcPath if it didn't).
 function _gzipBackup(srcPath, destPath) {
@@ -2234,41 +2257,12 @@ function _gzipBackup(srcPath, destPath) {
 }
 
 function createBackup(label) {
-  if (!db || !currentDbPath) throw new Error('Database not initialized');
-  checkpointWal('TRUNCATE');
-
-  const now = new Date();
-  const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
-  const tag = label ? `-${label.replace(/[^a-zA-Z0-9_-]/g, '')}` : '';
-  const tmpPath = path.join(BACKUP_DIR, `task-manager-${ts}${tag}.db`);
-  const backupName = `task-manager-${ts}${tag}.db.gz`;
-  const backupPath = path.join(BACKUP_DIR, backupName);
-
-  // Use SQLite backup API, then gzip
-  db.backup(tmpPath).then(() => {
-    _gzipBackup(tmpPath, backupPath);
-  }).catch(() => {
-    fs.copyFileSync(currentDbPath, tmpPath);
-    _gzipBackup(tmpPath, backupPath);
-  });
-
-  // Also copy images dir as a tarball if it has content
-  const imagesBackup = path.join(BACKUP_DIR, `images-${ts}${tag}.tar.gz`);
-  try {
-
-    const imageFiles = fs.readdirSync(DEFAULT_IMAGES_DIR);
-    if (imageFiles.length > 0) {
-      require('child_process').spawnSync('tar', ['-czf', imagesBackup, '-C', path.dirname(DEFAULT_IMAGES_DIR), path.basename(DEFAULT_IMAGES_DIR)], { timeout: 30000 });
-    }
-  } catch {}
-
-  cleanOldBackups();
-  return { backupName, backupPath, timestamp: now.toISOString() };
+  return createBackupSync(label);
 }
 
 function createBackupSync(label) {
   if (!db || !currentDbPath) throw new Error('Database not initialized');
-  checkpointWal('TRUNCATE');
+  checkpointWalOrThrow('TRUNCATE');
 
   const now = new Date();
   const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
@@ -2328,7 +2322,7 @@ function restoreBackup(backupName) {
   createBackupSync('pre-restore');
 
   // Close current DB
-  checkpointWal('TRUNCATE');
+  checkpointWalOrThrow('TRUNCATE');
   if (db) { db.close(); db = null; }
 
   // Decompress if needed, then copy over current DB
@@ -2874,7 +2868,7 @@ function updateStartupTaskBranch(sessionId, branch, worktreePath) {
 
 function updateStartupTaskCwd(sessionId, cwd) {
   getDb().prepare('UPDATE startup_tasks SET cwd = ?, worktree_path = ? WHERE ctm_session_id = ?')
-    .run(cwd || '', cwd && cwd.includes('.claude/worktrees/') ? cwd : null, sessionId);
+    .run(cwd || '', cwd && /\/\.(?:claude|walle)\/worktrees\//.test(cwd) ? cwd : null, sessionId);
   flushWal();
 }
 
@@ -3593,24 +3587,15 @@ function upsertSession(id, data, opts) {
   }
 
   const agentId = data.agentSessionId;
-
-  // Cross-tab claim guard: before writing agent_sessions, make sure this
-  // agent_session_id isn't already owned by a different CTM tab. This is the
-  // main defense against mass-spawn races where multiple relink paths compete.
-  if (agentId && agentId !== '__CLEAR__' && !allowReclaim) {
-    const existing = d.prepare(
-      'SELECT ctm_session_id FROM agent_sessions WHERE agent_session_id = ?'
-    ).get(agentId);
-    if (existing && existing.ctm_session_id && existing.ctm_session_id !== id) {
-      const err = new Error(
-        `agent_session_id ${agentId} is already claimed by ctm_session ${existing.ctm_session_id} (refusing cross-tab claim for ${id})`
-      );
-      err.code = 'E_CROSS_TAB_CLAIM';
-      err.existingCtmSessionId = existing.ctm_session_id;
-      err.attemptedCtmSessionId = id;
-      err.agentSessionId = agentId;
-      throw err;
-    }
+  function throwCrossTabClaim(existingCtmSessionId) {
+    const err = new Error(
+      `agent_session_id ${agentId} is already claimed by ctm_session ${existingCtmSessionId} (refusing cross-tab claim for ${id})`
+    );
+    err.code = 'E_CROSS_TAB_CLAIM';
+    err.existingCtmSessionId = existingCtmSessionId;
+    err.attemptedCtmSessionId = id;
+    err.agentSessionId = agentId;
+    throw err;
   }
   const ctmParams = {
     id,
@@ -3636,6 +3621,7 @@ function upsertSession(id, data, opts) {
     git_branch: data.gitBranch || '',
     user_msg_count: data.userMsgCount || 0,
     slug: data.slug || '',
+    allow_reclaim: allowReclaim ? 1 : 0,
   } : null;
 
   // Wrap both upserts in a transaction to keep ctm_sessions + agent_sessions atomic
@@ -3656,13 +3642,21 @@ function upsertSession(id, data, opts) {
 
     // If agent session data provided, upsert agent_sessions
     if (agentParams) {
-      d.prepare(`
+      if (!allowReclaim) {
+        const existing = d.prepare(
+          'SELECT ctm_session_id FROM agent_sessions WHERE agent_session_id = ?'
+        ).get(agentId);
+        if (existing && existing.ctm_session_id && existing.ctm_session_id !== id) {
+          throwCrossTabClaim(existing.ctm_session_id);
+        }
+      }
+      const result = d.prepare(`
         INSERT INTO agent_sessions (agent_session_id, ctm_session_id, provider, project_path, jsonl_path,
           first_message, file_size, modified_at, hostname, model, git_branch, user_msg_count, slug)
         VALUES (@agent_session_id, @ctm_session_id, @provider, @project_path, @jsonl_path,
           @first_message, @file_size, @modified_at, @hostname, @model, @git_branch, @user_msg_count, @slug)
         ON CONFLICT(agent_session_id) DO UPDATE SET
-          ctm_session_id = COALESCE(NULLIF(excluded.ctm_session_id, ''), agent_sessions.ctm_session_id),
+          ctm_session_id = excluded.ctm_session_id,
           provider = COALESCE(NULLIF(excluded.provider, ''), agent_sessions.provider),
           project_path = COALESCE(NULLIF(excluded.project_path, ''), agent_sessions.project_path),
           jsonl_path = COALESCE(NULLIF(excluded.jsonl_path, ''), agent_sessions.jsonl_path),
@@ -3675,10 +3669,20 @@ function upsertSession(id, data, opts) {
           user_msg_count = CASE WHEN excluded.user_msg_count > 0 THEN excluded.user_msg_count ELSE agent_sessions.user_msg_count END,
           slug = COALESCE(NULLIF(excluded.slug, ''), agent_sessions.slug),
           updated_at = datetime('now')
+        WHERE @allow_reclaim = 1
+           OR agent_sessions.ctm_session_id IS NULL
+           OR agent_sessions.ctm_session_id = excluded.ctm_session_id
       `).run(agentParams);
+      if (!allowReclaim && result.changes === 0) {
+        const existing = d.prepare(
+          'SELECT ctm_session_id FROM agent_sessions WHERE agent_session_id = ?'
+        ).get(agentId);
+        throwCrossTabClaim(existing?.ctm_session_id || 'unknown');
+      }
     }
   });
-  txn();
+  if (typeof txn.immediate === 'function') txn.immediate();
+  else txn();
 }
 
 function setSessionStar(id, starred) {
@@ -3757,13 +3761,17 @@ function getSessionTitleNew(id) {
 function getAllSessionsData() {
   return getDb().prepare(`
     SELECT c.*, a.agent_session_id, a.jsonl_path, a.first_message, a.file_size,
-      a.modified_at, a.hostname, a.model, a.git_branch, a.user_msg_count,
-      a.last_user_content, a.first_assistant_text, a.rename_name
+      a.modified_at, a.hostname, a.model, a.git_branch,
+      MAX(COALESCE(a.user_msg_count, 0), COALESCE(sc.user_msg_count, 0)) as user_msg_count,
+      COALESCE(NULLIF(a.last_user_content, ''), sc.last_user_content) as last_user_content,
+      COALESCE(NULLIF(a.first_assistant_text, ''), sc.first_assistant_text) as first_assistant_text,
+      COALESCE(NULLIF(a.rename_name, ''), sc.rename_name) as rename_name
     FROM ctm_sessions c
     LEFT JOIN (
       SELECT *, ROW_NUMBER() OVER (PARTITION BY ctm_session_id ORDER BY modified_at DESC, created_at DESC) as rn
       FROM agent_sessions
     ) a ON a.ctm_session_id = c.id AND a.rn = 1
+    LEFT JOIN session_conversations sc ON sc.ctm_session_id = a.agent_session_id
   `).all();
 }
 
@@ -3789,22 +3797,33 @@ function getAgentSession(agentSessionId) {
  */
 function deleteCtmSession(ctmSessionId) {
   const d = getDb();
-  // Collect JSONL paths before delete (for disk cleanup)
-  const agentRows = d.prepare('SELECT jsonl_path FROM agent_sessions WHERE ctm_session_id = ?').all(ctmSessionId);
-  const jsonlPaths = agentRows.map(r => r.jsonl_path).filter(Boolean);
-
-  // CASCADE delete: deleting from ctm_sessions cascades to agent_sessions
-  d.prepare('DELETE FROM ctm_sessions WHERE id = ?').run(ctmSessionId);
-
-  // Also clean up other child tables (these don't have FK constraints)
-  try { d.prepare('DELETE FROM startup_tasks WHERE ctm_session_id = ?').run(ctmSessionId); } catch (e) { console.error('[db] deleteSession startup_tasks cleanup:', e.message); }
-  try { d.prepare('DELETE FROM scrollback_log WHERE ctm_session_id = ?').run(ctmSessionId); } catch (e) { console.error('[db] deleteSession scrollback_log cleanup:', e.message); }
-  try { d.prepare('DELETE FROM session_conversations WHERE ctm_session_id = ?').run(ctmSessionId); } catch (e) { console.error('[db] deleteSession session_conversations cleanup:', e.message); }
-  try { d.prepare('DELETE FROM session_messages WHERE ctm_session_id = ?').run(ctmSessionId); } catch (e) { console.error('[db] deleteSession session_messages cleanup:', e.message); }
-  try { d.prepare('DELETE FROM session_analyses WHERE ctm_session_id = ?').run(ctmSessionId); } catch (e) { console.error('[db] deleteSession session_analyses cleanup:', e.message); }
-  try { d.prepare('DELETE FROM prompt_queues WHERE ctm_session_id = ?').run(ctmSessionId); } catch (e) { console.error('[db] deleteSession prompt_queues cleanup:', e.message); }
-
-  return jsonlPaths;
+  const cleanupTables = [
+    ['startup_tasks', 'ctm_session_id'],
+    ['scrollback_log', 'ctm_session_id'],
+    ['session_conversations', 'ctm_session_id'],
+    ['session_messages', 'ctm_session_id'],
+    ['session_analyses', 'ctm_session_id'],
+    ['prompt_queues', 'ctm_session_id'],
+  ];
+  const txn = d.transaction(() => {
+    // Collect JSONL paths before delete (for disk cleanup)
+    const agentRows = d.prepare('SELECT jsonl_path FROM agent_sessions WHERE ctm_session_id = ?').all(ctmSessionId);
+    const jsonlPaths = agentRows.map(r => r.jsonl_path).filter(Boolean);
+
+    // Also clean up child tables without FK constraints before the parent row is removed.
+    for (const [table, idColumn] of cleanupTables) {
+      const exists = d.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name = ?").get(table);
+      if (!exists) continue;
+      const cols = d.prepare(`PRAGMA table_info(${table})`).all().map(c => c.name);
+      const column = cols.includes(idColumn) ? idColumn : (cols.includes('session_id') ? 'session_id' : null);
+      if (column) d.prepare(`DELETE FROM ${table} WHERE ${column} = ?`).run(ctmSessionId);
+    }
+
+    // CASCADE delete: deleting from ctm_sessions cascades to agent_sessions.
+    d.prepare('DELETE FROM ctm_sessions WHERE id = ?').run(ctmSessionId);
+    return jsonlPaths;
+  });
+  return txn();
 }
 
 // Legacy compatibility: upsertSessionIndex is now a no-op (session_index dropped)
@@ -3833,7 +3852,7 @@ module.exports = {
   getSessionTitle, setSessionTitle, isSessionUserRenamed, getAllSessionTitles,
   createTemplate, listTemplates, getTemplate, deleteTemplate,
   trackPromptUsage, getPromptUsageStats,
-  checkpointWal, createBackup, createBackupSync, listBackups, restoreBackup, deleteBackup, startDailyBackup,
+  checkpointWal, checkpointWalOrThrow, createBackup, createBackupSync, listBackups, restoreBackup, deleteBackup, startDailyBackup,
   saveQueue, loadQueue, loadAllQueues, deleteQueueDb,
   listPermRules, addPermRule, removePermRule, bulkSetPermRules, getPermRulesByProject,
   listAutoApprovals, upsertAutoApproval, toggleAutoApproval, deleteAutoApproval, getEnabledAutoApprovals,

package/template/claude-task-manager/docs/session-standup-command-center-design.md

@@ -0,0 +1,242 @@
+# Session Standup Command Center Design
+
+## Problem
+
+CTM already supports many long-lived sessions, but the operator cost rises when
+multiple agents are active at once. Each terminal has its own context, and a new
+session does not inherit the hard-won context from an existing one. Reusing
+sessions is therefore necessary, but reuse creates a second problem: the user
+must remember what every session is doing, whether it is blocked, and what the
+next useful instruction should be.
+
+The Standup Command Center is a central dashboard for that operating loop. It is
+not a replacement for session terminals. It is a "manager view" over existing
+sessions that answers:
+
+- What is every active session doing?
+- Which sessions need the user's attention?
+- Which sessions are ready to review or finish?
+- What should the user do next for each session?
+- How can the user quickly deep dive and issue instructions without losing the
+  fleet-level view?
+
+## Research Signals
+
+Open-source projects validate the need for a control-plane style UI, but CTM
+should borrow the operating patterns rather than replatforming the runtime.
+
+- Mission Control positions itself as an open-source dashboard for agent fleets,
+  tasks, costs, workflows, logs, memory, alerts, and quality gates:
+  https://github.com/builderz-labs/mission-control
+- AutoGen Studio shows that multi-agent debugging benefits from explicit
+  sessions, observable messages, metrics, and reusable agent components, but it
+  is framed as a prototyping UI rather than a production app:
+  https://autogenhub.github.io/autogen/blog/2023/12/01/AutoGenStudio/
+- OpenHands exposes a local GUI, REST API, CLI-compatible coding-agent workflow,
+  and cloud/enterprise surfaces for scaling coding agents:
+  https://github.com/OpenHands/OpenHands
+- LangGraph's product framing emphasizes human-in-the-loop checks, persistent
+  memory, and streaming as first-class agent UX primitives:
+  https://www.langchain.com/langgraph
+
+The design conclusion for CTM: do not add a manager-of-managers orchestration
+runtime. CTM already has terminals, stream capture, recent-session history,
+worktree state, approval detection, and review panels. The right abstraction is
+a reusable dashboard projection over those signals, with deterministic manager
+recommendations first and optional LLM annotations later.
+
+## Existing CTM Substrate
+
+The feature should reuse these existing surfaces:
+
+- `lib/session-stream.js`: summary, intent, progress, last prompt, stream status.
+- `lib/status-hooks.js`: idle, busy, and waiting-input state transitions.
+- `server.js` session payloads: active sessions, provider, cwd, branch, modified
+  time, capabilities, and worktree status.
+- `/api/recent-sessions`: historical sessions and project filtering.
+- `/api/stream/status` and `/api/sessions/:id/summary`: stream health and
+  per-session summary.
+- Review tab and session deep links: structured transcript and review flows.
+
+## UX Model
+
+The first screen in CTM Sessions should become the operator dashboard when no
+terminal is selected. The dashboard is dense, operational, and scannable. It is
+closer to a standup board than a marketing landing page.
+
+Primary regions:
+
+1. Fleet header
+   - Total active sessions.
+   - Counts by lane.
+   - Last refresh time.
+   - Refresh action.
+   - New Session action.
+
+2. Attention ribbon
+   - Highest priority sessions needing input or approval.
+   - Shows only the action needed and evidence.
+   - Lets the user open the session directly.
+
+3. Lanes
+   - Needs User: approvals, questions, waiting input, or explicit blockers.
+   - Ready Review: worktree changes, completed work, or reviewable artifacts.
+   - Running: active output or recent work.
+   - Continue Later: idle, stale, or context-preserving sessions.
+
+4. Session card
+   - Title and agent/provider.
+   - State badge and age.
+   - Intent: one-line goal.
+   - Progress: one-line latest progress.
+   - Manager recommendation: what the user should do next.
+   - Evidence chips: waiting input, branch, worktree, last prompt, last activity.
+   - Actions: Open, Review when supported, and Send Instruction when a terminal
+     target is available.
+
+5. Deep dive behavior
+   - Open keeps the user's mental model simple: jump into the session terminal.
+   - Review opens the transcript/review panel when the agent supports it.
+   - Send Instruction targets the existing prompt/queue mechanism in a later
+     phase; the first implementation can focus the session and preserve the
+     command center as the resume surface.
+
+## Manager Recommendation Taxonomy
+
+Recommendations must be conservative and explainable. They should be derived
+from existing signals and include evidence. They should never claim certainty
+from weak heuristics.
+
+Recommended action kinds:
+
+- `approval_needed`: approve, deny, or answer a tool prompt.
+- `needs_input`: user instruction appears required.
+- `review`: inspect completed work or worktree changes.
+- `watch`: session is running; no action needed right now.
+- `resume`: session is idle but can continue with more instruction.
+- `investigate`: session appears failed or blocked.
+- `archive`: work appears complete and inactive.
+
+Lane priority:
+
+1. Failed or blocked signals.
+2. Waiting input or approval.
+3. Reviewable worktree/session output.
+4. Running or recently active sessions.
+5. Idle or stale sessions.
+
+Each recommendation includes:
+
+- `lane`: where it appears on the board.
+- `actionKind`: stable machine-readable action.
+- `actionLabel`: short CTA text.
+- `recommendation`: short human-readable manager note.
+- `confidence`: `high`, `medium`, or `low`.
+- `evidence`: short strings tied to concrete signals.
+
+## API Contract
+
+Add `GET /api/sessions/standup`.
+
+Response shape:
+
+```json
+{
+  "generatedAt": "2026-04-30T12:00:00.000Z",
+  "counts": {
+    "total": 3,
+    "needs_user": 1,
+    "ready_review": 1,
+    "running": 1,
+    "continue_later": 0
+  },
+  "lanes": [
+    {
+      "id": "needs_user",
+      "title": "Needs User",
+      "sessions": []
+    }
+  ],
+  "sessions": [
+    {
+      "id": "ctm-session-id",
+      "agentSessionId": "agent-session-id",
+      "title": "Fix build failure",
+      "agent": "codex",
+      "provider": "openai",
+      "cwd": "/repo",
+      "branch": "fix-build",
+      "status": "waiting_input",
+      "lane": "needs_user",
+      "actionKind": "approval_needed",
+      "actionLabel": "Respond",
+      "recommendation": "Approval or input is waiting in the terminal.",
+      "confidence": "high",
+      "evidence": ["waiting_input", "last activity 2m ago"],
+      "intent": "Fix build failure",
+      "progress": "Waiting for command approval",
+      "lastActivity": "2026-04-30T11:58:00.000Z",
+      "worktree": {
+        "branch": "fix-build",
+        "dirtyFiles": 2,
+        "unmergedCommits": 1
+      },
+      "capabilities": {
+        "review": true,
+        "resume": true
+      }
+    }
+  ]
+}
+```
+
+The endpoint should be pure projection logic over active sessions first. Recent
+sessions can be added as a later extension once the active-session dashboard is
+stable.
+
+## Implementation Phases
+
+Phase 1: Design document
+
+- Commit this design.
+
+Phase 2: Backend projection
+
+- Add a pure `lib/session-standup.js` module.
+- Classify sessions into lanes and recommendations.
+- Add unit tests for the classifier and snapshot builder.
+- Add `GET /api/sessions/standup`.
+
+Phase 3: Dashboard UI
+
+- Replace the empty Sessions welcome panel with the Standup Command Center.
+- Fetch `/api/sessions/standup`.
+- Render fleet header, attention ribbon, lanes, cards, and actions.
+- Keep the UI within the existing CTM visual language: compact, dark,
+  terminal-adjacent, and operational.
+
+Phase 4: Verification and polish
+
+- Run focused unit tests.
+- Run an isolated CTM dev server on random ports, never the primary 3456/3457.
+- Curl the new API.
+- Drive the dashboard in a real browser and confirm it renders without layout
+  overlap or blank states.
+
+Future phase: Manager annotations
+
+- Add optional LLM-generated manager notes only after deterministic
+  recommendations are useful.
+- Store annotation provenance and age.
+- Do not let the LLM issue autonomous cross-session commands; it can propose
+  actions, not execute them.
+
+## Open Questions
+
+- Should historical/recent sessions appear on the same board or in a secondary
+  "Resume Later" view?
+- Should Send Instruction fan out to multiple sessions, or should the first
+  version stay one-session-at-a-time?
+- Should manager annotations be cached per session turn, per stream summary, or
+  per dashboard refresh?
+