@yeaft/webchat-agent 0.1.237 → 0.1.238

package/conductor/conductor-claude.js

@@ -21,6 +21,7 @@ import {
   getConductorHome, ensureConductorHome,
   loadState, saveState, updateTaskInState, initTaskDir
 } from './persistence.js';
+import { startTaskExecution, forwardToTask } from './task-runner.js';
 
 // =====================================================================
 // Claude Session ID Persistence
@@ -110,8 +111,6 @@ message: <要转发的内容>
 - 每条用户消息只需要一种响应：创建任务 / 转发 / 直接回答
 - 创建任务时只给标题，不要描述实现步骤
 - 创建任务时必须指定 workDir（用户提到的项目路径）和 scenario（场景类型）
-- 当消息包含 [工作路径: xxx] 时，直接使用该路径作为 workDir 创建 CREATE_TASK，不要再询问 workDir
-- 当消息包含 [工作路径: xxx] 时，这是用户明确的意图——立刻创建任务，不要做任何分析
 - 如果用户没指定 workDir 或 scenario，先询问
 - 如果用户问"进度怎样"，直接汇总上面的任务列表状态
 - 保持回复简洁
@@ -144,7 +143,15 @@ export async function createConductorClaude(conductor) {
     cwd: conductorHome,
     permissionMode: 'bypassPermissions',
     abort: abortController.signal,
-    appendSystemPrompt: systemPrompt
+    appendSystemPrompt: systemPrompt,
+    // Conductor Claude is a lightweight classifier — restrict heavy tools
+    // Only allow: Read, Glob, Grep (for context awareness), WebFetch, WebSearch
+    disallowedTools: [
+      'Write', 'Edit', 'NotebookEdit',
+      'Bash', 'Agent',
+      'EnterPlanMode', 'ExitPlanMode',
+      'EnterWorktree', 'ExitWorktree'
+    ]
   };
 
   if (savedSessionId) {
@@ -178,27 +185,22 @@ export async function createConductorClaude(conductor) {
 /**
  * Send message to Conductor Claude
  */
-export async function sendToConductor(conductor, content, workDir) {
+export async function sendToConductor(conductor, content) {
   let state = conductor.conductorState;
 
   if (!state || !state.query || !state.inputStream) {
     state = await createConductorClaude(conductor);
   }
 
-  // Inject workDir prefix so Conductor knows the project path
-  let fullContent = content;
-  if (workDir) {
-    fullContent = `[工作路径: ${workDir}]\n${content}`;
-  }
-
   // Inject task context before user message
   const taskContext = buildTaskContext(conductor);
-  if (taskContext) {
-    fullContent = `${fullContent}\n\n---\n<conductor-context>\n${taskContext}\n</conductor-context>`;
-  }
+  const fullContent = taskContext
+    ? `${content}\n\n---\n<conductor-context>\n${taskContext}\n</conductor-context>`
+    : content;
 
   state.turnActive = true;
   state.accumulatedText = '';
+  state._lastUserContent = content;  // Preserve original user input for task description
   state.inputStream.enqueue({
     type: 'user',
     message: { role: 'user', content: fullContent }
@@ -336,6 +338,18 @@ async function processConductorOutput(conductor, conductorQuery) {
         for (const ct of createTasks) {
           const taskId = `task-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
 
+          // Notify frontend: task is being created (worktree may take a few seconds)
+          sendConductorOutput(conductor, 'task_creating', null, {
+            taskId, taskTitle: ct.title
+          });
+          sendConductorMessage({
+            type: 'conductor_task_creating',
+            taskId,
+            title: ct.title,
+            workDir: ct.workDir,
+            scenario: ct.scenario
+          });
+
           // Create task directory at {workDir}/.conductor/{taskId}/ (includes worktree)
           let worktreePath = null;
           if (ct.workDir) {
@@ -347,10 +361,15 @@ async function processConductorOutput(conductor, conductorQuery) {
             }
           }
 
+          // Extract user's original message as task description
+          // (the content that triggered this CREATE_TASK)
+          const userDescription = state._lastUserContent || ct.title;
+
           // Register in state.json
           const taskEntry = {
             taskId,
             title: ct.title,
+            description: userDescription,
             workDir: ct.workDir,
             scenario: ct.scenario,
             status: 'created',
@@ -375,6 +394,11 @@ async function processConductorOutput(conductor, conductorQuery) {
           });
 
           console.log(`[Conductor] Task created: ${taskId} — ${ct.title} @ ${ct.workDir} (${ct.scenario})`);
+
+          // Start Orchestrator-driven execution (fire-and-forget)
+          startTaskExecution(conductor, taskEntry).catch(e =>
+            console.error(`[Conductor] Task execution failed for ${taskId}:`, e.message)
+          );
         }
 
         // Handle FORWARD_TASK
@@ -389,6 +413,11 @@ async function processConductorOutput(conductor, conductorQuery) {
             });
             task.lastUpdate = Date.now();
 
+            // Forward to Orchestrator (which will relay to active actors)
+            forwardToTask(ft.taskId, ft.message).catch(e =>
+              console.warn(`[Conductor] Failed to forward to orchestrator ${ft.taskId}:`, e.message)
+            );
+
             sendConductorOutput(conductor, 'task_forwarded', null, {
               taskId: ft.taskId
             });

package/conductor/index.js

@@ -1,12 +1,13 @@
 /**
  * Conductor — Module Entry
  *
- * Exports three core subsystems:
+ * Exports core subsystems:
  * 1. Personas — 18 persona definitions (4 scenarios)
  * 2. Specialties — specialty behavior definitions
  * 3. CLAUDE.md Generator — dynamic 3-section generation
  * 4. Actor — Claude instance create/manage/release
  * 5. Worktree — per-task worktree management
+ * 6. Task Runner — Orchestrator ↔ Actor bridge layer
  */
 
 // ---- Personas ----
@@ -61,5 +62,15 @@ export {
   cleanupTaskWorktree,
   cleanupAllConductorWorktrees,
   getTaskWorktreePath,
-  getActorCwd
+  getActorCwd,
+  READ_WRITE_SPECIALTIES
 } from './worktree.js';
+
+// ---- Task Runner (Orchestrator ↔ Actor bridge) ----
+export {
+  startTaskExecution,
+  stopTaskExecution,
+  stopAllTaskExecutions,
+  forwardToTask,
+  getOrchestrator
+} from './task-runner.js';

package/conductor/orchestrator.js

@@ -53,6 +53,18 @@ export class Orchestrator {
 
     /** @type {Map<string, Task>} */
     this.tasks = new Map();
+
+    /** Abort flag — checked at each phase boundary in _runStateMachine */
+    this._aborted = false;
+  }
+
+  /**
+   * Abort the orchestrator — stops the state machine loop at the next phase boundary.
+   * Does NOT release actors (that's handled by task-runner's stopTaskExecution).
+   */
+  abort() {
+    this._aborted = true;
+    this.log('Orchestrator aborted');
   }
 
   // ===================================================================
@@ -63,15 +75,16 @@ export class Orchestrator {
    * 创建并启动新 Task
    *
    * @param {object} params
+   * @param {string} [params.taskId] — 外部指定的 taskId（来自 Conductor），不提供则自动生成
    * @param {string} params.title
    * @param {string} params.description
    * @param {string} params.scenario — 'dev' | 'writing' | 'trading' | 'video'
    * @param {string} params.workDir
    * @returns {Task}
    */
-  async startTask({ title, description, scenario, workDir }) {
+  async startTask({ taskId: externalTaskId, title, description, scenario, workDir }) {
     const flow = getFlow(scenario);  // 验证 scenario 合法性
-    const task = createTask({ title, description, scenario, workDir });
+    const task = createTask({ taskId: externalTaskId, title, description, scenario, workDir });
     this.tasks.set(task.taskId, task);
     this._notify(task);
 
@@ -114,13 +127,33 @@ export class Orchestrator {
 
   /**
    * 用户消息注入（Task 对话页直接交互时）
-   * TODO: 后续实现用户消息处理
+   *
+   * 将 Conductor 转发的用户消息注入到正在运行的 task：
+   * - 如果 task 有活跃的 actor，发送给所有活跃 actor
+   * - 如果没有活跃 actor（phase 之间），存入 inbox 等待下一个 actor
    */
   async handleUserMessage(taskId, message) {
     const task = this.tasks.get(taskId);
     if (!task) return;
     this.log(`User message for ${taskId}: ${message.substring(0, 100)}...`);
-    // 用户消息处理逻辑由 Conductor 引擎层实现
+
+    // Store in inbox for actors in subsequent phases
+    if (!task.inbox) task.inbox = [];
+    task.inbox.push({ from: 'user', content: message, timestamp: Date.now() });
+    task.updatedAt = Date.now();
+
+    // If there are active actors, forward to them
+    if (task.activeActors.length > 0) {
+      for (const actor of task.activeActors) {
+        try {
+          this.actorManager.sendMessage?.(actor.instanceId, message);
+        } catch (e) {
+          this.log(`Failed to send user message to actor ${actor.instanceId}: ${e.message}`);
+        }
+      }
+    }
+
+    this._notify(task);
   }
 
   // ===================================================================
@@ -132,6 +165,15 @@ export class Orchestrator {
    */
   async _runStateMachine(task, flow) {
     while (task.phase !== Phase.DONE && task.phase !== Phase.FAILED) {
+      // Check abort flag at each phase boundary
+      if (this._aborted) {
+        this.log(`Task ${task.taskId} aborted`);
+        task.error = 'Task aborted';
+        transitionPhase(task, Phase.FAILED);
+        this._notify(task);
+        break;
+      }
+
       this.log(`Task ${task.taskId} entering phase: ${task.phase}`);
 
       switch (task.phase) {

package/conductor/session.js

@@ -16,6 +16,7 @@ import {
   sendConductorMessage, sendConductorOutput, sendStatusUpdate, recordUserMessage
 } from './ui-messages.js';
 import { createConductorClaude, sendToConductor, stopConductorClaude } from './conductor-claude.js';
+import { stopAllTaskExecutions } from './task-runner.js';
 
 // =====================================================================
 // Singleton Conductor Instance
@@ -138,7 +139,7 @@ export async function initConductor(msg) {
  * Handle user input to Conductor
  */
 export async function handleConductorUserInput(msg) {
-  const { content, workDir } = msg;
+  const { content } = msg;
   if (!conductor) {
     console.warn('[Conductor] Not initialized, ignoring input');
     return;
@@ -154,7 +155,7 @@ export async function handleConductorUserInput(msg) {
 
   recordUserMessage(conductor, content);
   conductor.status = 'running';
-  await sendToConductor(conductor, content, workDir);
+  await sendToConductor(conductor, content);
 }
 
 /**
@@ -164,6 +165,7 @@ export async function stopConductor() {
   if (!conductor) return;
 
   conductor.status = 'stopped';
+  await stopAllTaskExecutions();
   await stopConductorClaude(conductor);
 
   sendConductorOutput(conductor, 'system', {

package/conductor/task-runner.js

@@ -0,0 +1,336 @@
+/**
+ * Conductor — Task Runner (Bridge Layer)
+ *
+ * Bridges the gap between Conductor Claude (task creation) and
+ * Orchestrator (state machine) + Actor (Claude instances).
+ *
+ * Responsibilities:
+ * 1. Create actorManager adapter that translates Orchestrator's interface
+ *    to Actor module's actual parameter format
+ * 2. Instantiate Orchestrator and start task execution
+ * 3. Relay status changes and actor output to frontend via UI messages
+ * 4. Handle task completion / failure cleanup
+ */
+import { createOrchestrator } from './orchestrator.js';
+import {
+  createActor, sendToActor, releaseActor, releaseAllActors
+} from './actor.js';
+import { getTaskDir, updateTaskInState } from './persistence.js';
+import {
+  sendConductorMessage, sendConductorOutput, sendStatusUpdate
+} from './ui-messages.js';
+import { READ_WRITE_SPECIALTIES } from './worktree.js';
+
+// =====================================================================
+// Per-task Orchestrator registry
+// =====================================================================
+
+/** @type {Map<string, Orchestrator>} taskId → Orchestrator */
+const orchestrators = new Map();
+
+/**
+ * Get an active orchestrator for a task
+ * @param {string} taskId
+ * @returns {Orchestrator|null}
+ */
+export function getOrchestrator(taskId) {
+  return orchestrators.get(taskId) || null;
+}
+
+// =====================================================================
+// ActorManager Adapter
+// =====================================================================
+
+/**
+ * Create an actorManager adapter that translates Orchestrator's
+ * createActor(persona, specialty, context) interface into Actor module's
+ * createActor({ personaId, specialtyId, ... }) format.
+ *
+ * Orchestrator calls:
+ *   actorManager.createActor(
+ *     { id: personaId, name: personaName },
+ *     specialty,        // string like 'coding', 'planning', etc.
+ *     { taskId, actorInstanceId, instruction, workDir, memoryPath, ... }
+ *   ) → Promise<ActorResult>
+ *
+ * Actor.js expects:
+ *   createActor({
+ *     personaId, specialtyId, taskId, taskDir, taskContext,
+ *     worktreePath, onOutput, onComplete, onError
+ *   }) → Promise<ActorInstance>
+ *
+ * The adapter wraps actor creation + message sending + result collection
+ * into a single Promise<ActorResult> that the Orchestrator awaits.
+ */
+function createActorManagerAdapter(conductor, taskEntry) {
+  const { taskId, workDir, worktreePath } = taskEntry;
+  const taskDir = getTaskDir(workDir, taskId);
+
+  return {
+    /**
+     * Create an actor, send it instructions, and wait for its result.
+     * @returns {Promise<ActorResult>}
+     */
+    async createActor(persona, specialty, context) {
+      const actorWorktreePath = READ_WRITE_SPECIALTIES.has(specialty)
+        ? worktreePath
+        : null;
+
+      // Create a deferred promise for actor completion
+      let resolveResult, rejectResult;
+      const resultPromise = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+      });
+
+      const instance = await createActor({
+        personaId: persona.id,
+        specialtyId: specialty,
+        taskId,
+        taskDir,
+        taskContext: {
+          description: taskEntry.description || '',
+          instruction: context.instruction || context.description || '',
+          memoryPath: context.memoryPath || null,
+          planPath: context.planPath || null,
+          scenario: taskEntry.scenario,
+          workDir
+        },
+        threadId: context.threadId || null,
+        worktreePath: actorWorktreePath,
+        onOutput: (instanceId, message) => {
+          // Relay actor output to frontend in real-time
+          sendConductorOutput(conductor, 'text', message, {
+            taskId,
+            persona: persona.name || persona.id,
+            specialty
+          });
+        },
+        onComplete: (instanceId, result) => {
+          console.log(`[TaskRunner] Actor ${instanceId} completed for task ${taskId}`);
+
+          // Accumulate actor cost into conductor totals
+          if (result.costUsd) conductor.costUsd += result.costUsd;
+          if (result.inputTokens) conductor.totalInputTokens += result.inputTokens;
+          if (result.outputTokens) conductor.totalOutputTokens += result.outputTokens;
+
+          // Update tracking: decrement active count
+          if (taskEntry.activeActors) {
+            const idx = taskEntry.activeActors.indexOf(instanceId);
+            if (idx !== -1) taskEntry.activeActors.splice(idx, 1);
+          }
+          conductor.activeClaudes = Math.max(0, (conductor.activeClaudes || 1) - 1);
+          sendStatusUpdate(conductor);
+
+          // Release actor from registry to prevent memory leak
+          releaseActor(taskId, instanceId).catch(e =>
+            console.warn(`[TaskRunner] Failed to auto-release actor ${instanceId}:`, e.message)
+          );
+
+          resolveResult(result);
+        },
+        onError: (instanceId, error) => {
+          console.error(`[TaskRunner] Actor ${instanceId} failed for task ${taskId}:`, error.message);
+
+          // Update tracking: decrement active count
+          if (taskEntry.activeActors) {
+            const idx = taskEntry.activeActors.indexOf(instanceId);
+            if (idx !== -1) taskEntry.activeActors.splice(idx, 1);
+          }
+          conductor.activeClaudes = Math.max(0, (conductor.activeClaudes || 1) - 1);
+          sendStatusUpdate(conductor);
+
+          // Release actor from registry on error too
+          releaseActor(taskId, instanceId).catch(e =>
+            console.warn(`[TaskRunner] Failed to auto-release failed actor ${instanceId}:`, e.message)
+          );
+
+          rejectResult(error);
+        }
+      });
+
+      // Update conductor's active claude count
+      conductor.activeClaudes = (conductor.activeClaudes || 0) + 1;
+
+      // Update task entry's activeActors for status tracking
+      if (!taskEntry.activeActors) taskEntry.activeActors = [];
+      taskEntry.activeActors.push(instance.instanceId);
+      sendStatusUpdate(conductor);
+
+      // Send the instruction to the actor to start work
+      const instruction = context.instruction || context.description || taskEntry.description || '';
+      if (instruction) {
+        sendToActor(taskId, instance.instanceId, instruction);
+      }
+
+      return resultPromise;
+    },
+
+    /**
+     * Release an actor instance.
+     */
+    releaseActor(instanceId) {
+      releaseActor(taskId, instanceId).catch(e =>
+        console.warn(`[TaskRunner] Failed to release actor ${instanceId}:`, e.message)
+      );
+
+      // Update tracking
+      if (taskEntry.activeActors) {
+        const idx = taskEntry.activeActors.indexOf(instanceId);
+        if (idx !== -1) taskEntry.activeActors.splice(idx, 1);
+      }
+      conductor.activeClaudes = Math.max(0, (conductor.activeClaudes || 1) - 1);
+    },
+
+    /**
+     * Send a message to an active actor (for user message forwarding).
+     */
+    sendMessage(instanceId, message) {
+      sendToActor(taskId, instanceId, message);
+    }
+  };
+}
+
+// =====================================================================
+// Task Execution Entry Point
+// =====================================================================
+
+/**
+ * Start task execution via Orchestrator.
+ *
+ * Called after initTaskDir completes (folder + worktree ready).
+ * This is fire-and-forget — the orchestrator runs asynchronously.
+ *
+ * @param {object} conductor — Conductor singleton instance
+ * @param {object} taskEntry — Task registry entry from conductor.tasks Map
+ */
+export async function startTaskExecution(conductor, taskEntry) {
+  const { taskId, title, workDir, scenario, description } = taskEntry;
+
+  console.log(`[TaskRunner] Starting execution for task ${taskId}: "${title}" [${scenario}]`);
+
+  // Update task status
+  taskEntry.status = 'running';
+  taskEntry.lastUpdate = Date.now();
+
+  // Create actorManager adapter
+  const actorManager = createActorManagerAdapter(conductor, taskEntry);
+
+  // Create Orchestrator instance
+  const orchestrator = createOrchestrator({
+    actorManager,
+
+    onStatusChange: (serializedTask) => {
+      // Sync orchestrator state back to conductor's task entry
+      taskEntry.status = serializedTask.phase;
+      taskEntry.currentStep = `${serializedTask.phase}${serializedTask.currentStepIndex >= 0 ? ' step ' + serializedTask.currentStepIndex : ''}`;
+      taskEntry.activeActors = serializedTask.activeActors.map(a => a.instanceId);
+      taskEntry.lastUpdate = Date.now();
+
+      // Persist to state.json (async, non-blocking)
+      updateTaskInState(taskId, taskEntry).catch(e =>
+        console.warn(`[TaskRunner] Failed to persist task ${taskId}:`, e.message)
+      );
+
+      // Push status to frontend
+      sendConductorMessage({
+        type: 'conductor_task_status',
+        taskId,
+        task: {
+          ...taskEntry,
+          phase: serializedTask.phase,
+          complexity: serializedTask.complexity,
+          plan: serializedTask.plan,
+          activeActors: serializedTask.activeActors,
+          completedActors: serializedTask.completedActors,
+          iterations: serializedTask.iterations
+        }
+      });
+      sendStatusUpdate(conductor);
+    },
+
+    onLog: (...args) => {
+      console.log('[TaskRunner/Orchestrator]', ...args);
+    }
+  });
+
+  // Register orchestrator
+  orchestrators.set(taskId, orchestrator);
+
+  // Start the task (async — orchestrator runs its state machine internally)
+  try {
+    await orchestrator.startTask({
+      taskId,
+      title,
+      description: description || title,
+      scenario,
+      workDir
+    });
+
+    console.log(`[TaskRunner] Orchestrator started for task ${taskId}`);
+  } catch (err) {
+    console.error(`[TaskRunner] Failed to start orchestrator for task ${taskId}:`, err.message);
+
+    taskEntry.status = 'failed';
+    taskEntry.error = err.message;
+    taskEntry.lastUpdate = Date.now();
+
+    await updateTaskInState(taskId, taskEntry).catch(() => {});
+
+    sendConductorOutput(conductor, 'system', {
+      message: { role: 'assistant', content: `Task "${title}" failed to start: ${err.message}` }
+    });
+    sendStatusUpdate(conductor);
+
+    // Cleanup
+    orchestrators.delete(taskId);
+    await releaseAllActors(taskId, { force: true }).catch(() => {});
+  }
+}
+
+/**
+ * Forward a user message to a running task's orchestrator.
+ *
+ * @param {string} taskId
+ * @param {string} message
+ */
+export async function forwardToTask(taskId, message) {
+  const orchestrator = orchestrators.get(taskId);
+  if (!orchestrator) {
+    console.warn(`[TaskRunner] Cannot forward to task ${taskId}: no active orchestrator`);
+    return;
+  }
+
+  await orchestrator.handleUserMessage(taskId, message);
+}
+
+/**
+ * Stop a running task's orchestrator and release all its actors.
+ *
+ * @param {string} taskId
+ */
+export async function stopTaskExecution(taskId) {
+  const orchestrator = orchestrators.get(taskId);
+  if (!orchestrator) return;
+
+  console.log(`[TaskRunner] Stopping task ${taskId}`);
+
+  // Abort the orchestrator state machine (stops at next phase boundary)
+  orchestrator.abort();
+  orchestrators.delete(taskId);
+
+  // Release all actors for this task
+  await releaseAllActors(taskId, { force: true }).catch(e =>
+    console.warn(`[TaskRunner] Error releasing actors for ${taskId}:`, e.message)
+  );
+}
+
+/**
+ * Stop all running task orchestrators (used during conductor shutdown).
+ */
+export async function stopAllTaskExecutions() {
+  const taskIds = [...orchestrators.keys()];
+  for (const taskId of taskIds) {
+    await stopTaskExecution(taskId);
+  }
+}

package/conductor/task.js

@@ -58,14 +58,15 @@ export function generateTaskId() {
  * 创建 Task 实例
  *
  * @param {object} params
+ * @param {string} [params.taskId]    — 外部指定的 taskId（来自 Conductor），不提供则自动生成
  * @param {string} params.title       — 任务标题
  * @param {string} params.description — 任务描述（用户原始输入 or Conductor 转译）
  * @param {string} params.scenario    — 场景: dev / writing / trading / video
  * @param {string} params.workDir     — 工作目录（创建时绑定）
  * @returns {Task}
  */
-export function createTask({ title, description, scenario, workDir }) {
-  const taskId = generateTaskId();
+export function createTask({ taskId: externalTaskId, title, description, scenario, workDir }) {
+  const taskId = externalTaskId || generateTaskId();
   const now = Date.now();
 
   return {

package/conductor/ui-messages.js

@@ -20,7 +20,7 @@ export function sendConductorMessage(msg) {
 
 /**
  * Send Conductor Claude output to frontend
- * outputType: 'text' | 'tool_use' | 'tool_result' | 'system' | 'task_created' | 'task_forwarded'
+ * outputType: 'text' | 'tool_use' | 'tool_result' | 'system' | 'task_creating' | 'task_created' | 'task_forwarded'
  */
 export function sendConductorOutput(conductor, outputType, rawMessage, extra = {}) {
   sendConductorMessage({
@@ -64,6 +64,13 @@ export function sendConductorOutput(conductor, outputType, rawMessage, extra = {
     conductor.uiMessages.push({
       source: 'conductor', type: 'system', content: text, timestamp: Date.now()
     });
+  } else if (outputType === 'task_creating') {
+    conductor.uiMessages.push({
+      source: 'conductor', type: 'task_creating',
+      taskId: extra.taskId, taskTitle: extra.taskTitle,
+      content: `Creating task: ${extra.taskTitle}...`,
+      timestamp: Date.now()
+    });
   } else if (outputType === 'task_created') {
     conductor.uiMessages.push({
       source: 'conductor', type: 'task_created',

package/conductor/worktree.js

@@ -15,6 +15,12 @@ import { promisify } from 'util';
 
 const execFile = promisify(execFileCb);
 
+/**
+ * Specialties that need read-write access (use worktree as cwd).
+ * Shared constant — imported by task-runner.js.
+ */
+export const READ_WRITE_SPECIALTIES = new Set(['coding', 'testing', 'review']);
+
 /**
  * Create a worktree for a task.
  * Called at task creation time.
@@ -147,8 +153,7 @@ export function getTaskWorktreePath(taskDir) {
  * - Read-only actors → workDir (main project directory)
  */
 export function getActorCwd(workDir, taskDir, specialty) {
-  const readWriteSpecialties = new Set(['coding', 'testing', 'review']);
-  if (readWriteSpecialties.has(specialty)) {
+  if (READ_WRITE_SPECIALTIES.has(specialty)) {
     return getTaskWorktreePath(taskDir);
   }
   return workDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.237",
+  "version": "0.1.238",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",