yzcode-cli 1.0.1 → 1.0.3

package/skills/mcpSkillBuilders.ts

@@ -0,0 +1,44 @@
+import type {
+  createSkillCommand,
+  parseSkillFrontmatterFields,
+} from './loadSkillsDir.js'
+
+/**
+ * Write-once registry for the two loadSkillsDir functions that MCP skill
+ * discovery needs. This module is a dependency-graph leaf: it imports nothing
+ * but types, so both mcpSkills.ts and loadSkillsDir.ts can depend on it
+ * without forming a cycle (client.ts → mcpSkills.ts → loadSkillsDir.ts → …
+ * → client.ts).
+ *
+ * The non-literal dynamic-import approach ("await import(variable)") fails at
+ * runtime in Bun-bundled binaries — the specifier is resolved against the
+ * chunk's /$bunfs/root/… path, not the original source tree, yielding "Cannot
+ * find module './loadSkillsDir.js'". A literal dynamic import works in bunfs
+ * but dependency-cruiser tracks it, and because loadSkillsDir transitively
+ * reaches almost everything, the single new edge fans out into many new cycle
+ * violations in the diff check.
+ *
+ * Registration happens at loadSkillsDir.ts module init, which is eagerly
+ * evaluated at startup via the static import from commands.ts — long before
+ * any MCP server connects.
+ */
+
+export type MCPSkillBuilders = {
+  createSkillCommand: typeof createSkillCommand
+  parseSkillFrontmatterFields: typeof parseSkillFrontmatterFields
+}
+
+let builders: MCPSkillBuilders | null = null
+
+export function registerMCPSkillBuilders(b: MCPSkillBuilders): void {
+  builders = b
+}
+
+export function getMCPSkillBuilders(): MCPSkillBuilders {
+  if (!builders) {
+    throw new Error(
+      'MCP skill builders not registered — loadSkillsDir.ts has not been evaluated yet',
+    )
+  }
+  return builders
+}

package/tasks/DreamTask/DreamTask.ts

