@yeaft/webchat-agent 0.1.233 → 0.1.235

package/conductor/conductor-claude.js

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

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 ----
@@ -63,3 +64,11 @@ 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,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
@@ -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,287 @@
+/**
+ * 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);
+  }
+}

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/package.json

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