very-happy-cli 0.2.90 → 0.2.91

package/dist/{types-DS3i_5LV.mjs → types-BKyjG23_.mjs}

@@ -29,7 +29,7 @@ import { SandboxManager } from '@anthropic-ai/sandbox-runtime';
 import { Expo } from 'expo-server-sdk';
 
 var name = "very-happy-cli";
-var version = "0.2.90";
+var version = "0.2.91";
 var description = "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.";
 var author = "Kirill Dubovitskiy";
 var contributors = [
@@ -142,12 +142,12 @@ var dependencies = {
 	zod: "^4.0.0"
 };
 var optionalDependencies = {
-	"very-happy-tools-arm64-darwin": "0.2.90",
-	"very-happy-tools-x64-darwin": "0.2.90",
-	"very-happy-tools-arm64-linux": "0.2.90",
-	"very-happy-tools-x64-linux": "0.2.90",
-	"very-happy-tools-arm64-win32": "0.2.90",
-	"very-happy-tools-x64-win32": "0.2.90"
+	"very-happy-tools-arm64-darwin": "0.2.91",
+	"very-happy-tools-x64-darwin": "0.2.91",
+	"very-happy-tools-arm64-linux": "0.2.91",
+	"very-happy-tools-x64-linux": "0.2.91",
+	"very-happy-tools-arm64-win32": "0.2.91",
+	"very-happy-tools-x64-win32": "0.2.91"
 };
 var devDependencies = {
 	"@slopus/happy-wire": "workspace:*",
@@ -639,9 +639,27 @@ const sessionToolCallStartEventSchema = z.object({
   description: z.string(),
   args: z.record(z.string(), z.unknown())
 });
+const sessionSubagentResultSchema = z.object({
+  text: z.string(),
+  truncated: z.boolean().optional()
+});
+const sessionSubagentUsageSchema = z.object({
+  toolUses: z.number().optional(),
+  totalTokens: z.number().optional(),
+  durationMs: z.number().optional()
+});
 const sessionToolCallEndEventSchema = z.object({
   t: z.literal("tool-call-end"),
-  call: z.string()
+  call: z.string(),
+  // Foreground Agent/Task completion: the sub-agent's final report + run
+  // totals (SDK `tool_use_result`). Absent for ordinary tools and for the
+  // background stub ("Async agent launched").
+  result: sessionSubagentResultSchema.extend({
+    isError: z.boolean().optional(),
+    stats: sessionSubagentUsageSchema.extend({
+      toolStats: z.record(z.string(), z.unknown()).optional()
+    }).optional()
+  }).optional()
 });
 const sessionFileEventSchema = z.object({
   t: z.literal("file"),
@@ -660,7 +678,10 @@ const sessionTurnStartEventSchema = z.object({
 });
 const sessionStartEventSchema = z.object({
   t: z.literal("start"),
-  title: z.string().optional()
+  title: z.string().optional(),
+  // B-260-P2: identity from SDK task_started / Agent tool input.
+  description: z.string().optional(),
+  subagentType: z.string().optional()
 });
 const sessionTurnEndStatusSchema = z.enum(["completed", "failed", "cancelled"]);
 const sessionTurnUsageSchema = z.object({
@@ -683,7 +704,21 @@ const sessionTurnEndEventSchema = z.object({
   usage: sessionTurnUsageSchema.optional()
 });
 const sessionStopEventSchema = z.object({
-  t: z.literal("stop")
+  t: z.literal("stop"),
+  // B-260-P2: from SDK task_notification. A second `stop` for the same
+  // subagent may follow carrying `result` once the notification user message
+  // (which holds the <result> block) arrives; consumers fold by subagent id.
+  status: z.enum(["completed", "failed", "stopped"]).optional(),
+  result: sessionSubagentResultSchema.optional(),
+  usage: sessionSubagentUsageSchema.optional()
+});
+const sessionProgressEventSchema = z.object({
+  t: z.literal("progress"),
+  toolUses: z.number(),
+  lastTool: z.string().optional(),
+  totalTokens: z.number().optional(),
+  durationMs: z.number().optional(),
+  summary: z.string().optional()
 });
 const sessionEventSchema = z.discriminatedUnion("t", [
   sessionTextEventSchema,
@@ -694,7 +729,8 @@ const sessionEventSchema = z.discriminatedUnion("t", [
   sessionTurnStartEventSchema,
   sessionStartEventSchema,
   sessionTurnEndEventSchema,
-  sessionStopEventSchema
+  sessionStopEventSchema,
+  sessionProgressEventSchema
 ]);
 const sessionEnvelopeSchema = z.object({
   id: z.string(),
@@ -725,7 +761,14 @@ const sessionEnvelopeSchema = z.object({
       path: ["role"]
     });
   }
-  if ((envelope.ev.t === "start" || envelope.ev.t === "stop") && envelope.role !== "agent") {
+  if (envelope.ev.t === "progress" && !envelope.subagent) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "progress events must carry a subagent",
+      path: ["subagent"]
+    });
+  }
+  if ((envelope.ev.t === "start" || envelope.ev.t === "stop" || envelope.ev.t === "progress") && envelope.role !== "agent") {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
       message: `${envelope.ev.t} events must use role "agent"`,
@@ -2149,6 +2192,69 @@ function shouldReconnect() {
   return true;
 }
 
+const SUBAGENT_RESULT_MAX_CHARS = 16384;
+const SUBAGENT_PROGRESS_MIN_INTERVAL_MS = 5e3;
+function capSubagentText(text, max = SUBAGENT_RESULT_MAX_CHARS) {
+  const trimmed = text.trim();
+  if (trimmed.length <= max) return { text: trimmed };
+  return { text: trimmed.slice(0, max), truncated: true };
+}
+function toolUseResultToText(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return null;
+  const content = toolUseResult.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function toolUseResultStatus(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return "unknown";
+  const status = toolUseResult.status;
+  if (status === "async_launched") return "async_launched";
+  if (status === "completed") return "completed";
+  return "unknown";
+}
+function toolUseResultStats(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return void 0;
+  const r = toolUseResult;
+  const stats = {};
+  if (typeof r.totalToolUseCount === "number") stats.toolUses = r.totalToolUseCount;
+  if (typeof r.totalTokens === "number") stats.totalTokens = r.totalTokens;
+  if (typeof r.totalDurationMs === "number") stats.durationMs = r.totalDurationMs;
+  if (r.toolStats && typeof r.toolStats === "object") stats.toolStats = r.toolStats;
+  return Object.keys(stats).length > 0 ? stats : void 0;
+}
+function parseTaskNotificationText(text) {
+  if (!/<task-notification>/i.test(text)) return null;
+  const pick = (tag) => text.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, "i"))?.[1] ?? null;
+  const rawStatus = pick("status")?.trim().toLowerCase() ?? null;
+  const status = rawStatus === "completed" || rawStatus === "failed" || rawStatus === "stopped" ? rawStatus : null;
+  let resultText = pick("result");
+  let result = null;
+  if (resultText !== null) {
+    resultText = resultText.replace(/^\s*\[harness:[^\]]*\]\s*/i, "").replace(/<usage>[\s\S]*?<\/usage>/gi, "").trim();
+    if (resultText.length > 0) result = capSubagentText(resultText);
+  }
+  return {
+    toolUseId: pick("tool-use-id")?.trim() || null,
+    taskId: pick("task-id")?.trim() || null,
+    status,
+    summary: pick("summary")?.trim() || null,
+    result
+  };
+}
+function shouldEmitProgress(previous, toolUses, now) {
+  if (!previous) return true;
+  if (previous.lastToolUses === toolUses) return false;
+  return now - previous.lastAt >= SUBAGENT_PROGRESS_MIN_INTERVAL_MS;
+}
+
+const SUBAGENT_BUFFER_MAX_MESSAGES = 100;
 function isSubagentTool(name) {
   return name === "Task" || name === "Agent";
 }
@@ -2217,6 +2323,7 @@ function bufferSubagentMessage(state, subagent, message) {
   const buffer = getBufferedSubagentMessages(state);
   const queue = buffer.get(subagent) ?? [];
   queue.push(message);
+  while (queue.length > SUBAGENT_BUFFER_MAX_MESSAGES) queue.shift();
   buffer.set(subagent, queue);
 }
 function consumeBufferedSubagentMessages(state, subagent) {
@@ -2237,6 +2344,31 @@ function getActiveSubagents(state) {
   }
   return state.activeSubagents;
 }
+function getAgentToolCalls(state) {
+  if (!state.agentToolCalls) state.agentToolCalls = /* @__PURE__ */ new Set();
+  return state.agentToolCalls;
+}
+function getSubagentMeta(state) {
+  if (!state.subagentMeta) state.subagentMeta = /* @__PURE__ */ new Map();
+  return state.subagentMeta;
+}
+function getStubSubagents(state) {
+  if (!state.stubSubagents) state.stubSubagents = /* @__PURE__ */ new Set();
+  return state.stubSubagents;
+}
+function getProgressThrottle(state) {
+  if (!state.progressThrottle) state.progressThrottle = /* @__PURE__ */ new Map();
+  return state.progressThrottle;
+}
+function nowOf(state) {
+  return state.now ? state.now() : Date.now();
+}
+function rememberSubagentMeta(state, subagent, meta) {
+  const existing = getSubagentMeta(state).get(subagent) ?? {};
+  const description = typeof meta.description === "string" && meta.description.trim() ? meta.description.trim() : existing.description;
+  const subagentType = typeof meta.subagentType === "string" && meta.subagentType.trim() ? meta.subagentType.trim() : existing.subagentType;
+  getSubagentMeta(state).set(subagent, { ...description ? { description } : {}, ...subagentType ? { subagentType } : {} });
+}
 function pickAssistantUsage(message) {
   if (message.type !== "assistant") return void 0;
   const usage = message.message?.usage;
@@ -2413,13 +2545,26 @@ function maybeEmitSubagentStart(state, turn, subagent, envelopes) {
     return;
   }
   const title = getSubagentTitles(state).get(subagent);
+  const meta = getSubagentMeta(state).get(subagent);
   envelopes.push(createEnvelope("agent", {
     t: "start",
-    ...title ? { title } : {}
+    ...title ? { title } : {},
+    ...meta?.description ? { description: meta.description } : {},
+    ...meta?.subagentType ? { subagentType: meta.subagentType } : {}
   }, { turn, subagent }));
   started.add(subagent);
   getActiveSubagents(state).add(subagent);
 }
+function emitSubagentStopWithStatus(state, turn, subagent, envelopes, payload) {
+  envelopes.push(createEnvelope("agent", {
+    t: "stop",
+    ...payload.status ? { status: payload.status } : {},
+    ...payload.result ? { result: payload.result } : {},
+    ...payload.usage ? { usage: payload.usage } : {}
+  }, { ...turn ? { turn } : {}, subagent }));
+  getActiveSubagents(state).delete(subagent);
+  getStartedSubagents(state).delete(subagent);
+}
 function maybeEmitSubagentStop(state, turn, subagent, envelopes) {
   const active = getActiveSubagents(state);
   if (!active.has(subagent)) {
@@ -2431,8 +2576,6 @@ function maybeEmitSubagentStop(state, turn, subagent, envelopes) {
 function clearSubagentTracking(state) {
   getUuidToProviderSubagent(state).clear();
   getTaskPromptToSubagents(state).clear();
-  getProviderSubagentToSessionSubagent(state).clear();
-  getSubagentTitles(state).clear();
   getBufferedSubagentMessages(state).clear();
   getHiddenParentToolCalls(state).clear();
   getStartedSubagents(state).clear();
@@ -2493,6 +2636,58 @@ function closeClaudeTurnWithStatus(state, status, meta) {
 function mapClaudeLogMessageToSessionEnvelopes(message, state) {
   return mapClaudeLogMessageToSessionEnvelopesInternal(message, state);
 }
+function mapTaskLifecycleSystemMessage(message, state, envelopes) {
+  const raw = message;
+  const subtype = typeof raw.subtype === "string" ? raw.subtype : "";
+  if (!subtype.startsWith("task_")) return;
+  if (raw.skip_transcript === true) return;
+  const toolUseId = typeof raw.tool_use_id === "string" && raw.tool_use_id.length > 0 ? raw.tool_use_id : null;
+  if (!toolUseId || !getAgentToolCalls(state).has(toolUseId)) return;
+  const subagent = ensureSessionSubagentIdForProviderSubagent(state, toolUseId);
+  const usage = raw.usage && typeof raw.usage === "object" ? {
+    ...typeof raw.usage.tool_uses === "number" ? { toolUses: raw.usage.tool_uses } : {},
+    ...typeof raw.usage.total_tokens === "number" ? { totalTokens: raw.usage.total_tokens } : {},
+    ...typeof raw.usage.duration_ms === "number" ? { durationMs: raw.usage.duration_ms } : {}
+  } : void 0;
+  if (subtype === "task_started") {
+    rememberSubagentMeta(state, subagent, { description: raw.description, subagentType: raw.subagent_type });
+    const turn = ensureTurn(state, envelopes);
+    getStartedSubagents(state).delete(subagent);
+    maybeEmitSubagentStart(state, turn, subagent, envelopes);
+    return;
+  }
+  if (subtype === "task_progress") {
+    const toolUses = typeof raw.usage?.tool_uses === "number" ? raw.usage.tool_uses : 0;
+    const throttle = getProgressThrottle(state);
+    const now = nowOf(state);
+    if (!shouldEmitProgress(throttle.get(subagent), toolUses, now)) return;
+    throttle.set(subagent, { lastAt: now, lastToolUses: toolUses });
+    const turn = ensureTurn(state, envelopes);
+    maybeEmitSubagentStart(state, turn, subagent, envelopes);
+    envelopes.push(createEnvelope("agent", {
+      t: "progress",
+      toolUses,
+      ...typeof raw.last_tool_name === "string" && raw.last_tool_name ? { lastTool: raw.last_tool_name } : {},
+      ...usage?.totalTokens !== void 0 ? { totalTokens: usage.totalTokens } : {},
+      ...usage?.durationMs !== void 0 ? { durationMs: usage.durationMs } : {},
+      ...typeof raw.summary === "string" && raw.summary.trim() ? { summary: raw.summary.trim() } : {}
+    }, { turn, subagent }));
+    return;
+  }
+  if (subtype === "task_notification") {
+    const status = raw.status === "completed" || raw.status === "failed" || raw.status === "stopped" ? raw.status : "completed";
+    emitSubagentStopWithStatus(state, state.currentTurnId ?? void 0, subagent, envelopes, {
+      status,
+      ...usage ? { usage } : {}
+    });
+    getStubSubagents(state).delete(subagent);
+    getProgressThrottle(state).delete(subagent);
+    return;
+  }
+  if (subtype === "task_updated" && raw.patch?.is_backgrounded === true) {
+    getStubSubagents(state).add(subagent);
+  }
+}
 function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
   const envelopes = [];
   const claudeUuid = pickUuid(message);
@@ -2513,6 +2708,7 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
     };
   }
   if (message.type === "system") {
+    mapTaskLifecycleSystemMessage(message, state, envelopes);
     return {
       currentTurnId: state.currentTurnId,
       envelopes
@@ -2554,6 +2750,9 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
             queueTaskPromptSubagent(state, prompt, call);
           }
           setSubagentTitle(state, sessionSubagentForCall, pickTaskTitle(block.input) ?? prompt);
+          getAgentToolCalls(state).add(call);
+          const input = block.input ?? {};
+          rememberSubagentMeta(state, sessionSubagentForCall, { description: input.description, subagentType: input.subagent_type });
         }
         if (shouldHideParentToolCall(name)) {
           getHiddenParentToolCalls(state).add(call);
@@ -2598,6 +2797,18 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
         maybeEmitSubagentStart(state, turnId2, subagent, envelopes);
         envelopes.push(createEnvelope("agent", { t: "text", text: message.message.content }, { turn: turnId2, subagent, claudeUuid }));
       } else {
+        const origin = message.origin;
+        if (origin?.kind === "task-notification" || /<task-notification>/i.test(message.message.content)) {
+          const fields = parseTaskNotificationText(message.message.content);
+          const providerId = fields?.toolUseId ?? null;
+          const subagentForNotification = providerId && getAgentToolCalls(state).has(providerId) ? getSessionSubagentIdForProviderSubagent(state, providerId) : void 0;
+          if (fields && subagentForNotification && (fields.result || fields.status)) {
+            emitSubagentStopWithStatus(state, state.currentTurnId ?? void 0, subagentForNotification, envelopes, {
+              ...fields.status ? { status: fields.status } : {},
+              ...fields.result ? { result: fields.result } : {}
+            });
+          }
+        }
         closeTurn(state, "completed", envelopes);
         envelopes.push(createEnvelope("user", { t: "text", text: message.message.content }, { claudeUuid }));
       }
@@ -2628,6 +2839,31 @@ function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
             getHiddenParentToolCalls(state).delete(block.tool_use_id);
             continue;
           }
+          if (sessionSubagentForToolResult && getAgentToolCalls(state).has(block.tool_use_id)) {
+            const toolUseResult = message.tool_use_result;
+            const resultStatus = toolUseResultStatus(toolUseResult);
+            if (resultStatus === "async_launched") {
+              getStubSubagents(state).add(sessionSubagentForToolResult);
+              envelopes.push(createEnvelope("agent", { t: "tool-call-end", call: block.tool_use_id }, { turn: turnId, subagent }));
+              continue;
+            }
+            if (resultStatus === "completed") {
+              const text = toolUseResultToText(toolUseResult);
+              const stats = toolUseResultStats(toolUseResult);
+              const result = text ? capSubagentText(text) : void 0;
+              emitSubagentStopWithStatus(state, turnId, sessionSubagentForToolResult, envelopes, {
+                status: "completed",
+                ...result ? { result } : {},
+                ...stats ? { usage: { toolUses: stats.toolUses, totalTokens: stats.totalTokens, durationMs: stats.durationMs } } : {}
+              });
+              envelopes.push(createEnvelope("agent", {
+                t: "tool-call-end",
+                call: block.tool_use_id,
+                ...result ? { result: { ...result, ...stats ? { stats } : {} } } : {}
+              }, { turn: turnId, subagent }));
+              continue;
+            }
+          }
           if (sessionSubagentForToolResult) {
             maybeEmitSubagentStop(state, turnId, sessionSubagentForToolResult, envelopes);
           }