@yeaft/webchat-agent 0.1.235 → 0.1.236

package/conductor/conductor-claude.js

@@ -21,7 +21,6 @@ import {
   getConductorHome, ensureConductorHome,
   loadState, saveState, updateTaskInState, initTaskDir
 } from './persistence.js';
-import { startTaskExecution } from './task-runner.js';
 
 // =====================================================================
 // Claude Session ID Persistence
@@ -192,7 +191,6 @@ export async function sendToConductor(conductor, 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 }
@@ -330,18 +328,6 @@ 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) {
@@ -353,15 +339,10 @@ 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',
@@ -386,11 +367,6 @@ 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

package/conductor/index.js

@@ -1,13 +1,12 @@
 /**
  * Conductor — Module Entry
  *
- * Exports core subsystems:
+ * Exports three 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 ----
@@ -64,11 +63,3 @@ export {
   getTaskWorktreePath,
   getActorCwd
 } from './worktree.js';
-
-// ---- Task Runner (Orchestrator ↔ Actor bridge) ----
-export {
-  startTaskExecution,
-  stopTaskExecution,
-  stopAllTaskExecutions,
-  getOrchestrator
-} from './task-runner.js';

package/conductor/session.js

@@ -16,7 +16,6 @@ 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
@@ -165,7 +164,6 @@ export async function stopConductor() {
   if (!conductor) return;
 
   conductor.status = 'stopped';
-  await stopAllTaskExecutions();
   await stopConductorClaude(conductor);
 
   sendConductorOutput(conductor, 'system', {

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_creating' | 'task_created' | 'task_forwarded'
+ * outputType: 'text' | 'tool_use' | 'tool_result' | 'system' | 'task_created' | 'task_forwarded'
  */
 export function sendConductorOutput(conductor, outputType, rawMessage, extra = {}) {
   sendConductorMessage({
@@ -64,13 +64,6 @@ 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/package.json

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

package/conductor/task-runner.js

@@ -1,287 +0,0 @@
-/**
- * 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';
-
-// =====================================================================
-// 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;
-}
-
-// =====================================================================
-// Read-write specialties (need worktree cwd)
-// =====================================================================
-
-const READ_WRITE_SPECIALTIES = new Set(['coding', 'testing', 'review']);
-
-// =====================================================================
-// 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;
-
-          resolveResult(result);
-        },
-        onError: (instanceId, error) => {
-          console.error(`[TaskRunner] Actor ${instanceId} failed for task ${taskId}:`, error.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);
-    }
-  };
-}
-
-// =====================================================================
-// 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({
-      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(() => {});
-  }
-}
-
-/**
- * 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}`);
-  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);
-  }
-}