devez-vibe 1.6.35 → 1.6.37

package/bridge/claude-agent-sdk-bridge.mjs

@@ -3,7 +3,7 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { createReadStream, existsSync, readdirSync } from "node:fs";
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createInterface } from "node:readline";
@@ -29,6 +29,7 @@ const modelCatalogs = new Map();
 const CLAUDE_MODEL_ORDER = ["fable", "opus", "sonnet", "haiku"];
 const OPUS_48_MODEL = "claude-opus-4-8";
 const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+const CLAUDE_TASK_TOOLS = ["TaskCreate", "TaskGet", "TaskUpdate", "TaskList"];
 let nextHostRequest = 1;
 
 class AsyncQueue {
@@ -575,6 +576,12 @@ function makeOptions(params, sessionId, resume) {
     },
     skills: "all",
     tools: { type: "preset", preset: "claude_code" },
+    // Task tools left the default surface in SDK 0.3.233. Listing them here
+    // keeps the plan panel available without replacing the Claude Code preset.
+    allowedTools: [...CLAUDE_TASK_TOOLS],
+    // DevezVibe keeps per-task controls available through Claude's TaskStop
+    // tool, so a turn interrupt must not tear down independent background work.
+    perTaskStopAffordance: true,
     systemPrompt: {
       type: "preset",
       preset: "claude_code",
@@ -662,6 +669,13 @@ async function requestToolPermission(toolName, input, permission) {
         return { behavior: "deny", message: questionFallbackMessage(questions) };
       }
     }
+    // Esc on the host cancels the question outright. Claude Code stops the turn
+    // there, so the tool must not be handed an empty answer set: that reads as a
+    // successful call and the model keeps talking about a question nobody
+    // answered. The host sends its own interrupt right behind this reply.
+    if (response?.cancelled) {
+      return { behavior: "deny", message: "사용자가 질문을 취소하고 작업을 중단했습니다." };
+    }
     const answers = {};
     for (let index = 0; index < questions.length; index += 1) {
       const selected = response?.answers?.[`q${index}`]?.answers;
@@ -1062,6 +1076,7 @@ async function createSession(params, resumeId) {
     subagents: new Map(),
     knownSubagents: new Map(),
     hiddenSubagentTasks: new Set(),
+    ambientSubagentTasks: new Set(),
     subagentPulse: null,
     lastContextUsage: null,
     lastContextWindow: 0,
@@ -1359,7 +1374,7 @@ function processAssistant(session, message) {
 function processToolUse(session, block) {
   const name = block.name || "Tool";
   const input = block.input || {};
-  if (name === "TaskCreate" || name === "TaskUpdate" || name === "TaskList") {
+  if (CLAUDE_TASK_TOOLS.includes(name)) {
     updatePlanFromToolUse(session, name, block.id, input);
     session.tools.set(block.id, { name, input, suppressed: true });
     return;
@@ -1689,7 +1704,8 @@ function upsertStructuredSubagent(session, message) {
   const taskId = firstLine(message.task_id || "", 80);
   const toolUseId = firstLine(message.tool_use_id || "", 80);
   const subagentType = firstLine(message.subagent_type || "", 40);
-  if (taskId && session.hiddenSubagentTasks?.has(taskId)) return null;
+  if (taskId && (session.hiddenSubagentTasks?.has(taskId)
+    || session.ambientSubagentTasks?.has(taskId))) return null;
   const byTool = toolUseId && findSubagent(session, toolUseId);
   const byTask = taskId && findSubagent(session, taskId);
   let running = byTool || byTask;
@@ -1743,7 +1759,13 @@ function upsertStructuredSubagent(session, message) {
 function finishStructuredSubagent(session, message, kind, text) {
   const taskId = firstLine(message.task_id || "", 80);
   const toolUseId = firstLine(message.tool_use_id || "", 80);
-  const wasHidden = taskId ? session.hiddenSubagentTasks?.delete(taskId) === true : false;
+  const wasTranscriptHidden = taskId
+    ? session.hiddenSubagentTasks?.delete(taskId) === true
+    : false;
+  const wasAmbient = taskId
+    ? session.ambientSubagentTasks?.delete(taskId) === true
+    : false;
+  const wasHidden = wasTranscriptHidden || wasAmbient;
   const running = (toolUseId && findSubagent(session, toolUseId))
     || (taskId && findSubagent(session, taskId));
   if (!running) return wasHidden;
@@ -1754,13 +1776,24 @@ function finishStructuredSubagent(session, message, kind, text) {
 }
 
 function syncBackgroundSubagents(session, tasks) {
-  const live = (Array.isArray(tasks) ? tasks : []).filter((task) => {
+  const snapshot = Array.isArray(tasks) ? tasks : [];
+  session.ambientSubagentTasks = new Set(snapshot
+    .filter((task) => task?.ambient === true)
+    .map((task) => firstLine(task?.task_id || "", 80))
+    .filter(Boolean));
+  const live = snapshot.filter((task) => {
     const taskId = firstLine(task?.task_id || "", 80);
-    return !taskId || !session.hiddenSubagentTasks?.has(taskId);
+    return task?.ambient !== true
+      && (!taskId || !session.hiddenSubagentTasks?.has(taskId));
   });
   const liveIds = new Set(live.map((task) => firstLine(task?.task_id || "", 80)).filter(Boolean));
   let changed = false;
   for (const [id, running] of session.subagents) {
+    if (running.taskId && session.ambientSubagentTasks.has(running.taskId)) {
+      session.subagents.delete(id);
+      changed = true;
+      continue;
+    }
     if (!running.background || !running.taskId || liveIds.has(running.taskId)) continue;
     session.subagents.delete(id);
     changed = true;
@@ -1799,12 +1832,14 @@ function syncBackgroundSubagents(session, tasks) {
 
 function processSubagentSystemMessage(session, message) {
   if (message.subtype === "task_started") {
-    if (message.skip_transcript === true) {
+    if (message.skip_transcript === true || message.ambient === true) {
       const taskId = firstLine(message.task_id || "", 80);
       const toolUseId = firstLine(message.tool_use_id || "", 80);
       if (taskId) {
-        session.hiddenSubagentTasks ||= new Set();
-        session.hiddenSubagentTasks.add(taskId);
+        const hidden = message.ambient === true
+          ? (session.ambientSubagentTasks ||= new Set())
+          : (session.hiddenSubagentTasks ||= new Set());
+        hidden.add(taskId);
       }
       const running = (toolUseId && findSubagent(session, toolUseId))
         || (taskId && findSubagent(session, taskId));
@@ -1853,6 +1888,10 @@ function processSubagentSystemMessage(session, message) {
     return true;
   }
   if (message.subtype === "task_notification") {
+    if (message.ambient === true && message.task_id) {
+      session.ambientSubagentTasks ||= new Set();
+      session.ambientSubagentTasks.add(firstLine(message.task_id, 80));
+    }
     const status = firstLine(message.status || "completed", 40);
     return finishStructuredSubagent(
       session,
@@ -1961,6 +2000,7 @@ function clearSubagents(session) {
   const changed = session.subagents.size > 0;
   session.subagents.clear();
   session.hiddenSubagentTasks?.clear();
+  session.ambientSubagentTasks?.clear();
   if (session.subagentPulse) {
     clearInterval(session.subagentPulse);
     session.subagentPulse = null;
@@ -2547,7 +2587,7 @@ function historyState(messages) {
             tasks.set(`pending:${block.id}`, { id: `pending:${block.id}`, subject: block.input?.subject || "작업", status: "pending", turnId: turn.id });
           } else if (block.name === "TaskUpdate") {
             applyTaskUpdate(tasks, block.input || {}, turn.id, undefined, messageTime(message));
-          } else if (!["TaskList", "AskUserQuestion"].includes(block.name)) turn.items.push(pending.item);
+          } else if (!["TaskGet", "TaskList", "AskUserQuestion"].includes(block.name)) turn.items.push(pending.item);
         }
       }
     } else if (message.type === "user") {
@@ -2685,6 +2725,98 @@ async function readableCwd(id, cwd) {
   return await transcriptCwd(id) || cwd;
 }
 
+function sameCwd(left, right) {
+  if (!left || !right) return !left && !right;
+  const normalize = (value) => value.replaceAll("\\", "/").replace(/\/$/, "");
+  const normalizedLeft = normalize(left);
+  const normalizedRight = normalize(right);
+  return process.platform === "win32"
+    ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+    : normalizedLeft === normalizedRight;
+}
+
+function transcriptPreview(messages) {
+  const prompt = historyTurns(messages)
+    .flatMap((turn) => turn.items || [])
+    .find((item) => item.type === "userMessage");
+  return prompt?.content?.find((item) => item.type === "text")?.text || "Untitled Claude session";
+}
+
+async function transcriptSessions(cwd) {
+  if (!cwd) return [];
+  let projects;
+  try {
+    projects = await readdir(claudeProjectsDir(), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const rows = new Map();
+  for (const project of projects) {
+    if (!project.isDirectory()) continue;
+    const dir = join(claudeProjectsDir(), project.name);
+    let files;
+    try {
+      files = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.isFile() || !/^[0-9a-f-]{36}\.jsonl$/i.test(file.name)) continue;
+      const path = join(dir, file.name);
+      let recordedCwd;
+      try {
+        recordedCwd = await readTranscriptCwd(path);
+      } catch {
+        continue;
+      }
+      if (!recordedCwd || (cwd && !sameCwd(recordedCwd, cwd))) continue;
+      const id = file.name.slice(0, -".jsonl".length);
+      try {
+        const [messages, metadata] = await Promise.all([
+          getSessionMessages(id, { dir: recordedCwd, includeSystemMessages: true }),
+          stat(path),
+        ]);
+        if (!messages.length) continue;
+        const row = {
+          id: visibleSession(id),
+          preview: transcriptPreview(messages),
+          cwd: recordedCwd,
+          updatedAt: Math.floor(metadata.mtimeMs / 1000),
+        };
+        const previous = rows.get(row.id);
+        if (!previous || row.updatedAt >= previous.updatedAt) rows.set(row.id, row);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return [...rows.values()];
+}
+
+async function claudeSessionList(params) {
+  const offset = params.offset || 0;
+  const limit = params.limit || 100;
+  const found = await listSessions({
+    dir: params.cwd,
+    limit: offset + limit,
+    offset: 0,
+    includeProgrammatic: true,
+  });
+  const rows = new Map(found.map((session) => [visibleSession(session.sessionId), {
+    id: visibleSession(session.sessionId),
+    name: session.customTitle || undefined,
+    preview: session.summary || session.firstPrompt || "Untitled Claude session",
+    cwd: session.cwd || params.cwd || "",
+    updatedAt: Math.floor((session.lastModified || 0) / 1000),
+  }]));
+  for (const row of await transcriptSessions(params.cwd)) {
+    if (!rows.has(row.id)) rows.set(row.id, row);
+  }
+  return [...rows.values()]
+    .sort((left, right) => right.updatedAt - left.updatedAt)
+    .slice(offset, offset + limit);
+}
+
 async function dispatch(method, params = {}) {
   if (method === "model/list") return loadModelCatalog(params);
   if (method === "mcpServerStatus/list") return claudeMcpStatus(params);
@@ -2844,20 +2976,8 @@ async function dispatch(method, params = {}) {
     };
   }
   if (method === "session/list") {
-    const found = await listSessions({
-      dir: params.cwd,
-      limit: params.limit || 100,
-      offset: params.offset || 0,
-      includeProgrammatic: true,
-    });
     return {
-      data: found.map((session) => ({
-        id: visibleSession(session.sessionId),
-        name: session.customTitle || undefined,
-        preview: session.summary || session.firstPrompt || "Untitled Claude session",
-        cwd: session.cwd || params.cwd || "",
-        updatedAt: Math.floor((session.lastModified || 0) / 1000),
-      })),
+      data: await claudeSessionList(params),
       nextCursor: null,
     };
   }
@@ -2939,10 +3059,36 @@ async function dispatch(method, params = {}) {
 }
 
 async function runSelfTest() {
+  const equivalentCwd = process.platform === "win32"
+    ? sameCwd("D:\\Repo", "d:/repo/")
+    : sameCwd("/tmp/repo", "/tmp/repo/");
+  const preview = transcriptPreview([{
+    type: "user",
+    uuid: "session-list-prompt",
+    message: { content: "세션 목록 질문" },
+  }]);
+  if (!equivalentCwd || preview !== "세션 목록 질문") {
+    throw new Error(`Claude session list self-test failed: ${JSON.stringify({ equivalentCwd, preview })}`);
+  }
   if (permissionMode("dontAsk") !== "dontAsk"
     || permissionMode("not-a-mode", "auto") !== "auto") {
     throw new Error("Claude permission mode self-test failed");
   }
+  const latestOptions = makeOptions({ cwd: process.cwd() }, "00000000-0000-4000-8000-000000000000");
+  if (latestOptions.perTaskStopAffordance !== true
+    || CLAUDE_TASK_TOOLS.some((tool) => !latestOptions.allowedTools.includes(tool))) {
+    throw new Error(`Claude latest SDK options self-test failed: ${JSON.stringify(latestOptions.allowedTools)}`);
+  }
+  const lookupSession = {
+    turn: { id: "task-get-turn" },
+    tools: new Map(),
+    tasks: new Map(),
+    planCreatePending: false,
+  };
+  processToolUse(lookupSession, { id: "task-get", name: "TaskGet", input: { taskId: "1" } });
+  if (lookupSession.tools.get("task-get")?.suppressed !== true) {
+    throw new Error("Claude TaskGet transcript suppression self-test failed");
+  }
   const pluginCatalog = buildClaudePluginCatalog(
     [{ id: "cloudflare@official", enabled: true, scope: "user" }],
     [{
@@ -3383,6 +3529,7 @@ async function runSelfTest() {
       subagents: new Map(),
       knownSubagents: new Map(),
       hiddenSubagentTasks: new Set(),
+      ambientSubagentTasks: new Set(),
       subagentPulse: null,
     };
     processSubagentSystemMessage(structuredSession, {
@@ -3504,6 +3651,42 @@ async function runSelfTest() {
       summary: "Hidden task finished",
     });
 
+    processSubagentSystemMessage(structuredSession, {
+      type: "system",
+      subtype: "task_started",
+      task_id: "agent-ambient",
+      tool_use_id: "toolu_ambient",
+      task_type: "agent",
+      subagent_type: "Explore",
+      description: "Refresh housekeeping",
+      ambient: true,
+    });
+    processSubagentSystemMessage(structuredSession, {
+      type: "system",
+      subtype: "background_tasks_changed",
+      tasks: [{
+        task_id: "agent-ambient",
+        task_type: "agent",
+        description: "Refresh housekeeping",
+        ambient: true,
+      }],
+    });
+    if (structuredSession.subagents.size !== 0
+      || !structuredSession.ambientSubagentTasks.has("agent-ambient")) {
+      throw new Error("Claude ambient task was shown as a subagent row");
+    }
+    processSubagentSystemMessage(structuredSession, {
+      type: "system",
+      subtype: "task_notification",
+      task_id: "agent-ambient",
+      status: "completed",
+      summary: "Ambient task finished",
+      ambient: true,
+    });
+    if (structuredSession.ambientSubagentTasks.size !== 0) {
+      throw new Error("Claude ambient task completion did not clear hidden state");
+    }
+
     processSubagentSystemMessage(structuredSession, {
       type: "system",
       subtype: "task_started",

package/package.json

@@ -1,41 +1,41 @@
-{
-  "name": "devez-vibe",
-  "version": "1.6.35",
-  "description": "Stable terminal UI for Codex and Claude Agent SDK",
-  "keywords": [
-    "codex",
-    "cli",
-    "tui",
-    "terminal",
-    "app-server",
-    "claude-agent-sdk"
-  ],
-  "homepage": "https://github.com/MrHoje/Devez-vibe#readme",
-  "bugs": "https://github.com/MrHoje/Devez-vibe/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MrHoje/Devez-vibe.git"
-  },
-  "license": "MIT",
-  "bin": {
-    "dvz": "bin/dvz.exe"
-  },
-  "files": [
-    "bin/dvz.exe",
-    "bridge/claude-agent-sdk-bridge.mjs",
-    "README.md",
-    "LICENSE"
-  ],
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.231"
-  }
-}
+{
+  "name": "devez-vibe",
+  "version": "1.6.37",
+  "description": "Stable terminal UI for Codex and Claude Agent SDK",
+  "keywords": [
+    "codex",
+    "cli",
+    "tui",
+    "terminal",
+    "app-server",
+    "claude-agent-sdk"
+  ],
+  "homepage": "https://github.com/MrHoje/Devez-vibe#readme",
+  "bugs": "https://github.com/MrHoje/Devez-vibe/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrHoje/Devez-vibe.git"
+  },
+  "license": "MIT",
+  "bin": {
+    "dvz": "bin/dvz.exe"
+  },
+  "files": [
+    "bin/dvz.exe",
+    "bridge/claude-agent-sdk-bridge.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.247"
+  }
+}