@@ -0,0 +1,157 @@
+// Background task entry for auto-dream (memory consolidation subagent).
+// Makes the otherwise-invisible forked agent visible in the footer pill and
+// Shift+Down dialog. The dream agent itself is unchanged — this is pure UI
+// surfacing via the existing task registry.
+
+import { rollbackConsolidationLock } from '../../services/autoDream/consolidationLock.js'
+import type { SetAppState, Task, TaskStateBase } from '../../Task.js'
+import { createTaskStateBase, generateTaskId } from '../../Task.js'
+import { registerTask, updateTaskState } from '../../utils/task/framework.js'
+
+// Keep only the N most recent turns for live display.
+const MAX_TURNS = 30
+
+// A single assistant turn from the dream agent, tool uses collapsed to a count.
+export type DreamTurn = {
+  text: string
+  toolUseCount: number
+}
+
+// No phase detection — the dream prompt has a 4-stage structure
+// (orient/gather/consolidate/prune) but we don't parse it. Just flip from
+// 'starting' to 'updating' when the first Edit/Write tool_use lands.
+export type DreamPhase = 'starting' | 'updating'
+
+export type DreamTaskState = TaskStateBase & {
+  type: 'dream'
+  phase: DreamPhase
+  sessionsReviewing: number
+  /**
+   * Paths observed in Edit/Write tool_use blocks via onMessage. This is an
+   * INCOMPLETE reflection of what the dream agent actually changed — it misses
+   * any bash-mediated writes and only captures the tool calls we pattern-match.
+   * Treat as "at least these were touched", not "only these were touched".
+   */
+  filesTouched: string[]
+  /** Assistant text responses, tool uses collapsed. Prompt is NOT included. */
+  turns: DreamTurn[]
+  abortController?: AbortController
+  /** Stashed so kill can rewind the lock mtime (same path as fork-failure). */
+  priorMtime: number
+}
+
+export function isDreamTask(task: unknown): task is DreamTaskState {
+  return (
+    typeof task === 'object' &&
+    task !== null &&
+    'type' in task &&
+    task.type === 'dream'
+  )
+}
+
+export function registerDreamTask(
+  setAppState: SetAppState,
+  opts: {
+    sessionsReviewing: number
+    priorMtime: number
+    abortController: AbortController
+  },
+): string {
+  const id = generateTaskId('dream')
+  const task: DreamTaskState = {
+    ...createTaskStateBase(id, 'dream', 'dreaming'),
+    type: 'dream',
+    status: 'running',
+    phase: 'starting',
+    sessionsReviewing: opts.sessionsReviewing,
+    filesTouched: [],
+    turns: [],
+    abortController: opts.abortController,
+    priorMtime: opts.priorMtime,
+  }
+  registerTask(task, setAppState)
+  return id
+}
+
+export function addDreamTurn(
+  taskId: string,
+  turn: DreamTurn,
+  touchedPaths: string[],
+  setAppState: SetAppState,
+): void {
+  updateTaskState<DreamTaskState>(taskId, setAppState, task => {
+    const seen = new Set(task.filesTouched)
+    const newTouched = touchedPaths.filter(p => !seen.has(p) && seen.add(p))
+    // Skip the update entirely if the turn is empty AND nothing new was
+    // touched. Avoids re-rendering on pure no-ops.
+    if (
+      turn.text === '' &&
+      turn.toolUseCount === 0 &&
+      newTouched.length === 0
+    ) {
+      return task
+    }
+    return {
+      ...task,
+      phase: newTouched.length > 0 ? 'updating' : task.phase,
+      filesTouched:
+        newTouched.length > 0
+          ? [...task.filesTouched, ...newTouched]
+          : task.filesTouched,
+      turns: task.turns.slice(-(MAX_TURNS - 1)).concat(turn),
+    }
+  })
+}
+
+export function completeDreamTask(
+  taskId: string,
+  setAppState: SetAppState,
+): void {
+  // notified: true immediately — dream has no model-facing notification path
+  // (it's UI-only), and eviction requires terminal + notified. The inline
+  // appendSystemMessage completion note IS the user surface.
+  updateTaskState<DreamTaskState>(taskId, setAppState, task => ({
+    ...task,
+    status: 'completed',
+    endTime: Date.now(),
+    notified: true,
+    abortController: undefined,
+  }))
+}
+
+export function failDreamTask(taskId: string, setAppState: SetAppState): void {
+  updateTaskState<DreamTaskState>(taskId, setAppState, task => ({
+    ...task,
+    status: 'failed',
+    endTime: Date.now(),
+    notified: true,
+    abortController: undefined,
+  }))
+}
+
+export const DreamTask: Task = {
+  name: 'DreamTask',
+  type: 'dream',
+
+  async kill(taskId, setAppState) {
+    let priorMtime: number | undefined
+    updateTaskState<DreamTaskState>(taskId, setAppState, task => {
+      if (task.status !== 'running') return task
+      task.abortController?.abort()
+      priorMtime = task.priorMtime
+      return {
+        ...task,
+        status: 'killed',
+        endTime: Date.now(),
+        notified: true,
+        abortController: undefined,
+      }
+    })
+    // Rewind the lock mtime so the next session can retry. Same path as the
+    // fork-failure catch in autoDream.ts. If updateTaskState was a no-op
+    // (already terminal), priorMtime stays undefined and we skip.
+    if (priorMtime !== undefined) {
+      await rollbackConsolidationLock(priorMtime)
+    }
+  },
+}

package/tasks/InProcessTeammateTask/InProcessTeammateTask.tsx

