iriai-build 0.2.6 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iriai-build",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Iriai Build tool — AI agent orchestration CLI",
   "type": "module",
   "bin": {

package/v3/agent-supervisor.js

@@ -192,12 +192,18 @@ export class AgentSupervisor extends EventEmitter {
     console.log(`[supervisor] Scheduling retry ${updatedAgent.retry_count}/${agent.max_retries} for ${agent.agent_key} in ${backoffS}s (${isFastExit ? "fast-exit" : "normal"})`);
 
     const entry = this._processes[agent.agent_key] || {};
-    entry.retryTimer = setTimeout(() => {
-      const result = promptFn(updatedAgent);
-      // promptFn can return a string (prompt only) or { prompt, continue } object
-      const prompt = typeof result === "string" ? result : result.prompt;
-      const spawnOpts = typeof result === "string" ? {} : { continue: !!result.continue };
-      this.spawn(agentId, prompt, spawnOpts);
+    entry.retryTimer = setTimeout(async () => {
+      try {
+        const result = await promptFn(updatedAgent);
+        // promptFn can return null (already handled spawn), a string, or { prompt, continue }
+        if (result == null) return;
+        const prompt = typeof result === "string" ? result : result.prompt;
+        const spawnOpts = typeof result === "string" ? {} : { continue: !!result.continue };
+        this.spawn(agentId, prompt, spawnOpts);
+      } catch (err) {
+        console.error(`[supervisor] Retry callback error for ${agent.agent_key}:`, err.message);
+        queries.updateAgentStatus(agentId, "crashed");
+      }
     }, backoffS * 1000);
     this._processes[agent.agent_key] = entry;
 

package/v3/operator.js

@@ -25,7 +25,7 @@ import {
  * @param {AgentSupervisor} opts.supervisor - Agent supervisor instance
  * @param {number} opts.agentId - Operator agent DB id
  */
-export async function invokeOperator({ feature, operatorDir, flDir, featureDir, userMessage, supervisor, agentId, planDir, activePlanningRole }) {
+export async function invokeOperator({ feature, operatorDir, flDir, featureDir, userMessage, supervisor, agentId, planDir, activePlanningRole, continue: useContinue }) {
   // 1. Assemble context from SQLite (async — Haiku summarization is non-blocking)
   const history = await assembleHistory(feature.id);
   const activeAgents = assembleActiveAgents(feature.id);
@@ -49,10 +49,9 @@ export async function invokeOperator({ feature, operatorDir, flDir, featureDir,
     directoryMap,
   });
 
-  // 3. Spawn claude via supervisor with --continue for session context
-  // The supervisor handles PID tracking, exit detection, .runner.log
-  // Response flows through .agent-response → fileIO → slack adapter
-  supervisor.spawn(agentId, prompt, { continue: true });
+  // 3. Spawn claude via supervisor — default to --continue for session context,
+  // but allow caller to force a fresh session (e.g. after "Prompt is too long")
+  supervisor.spawn(agentId, prompt, { continue: useContinue !== undefined ? useContinue : true });
 
   // Record the event
   queries.insertEvent(feature.id, "user-message", "bridge", `Operator invoked for: ${userMessage.slice(0, 100)}`);

package/v3/orchestrator.js

@@ -2232,6 +2232,11 @@ export class Orchestrator {
 
     // Invoke ephemeral operator with planning-phase context
     const planDir = tree.plansDir || path.join(tree.featureDir, "plans");
+
+    // Stash context for retry if "Prompt is too long" — readSignal already deleted the file
+    if (!this._lastOperatorContext) this._lastOperatorContext = {};
+    this._lastOperatorContext[feature.slug] = { userMessage, planDir, tree, feature };
+
     try {
       await invokeOperator({
         feature,
@@ -2263,6 +2268,8 @@ export class Orchestrator {
     if (exitCode === 0) {
       queries.updateAgentStatus(agentId, "idle");
       queries.resetAgentRetry(agentId);
+      // Clean up stashed context
+      if (this._lastOperatorContext) delete this._lastOperatorContext[feature.slug];
       return;
     }
 
@@ -2275,8 +2282,29 @@ export class Orchestrator {
 
     console.log(`[orchestrator] Operator exited with code ${exitCode} after ${elapsed}ms — scheduling retry`);
 
-    const retried = this.supervisor.scheduleRetry(agentId, () => {
-      // On retry, assembleHistory will re-summarize with a tighter budget
+    // Capture stashed context for the retry closure
+    const stashedCtx = this._lastOperatorContext?.[feature.slug];
+
+    const retried = this.supervisor.scheduleRetry(agentId, async () => {
+      // Retry with continue:false to start a fresh session (old session hit context limit).
+      // Re-invoke the full Operator with the original user message so it doesn't lose context.
+      if (stashedCtx) {
+        console.log(`[orchestrator] Operator retry: re-invoking with original user message (continue:false)`);
+        const freshFeature = queries.getFeatureById(feature.id) || feature;
+        await invokeOperator({
+          feature: freshFeature,
+          operatorDir: tree.operator,
+          flDir: tree.featureLead,
+          featureDir: tree.featureDir,
+          userMessage: stashedCtx.userMessage,
+          supervisor: this.supervisor,
+          agentId,
+          planDir: stashedCtx.planDir,
+          activePlanningRole: freshFeature.active_planning_role,
+          continue: false,
+        });
+        return null; // invokeOperator already called supervisor.spawn
+      }
       return { prompt: "Re-read your CLAUDE.md and check for pending relay queue items or user messages. Write a status update to .agent-response if there's nothing to relay.", continue: false };
     });