@bluecopa/harness 0.1.0-snapshot.24 → 0.1.0-snapshot.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluecopa/harness",
-  "version": "0.1.0-snapshot.24",
+  "version": "0.1.0-snapshot.26",
   "description": "Provider-agnostic TypeScript agent framework",
   "license": "UNLICENSED",
   "scripts": {

package/src/arc/arc-loop.ts

@@ -77,6 +77,7 @@ export class ArcLoop {
   private readonly resilience: ResiliencePolicy | undefined;
   private readonly traceWriter: ((event: TraceEvent) => void) | undefined;
   private readonly tracedRunning = new Set<string>();
+  private readonly reportedCompletions = new Set<string>();
   private readonly processListeners: Promise<void>[] = [];
   private readonly skillRouter: SkillRouter | undefined;
   private skillSummaries: SkillSummary[] | null = null;
@@ -421,9 +422,10 @@ export class ArcLoop {
       this.trace({ type: 'turn_end', turn });
       yield { type: 'turn_end', turn };
 
-      // Wait for at least one process to reach a terminal state.
-      // We poll process.status (set directly by createProcess's floating promise)
-      // rather than consuming the outbox (which listenToProcess already reads).
+      // Wait for all processes dispatched this turn to reach a terminal state.
+      // When the orchestrator dispatches N parallel threads, there's no useful
+      // work it can do with partial results — giving it a turn early just wastes
+      // an LLM call on empty Check loops.
       const active = [...this.processes.values()].filter(
         p => p.status === 'running' || p.status === 'pending',
       );
@@ -431,7 +433,7 @@ export class ArcLoop {
         const deadline = Date.now() + (this.config.processTimeout ?? 120_000);
         await new Promise<void>(resolve => {
           const check = () => {
-            if (active.some(p => p.status !== 'running' && p.status !== 'pending') || Date.now() > deadline) {
+            if (active.every(p => p.status !== 'running' && p.status !== 'pending') || Date.now() > deadline) {
               resolve();
             } else {
               setTimeout(check, 10);
@@ -440,6 +442,32 @@ export class ArcLoop {
           check();
         });
       }
+
+      // Inject process completion messages into the orchestrator's conversation
+      // so it sees episodeIds and can pass them as contextEpisodeIds.
+      const completionMessages: AgentMessage[] = [];
+      for (const [id, proc] of this.processes) {
+        if (proc.result && !this.reportedCompletions.has(id)) {
+          this.reportedCompletions.add(id);
+          const ep = proc.result.episode;
+          const status = proc.result.success ? 'success' : `failed: ${proc.result.error ?? 'unknown'}`;
+          completionMessages.push({
+            role: 'user',
+            content: `[Thread ${id} completed] (episodeId: ${ep.id}) — ${status}\n${ep.summary}`,
+          });
+        }
+      }
+      if (completionMessages.length > 0) {
+        this.ctx.recordTurn({
+          role: 'process_result',
+          messages: completionMessages,
+          tokenEstimate: completionMessages.reduce((s, m) => {
+            const text = typeof m.content === 'string' ? m.content : getTextContent(m.content);
+            return s + estimateTokens(text);
+          }, 0),
+          timestamp: Date.now(),
+        });
+      }
     }
 
     await this.waitForProcessListeners();