@@ -0,0 +1,126 @@
+/**
+ * InProcessTeammateTask - Manages in-process teammate lifecycle
+ *
+ * This component implements the Task interface for in-process teammates.
+ * Unlike LocalAgentTask (background agents), in-process teammates:
+ * 1. Run in the same Node.js process using AsyncLocalStorage for isolation
+ * 2. Have team-aware identity (agentName@teamName)
+ * 3. Support plan mode approval flow
+ * 4. Can be idle (waiting for work) or active (processing)
+ */
+
+import { isTerminalTaskStatus, type SetAppState, type Task, type TaskStateBase } from '../../Task.js';
+import type { Message } from '../../types/message.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { createUserMessage } from '../../utils/messages.js';
+import { killInProcessTeammate } from '../../utils/swarm/spawnInProcess.js';
+import { updateTaskState } from '../../utils/task/framework.js';
+import type { InProcessTeammateTaskState } from './types.js';
+import { appendCappedMessage, isInProcessTeammateTask } from './types.js';
+
+/**
+ * InProcessTeammateTask - Handles in-process teammate execution.
+ */
+export const InProcessTeammateTask: Task = {
+  name: 'InProcessTeammateTask',
+  type: 'in_process_teammate',
+  async kill(taskId, setAppState) {
+    killInProcessTeammate(taskId, setAppState);
+  }
+};
+
+/**
+ * Request shutdown for a teammate.
+ */
+export function requestTeammateShutdown(taskId: string, setAppState: SetAppState): void {
+  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {
+    if (task.status !== 'running' || task.shutdownRequested) {
+      return task;
+    }
+    return {
+      ...task,
+      shutdownRequested: true
+    };
+  });
+}
+
+/**
+ * Append a message to a teammate's conversation history.
+ * Used for zoomed view to show the teammate's conversation.
+ */
+export function appendTeammateMessage(taskId: string, message: Message, setAppState: SetAppState): void {
+  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {
+    if (task.status !== 'running') {
+      return task;
+    }
+    return {
+      ...task,
+      messages: appendCappedMessage(task.messages, message)
+    };
+  });
+}
+
+/**
+ * Inject a user message to a teammate's pending queue.
+ * Used when viewing a teammate's transcript to send typed messages to them.
+ * Also adds the message to task.messages so it appears immediately in the transcript.
+ */
+export function injectUserMessageToTeammate(taskId: string, message: string, setAppState: SetAppState): void {
+  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {
+    // Allow message injection when teammate is running or idle (waiting for input)
+    // Only reject if teammate is in a terminal state
+    if (isTerminalTaskStatus(task.status)) {
+      logForDebugging(`Dropping message for teammate task ${taskId}: task status is "${task.status}"`);
+      return task;
+    }
+    return {
+      ...task,
+      pendingUserMessages: [...task.pendingUserMessages, message],
+      messages: appendCappedMessage(task.messages, createUserMessage({
+        content: message
+      }))
+    };
+  });
+}
+
+/**
+ * Get teammate task by agent ID from AppState.
+ * Prefers running tasks over killed/completed ones in case multiple tasks
+ * with the same agentId exist.
+ * Returns undefined if not found.
+ */
+export function findTeammateTaskByAgentId(agentId: string, tasks: Record<string, TaskStateBase>): InProcessTeammateTaskState | undefined {
+  let fallback: InProcessTeammateTaskState | undefined;
+  for (const task of Object.values(tasks)) {
+    if (isInProcessTeammateTask(task) && task.identity.agentId === agentId) {
+      // Prefer running tasks in case old killed tasks still exist in AppState
+      // alongside new running ones with the same agentId
+      if (task.status === 'running') {
+        return task;
+      }
+      // Keep first match as fallback in case no running task exists
+      if (!fallback) {
+        fallback = task;
+      }
+    }
+  }
+  return fallback;
+}
+
+/**
+ * Get all in-process teammate tasks from AppState.
+ */
+export function getAllInProcessTeammateTasks(tasks: Record<string, TaskStateBase>): InProcessTeammateTaskState[] {
+  return Object.values(tasks).filter(isInProcessTeammateTask);
+}
+
+/**
+ * Get running in-process teammates sorted alphabetically by agentName.
+ * Shared between TeammateSpinnerTree display, PromptInput footer selector,
+ * and useBackgroundTaskNavigation — selectedIPAgentIndex maps into this
+ * array, so all three must agree on sort order.
+ */
+export function getRunningTeammatesSorted(tasks: Record<string, TaskStateBase>): InProcessTeammateTaskState[] {
+  return getAllInProcessTeammateTasks(tasks).filter(t => t.status === 'running').sort((a, b) => a.identity.agentName.localeCompare(b.identity.agentName));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["isTerminalTaskStatus","SetAppState","Task","TaskStateBase","Message","logForDebugging","createUserMessage","killInProcessTeammate","updateTaskState","InProcessTeammateTaskState","appendCappedMessage","isInProcessTeammateTask","InProcessTeammateTask","name","type","kill","taskId","setAppState","requestTeammateShutdown","task","status","shutdownRequested","appendTeammateMessage","message","messages","injectUserMessageToTeammate","pendingUserMessages","content","findTeammateTaskByAgentId","agentId","tasks","Record","fallback","Object","values","identity","getAllInProcessTeammateTasks","filter","getRunningTeammatesSorted","t","sort","a","b","agentName","localeCompare"],"sources":["InProcessTeammateTask.tsx"],"sourcesContent":["/**\n * InProcessTeammateTask - Manages in-process teammate lifecycle\n *\n * This component implements the Task interface for in-process teammates.\n * Unlike LocalAgentTask (background agents), in-process teammates:\n * 1. Run in the same Node.js process using AsyncLocalStorage for isolation\n * 2. Have team-aware identity (agentName@teamName)\n * 3. Support plan mode approval flow\n * 4. Can be idle (waiting for work) or active (processing)\n */\n\nimport {\n  isTerminalTaskStatus,\n  type SetAppState,\n  type Task,\n  type TaskStateBase,\n} from '../../Task.js'\nimport type { Message } from '../../types/message.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { createUserMessage } from '../../utils/messages.js'\nimport { killInProcessTeammate } from '../../utils/swarm/spawnInProcess.js'\nimport { updateTaskState } from '../../utils/task/framework.js'\nimport type { InProcessTeammateTaskState } from './types.js'\nimport { appendCappedMessage, isInProcessTeammateTask } from './types.js'\n\n/**\n * InProcessTeammateTask - Handles in-process teammate execution.\n */\nexport const InProcessTeammateTask: Task = {\n  name: 'InProcessTeammateTask',\n  type: 'in_process_teammate',\n  async kill(taskId, setAppState) {\n    killInProcessTeammate(taskId, setAppState)\n  },\n}\n\n/**\n * Request shutdown for a teammate.\n */\nexport function requestTeammateShutdown(\n  taskId: string,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running' || task.shutdownRequested) {\n      return task\n    }\n\n    return {\n      ...task,\n      shutdownRequested: true,\n    }\n  })\n}\n\n/**\n * Append a message to a teammate's conversation history.\n * Used for zoomed view to show the teammate's conversation.\n */\nexport function appendTeammateMessage(\n  taskId: string,\n  message: Message,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {\n    if (task.status !== 'running') {\n      return task\n    }\n\n    return {\n      ...task,\n      messages: appendCappedMessage(task.messages, message),\n    }\n  })\n}\n\n/**\n * Inject a user message to a teammate's pending queue.\n * Used when viewing a teammate's transcript to send typed messages to them.\n * Also adds the message to task.messages so it appears immediately in the transcript.\n */\nexport function injectUserMessageToTeammate(\n  taskId: string,\n  message: string,\n  setAppState: SetAppState,\n): void {\n  updateTaskState<InProcessTeammateTaskState>(taskId, setAppState, task => {\n    // Allow message injection when teammate is running or idle (waiting for input)\n    // Only reject if teammate is in a terminal state\n    if (isTerminalTaskStatus(task.status)) {\n      logForDebugging(\n        `Dropping message for teammate task ${taskId}: task status is \"${task.status}\"`,\n      )\n      return task\n    }\n\n    return {\n      ...task,\n      pendingUserMessages: [...task.pendingUserMessages, message],\n      messages: appendCappedMessage(\n        task.messages,\n        createUserMessage({ content: message }),\n      ),\n    }\n  })\n}\n\n/**\n * Get teammate task by agent ID from AppState.\n * Prefers running tasks over killed/completed ones in case multiple tasks\n * with the same agentId exist.\n * Returns undefined if not found.\n */\nexport function findTeammateTaskByAgentId(\n  agentId: string,\n  tasks: Record<string, TaskStateBase>,\n): InProcessTeammateTaskState | undefined {\n  let fallback: InProcessTeammateTaskState | undefined\n  for (const task of Object.values(tasks)) {\n    if (isInProcessTeammateTask(task) && task.identity.agentId === agentId) {\n      // Prefer running tasks in case old killed tasks still exist in AppState\n      // alongside new running ones with the same agentId\n      if (task.status === 'running') {\n        return task\n      }\n      // Keep first match as fallback in case no running task exists\n      if (!fallback) {\n        fallback = task\n      }\n    }\n  }\n  return fallback\n}\n\n/**\n * Get all in-process teammate tasks from AppState.\n */\nexport function getAllInProcessTeammateTasks(\n  tasks: Record<string, TaskStateBase>,\n): InProcessTeammateTaskState[] {\n  return Object.values(tasks).filter(isInProcessTeammateTask)\n}\n\n/**\n * Get running in-process teammates sorted alphabetically by agentName.\n * Shared between TeammateSpinnerTree display, PromptInput footer selector,\n * and useBackgroundTaskNavigation — selectedIPAgentIndex maps into this\n * array, so all three must agree on sort order.\n */\nexport function getRunningTeammatesSorted(\n  tasks: Record<string, TaskStateBase>,\n): InProcessTeammateTaskState[] {\n  return getAllInProcessTeammateTasks(tasks)\n    .filter(t => t.status === 'running')\n    .sort((a, b) => a.identity.agentName.localeCompare(b.identity.agentName))\n}\n"],"mappings":"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","ignoreList":[]}

package/tasks/InProcessTeammateTask/types.ts

@@ -0,0 +1,121 @@
+import type { TaskStateBase } from '../../Task.js'
+import type { AgentToolResult } from '../../tools/AgentTool/agentToolUtils.js'
+import type { AgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js'
+import type { Message } from '../../types/message.js'
+import type { PermissionMode } from '../../utils/permissions/PermissionMode.js'
+import type { AgentProgress } from '../LocalAgentTask/LocalAgentTask.js'
+
+/**
+ * Teammate identity stored in task state.
+ * Same shape as TeammateContext (runtime) but stored as plain data.
+ * TeammateContext is for AsyncLocalStorage; this is for AppState persistence.
+ */
+export type TeammateIdentity = {
+  agentId: string // e.g., "researcher@my-team"
+  agentName: string // e.g., "researcher"
+  teamName: string
+  color?: string
+  planModeRequired: boolean
+  parentSessionId: string // Leader's session ID
+}
+
+export type InProcessTeammateTaskState = TaskStateBase & {
+  type: 'in_process_teammate'
+
+  // Identity as sub-object (matches TeammateContext shape for consistency)
+  // Stored as plain data in AppState, NOT a reference to AsyncLocalStorage
+  identity: TeammateIdentity
+
+  // Execution
+  prompt: string
+  // Optional model override for this teammate
+  model?: string
+  // Optional: Only set if teammate uses a specific agent definition
+  // Many teammates run as general-purpose agents without a predefined definition
+  selectedAgent?: AgentDefinition
+  abortController?: AbortController // Runtime only, not serialized to disk - kills WHOLE teammate
+  currentWorkAbortController?: AbortController // Runtime only - aborts current turn without killing teammate
+  unregisterCleanup?: () => void // Runtime only
+
+  // Plan mode approval tracking (planModeRequired is in identity)
+  awaitingPlanApproval: boolean
+
+  // Permission mode for this teammate (cycled independently via Shift+Tab when viewing)
+  permissionMode: PermissionMode
+
+  // State
+  error?: string
+  result?: AgentToolResult // Reuse existing type since teammates run via runAgent()
+  progress?: AgentProgress
+
+  // Conversation history for zoomed view (NOT mailbox messages)
+  // Mailbox messages are stored separately in teamContext.inProcessMailboxes
+  messages?: Message[]
+
+  // Tool use IDs currently being executed (for animation in transcript view)
+  inProgressToolUseIDs?: Set<string>
+
+  // Queue of user messages to deliver when viewing teammate transcript
+  pendingUserMessages: string[]
+
+  // UI: random spinner verbs (stable across re-renders, shared between components)
+  spinnerVerb?: string
+  pastTenseVerb?: string
+
+  // Lifecycle
+  isIdle: boolean
+  shutdownRequested: boolean
+
+  // Callbacks to notify when teammate becomes idle (runtime only)
+  // Used by leader to efficiently wait without polling
+  onIdleCallbacks?: Array<() => void>
+
+  // Progress tracking (for computing deltas in notifications)
+  lastReportedToolCount: number
+  lastReportedTokenCount: number
+}
+
+export function isInProcessTeammateTask(
+  task: unknown,
+): task is InProcessTeammateTaskState {
+  return (
+    typeof task === 'object' &&
+    task !== null &&
+    'type' in task &&
+    task.type === 'in_process_teammate'
+  )
+}
+
+/**
+ * Cap on the number of messages kept in task.messages (the AppState UI mirror).
+ *
+ * task.messages exists purely for the zoomed transcript dialog, which only
+ * needs recent context. The full conversation lives in the local allMessages
+ * array (inProcessRunner) and on disk at the agent transcript path.
+ *
+ * BQ analysis (round 9, 2026-03-20) showed ~20MB RSS per agent at 500+ turn
+ * sessions and ~125MB per concurrent agent in swarm bursts. Whale session
+ * 9a990de8 launched 292 agents in 2 minutes and reached 36.8GB. The dominant
+ * cost is this array holding a second full copy of every message.
+ */
+export const TEAMMATE_MESSAGES_UI_CAP = 50
+
+/**
+ * Append an item to a message array, capping the result at
+ * TEAMMATE_MESSAGES_UI_CAP entries by dropping the oldest. Always returns
+ * a new array (AppState immutability).
+ */
+export function appendCappedMessage<T>(
+  prev: readonly T[] | undefined,
+  item: T,
+): T[] {
+  if (prev === undefined || prev.length === 0) {
+    return [item]
+  }
+  if (prev.length >= TEAMMATE_MESSAGES_UI_CAP) {
+    const next = prev.slice(-(TEAMMATE_MESSAGES_UI_CAP - 1))
+    next.push(item)
+    return next
+  }
+  return [...prev, item]
+}