@bluecopa/harness 0.1.0-snapshot.74 → 0.1.0-snapshot.76

package/package.json

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

package/src/arc/org-arc-loop.ts

@@ -15,29 +15,6 @@ function renderUserMission(messages: AgentMessage[]): string {
   }).join('\n\n').trim();
 }
 
-function normalizeFocus(value: string): string {
-  return value.trim().toLowerCase().replace(/\s+/g, ' ');
-}
-
-function normalizeSummary(value: string): string {
-  return value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9\s]/g, ' ')
-    .replace(/\s+/g, ' ');
-}
-
-function summarySimilarity(a: string, b: string): number {
-  const aWords = new Set(normalizeSummary(a).split(' ').filter((word) => word.length >= 4));
-  const bWords = new Set(normalizeSummary(b).split(' ').filter((word) => word.length >= 4));
-  if (aWords.size === 0 || bWords.size === 0) return 0;
-  let intersection = 0;
-  for (const word of aWords) {
-    if (bWords.has(word)) intersection++;
-  }
-  return intersection / Math.min(aWords.size, bWords.size);
-}
-
 export class OrgArcLoop {
   private readonly runner: OrgArcRunner;
   private readonly acceptedEpisodes: OrgAcceptedEpisode[] = [];
@@ -85,8 +62,6 @@ export class OrgArcLoop {
     const mission = renderUserMission(messages);
     const maxWorkers = this.config.maxWorkers ?? 4;
     const maxAbstentions = this.config.maxAbstentions ?? 2;
-    const maxConsecutiveLowValueRounds = this.config.maxConsecutiveLowValueRounds ?? maxAbstentions;
-    const minConfidence = this.config.minConfidence ?? 0.45;
     const baseSeed = [
       ...normalizeSeedContext(this.config.processSeedContext),
       {
@@ -96,12 +71,19 @@ export class OrgArcLoop {
     ];
 
     const sessionFacts = await this.loadSessionFacts();
-    let consecutiveLowValueRounds = 0;
+    let consecutiveAbstentions = 0;
     let stopReason: string | null = null;
     const startTime = Date.now();
+    let round = 0;
 
-    for (let round = 0; round < maxWorkers; round++) {
+    while (round < maxWorkers) {
       signal.throwIfAborted();
+      const remainingWorkers = maxWorkers - round;
+      const shouldRunFinishStage = this.acceptedEpisodes.length >= 2 && remainingWorkers >= 2;
+      if (shouldRunFinishStage) {
+        break;
+      }
+
       yield {
         type: 'org_round_start',
         round,
@@ -151,7 +133,7 @@ export class OrgArcLoop {
 
       if (!workerResult) {
         yield { type: 'process_failed', id: workerId, error: 'Worker produced no result.' };
-        consecutiveLowValueRounds++;
+        round++;
         continue;
       }
 
@@ -170,7 +152,7 @@ export class OrgArcLoop {
         });
       }
 
-      const decision = await this.evaluateWorker(workerResult, minConfidence);
+      const decision = await this.evaluateWorker(workerResult);
       if (!decision.accepted) {
         const rejected: OrgRejectedEpisode = {
           workerId: workerResult.workerId,
@@ -183,7 +165,7 @@ export class OrgArcLoop {
         this.rejectedEpisodes.push(rejected);
 
         if (workerResult.orgOutput.abstained) {
-          consecutiveLowValueRounds++;
+          consecutiveAbstentions++;
           yield {
             type: 'org_worker_abstained',
             id: workerResult.workerId,
@@ -192,7 +174,6 @@ export class OrgArcLoop {
             reason: decision.reason,
           };
         } else {
-          consecutiveLowValueRounds++;
           yield {
             type: 'org_worker_rejected',
             id: workerResult.workerId,
@@ -210,7 +191,7 @@ export class OrgArcLoop {
           trace: workerResult.trace,
           orgOutput: workerResult.orgOutput,
         });
-        consecutiveLowValueRounds = 0;
+        consecutiveAbstentions = 0;
         yield {
           type: 'org_worker_accepted',
           id: workerResult.workerId,
@@ -221,10 +202,8 @@ export class OrgArcLoop {
         };
       }
 
-      if (workerResult.orgOutput.abstained && consecutiveLowValueRounds >= maxAbstentions) {
-        stopReason = `too_many_abstentions:${consecutiveLowValueRounds}`;
-      } else if (consecutiveLowValueRounds >= maxConsecutiveLowValueRounds) {
-        stopReason = `novelty_exhausted:${consecutiveLowValueRounds}`;
+      if (workerResult.orgOutput.abstained && consecutiveAbstentions >= maxAbstentions) {
+        stopReason = `too_many_abstentions:${consecutiveAbstentions}`;
       }
 
       if (stopReason && this.config.hookRunner) {
@@ -243,9 +222,102 @@ export class OrgArcLoop {
         }
       }
 
+      round++;
       if (stopReason) break;
     }
 
+    if (!stopReason) {
+      const finishRemainingWorkers = maxWorkers - round;
+      const canRunFinishStage = this.acceptedEpisodes.length >= 2 && finishRemainingWorkers >= 2;
+      if (canRunFinishStage) {
+        const firstIterator = this.runCandidateWorker(mission, round, baseSeed, sessionFacts, signal)[Symbol.asyncIterator]();
+        let first: { worker: OrgWorkerRunResult; decision: OrgEpisodeDecision } | undefined;
+        while (true) {
+          const next = await firstIterator.next();
+          if (next.done) {
+            first = next.value;
+            break;
+          }
+          const event = next.value;
+          yield event;
+        }
+        round++;
+        const secondIterator = this.runCandidateWorker(mission, round, baseSeed, sessionFacts, signal)[Symbol.asyncIterator]();
+        let second: { worker: OrgWorkerRunResult; decision: OrgEpisodeDecision } | undefined;
+        while (true) {
+          const next = await secondIterator.next();
+          if (next.done) {
+            second = next.value;
+            break;
+          }
+          const event = next.value;
+          yield event;
+        }
+        round++;
+        if (!first || !second) throw new Error('Finish stage worker did not produce a result.');
+
+        const firstAccepted = first.decision.accepted && !first.worker.orgOutput.abstained;
+        const secondAccepted = second.decision.accepted && !second.worker.orgOutput.abstained;
+
+        if (firstAccepted && secondAccepted) {
+          const winner = first.worker.orgOutput.confidence >= second.worker.orgOutput.confidence ? first : second;
+          const loser = winner === first ? second : first;
+          this.acceptedEpisodes.push({
+            workerId: winner.worker.workerId,
+            round: winner.worker.round,
+            episode: winner.worker.episode,
+            trace: winner.worker.trace,
+            orgOutput: winner.worker.orgOutput,
+          });
+          yield {
+            type: 'org_worker_accepted',
+            id: winner.worker.workerId,
+            round: winner.worker.round,
+            episodeId: winner.worker.episode.id,
+            focus: winner.worker.orgOutput.focus,
+            roleLabel: winner.worker.orgOutput.roleLabel,
+          };
+          this.rejectedEpisodes.push({
+            workerId: loser.worker.workerId,
+            round: loser.worker.round,
+            episode: loser.worker.episode,
+            trace: loser.worker.trace,
+            orgOutput: loser.worker.orgOutput,
+            reason: 'Lost final two-choice selection.',
+          });
+          yield {
+            type: 'org_worker_rejected',
+            id: loser.worker.workerId,
+            round: loser.worker.round,
+            episodeId: loser.worker.episode.id,
+            reason: 'Lost final two-choice selection.',
+            focus: loser.worker.orgOutput.focus,
+          };
+          stopReason = 'finish_stage_complete';
+        } else if (firstAccepted || secondAccepted) {
+          const winner = firstAccepted ? first : second;
+          this.acceptedEpisodes.push({
+            workerId: winner.worker.workerId,
+            round: winner.worker.round,
+            episode: winner.worker.episode,
+            trace: winner.worker.trace,
+            orgOutput: winner.worker.orgOutput,
+          });
+          yield {
+            type: 'org_worker_accepted',
+            id: winner.worker.workerId,
+            round: winner.worker.round,
+            episodeId: winner.worker.episode.id,
+            focus: winner.worker.orgOutput.focus,
+            roleLabel: winner.worker.orgOutput.roleLabel,
+          };
+          stopReason = 'finish_stage_complete';
+        } else {
+          stopReason = 'finish_stage_abstained';
+        }
+      }
+    }
+
     if (stopReason) {
       yield {
         type: 'org_stop_condition_met',
@@ -299,15 +371,14 @@ export class OrgArcLoop {
     };
   }
 
-  private async evaluateWorker(worker: OrgWorkerRunResult, minConfidence: number): Promise<OrgEpisodeDecision> {
-    const normalizedFocus = normalizeFocus(worker.orgOutput.focus);
+  private async evaluateWorker(worker: OrgWorkerRunResult): Promise<OrgEpisodeDecision> {
     const forbiddenTools = (this.config.workerDisallowedTools ?? []).filter((tool) => worker.usedTools.includes(tool));
 
     if (this.config.rejectOnForbiddenToolUse !== false && forbiddenTools.length > 0) {
       return {
         accepted: false,
         reason: `Worker used forbidden exploration tools: ${forbiddenTools.join(', ')}.`,
-        normalizedFocus,
+        normalizedFocus: '',
       };
     }
 
@@ -315,7 +386,7 @@ export class OrgArcLoop {
       return {
         accepted: false,
         reason: worker.orgOutput.noveltyReason || 'Worker abstained.',
-        normalizedFocus,
+        normalizedFocus: '',
       };
     }
 
@@ -323,35 +394,7 @@ export class OrgArcLoop {
       return {
         accepted: false,
         reason: 'Worker contribution summary was empty.',
-        normalizedFocus,
-      };
-    }
-
-    if (worker.orgOutput.confidence < minConfidence) {
-      return {
-        accepted: false,
-        reason: `Worker confidence ${worker.orgOutput.confidence.toFixed(2)} was below threshold ${minConfidence.toFixed(2)}.`,
-        normalizedFocus,
-      };
-    }
-
-    const duplicate = this.acceptedEpisodes.find((item) => normalizeFocus(item.orgOutput.focus) === normalizedFocus);
-    if (duplicate) {
-      return {
-        accepted: false,
-        reason: `Focus "${worker.orgOutput.focus}" duplicates accepted episode ${duplicate.episode.id}.`,
-        normalizedFocus,
-      };
-    }
-
-    const similar = this.acceptedEpisodes.find((item) => (
-      summarySimilarity(item.orgOutput.contributionSummary, worker.orgOutput.contributionSummary) >= 0.72
-    ));
-    if (similar) {
-      return {
-        accepted: false,
-        reason: `Contribution summary substantially overlaps accepted episode ${similar.episode.id}.`,
-        normalizedFocus,
+        normalizedFocus: '',
       };
     }
 
@@ -364,7 +407,7 @@ export class OrgArcLoop {
         return {
           accepted: false,
           reason: hookDecision.reason ?? 'AcceptEpisode hook rejected the worker contribution.',
-          normalizedFocus,
+          normalizedFocus: '',
         };
       }
     }
@@ -372,7 +415,7 @@ export class OrgArcLoop {
     return {
       accepted: true,
       reason: 'Accepted.',
-      normalizedFocus,
+      normalizedFocus: '',
     };
   }
 
@@ -384,4 +427,70 @@ export class OrgArcLoop {
       return [];
     }
   }
+
+  private async *runCandidateWorker(
+    mission: string,
+    round: number,
+    baseSeed: AgentMessage[],
+    sessionFacts: string[],
+    signal: AbortSignal,
+  ): AsyncGenerator<OrgArcEvent, { worker: OrgWorkerRunResult; decision: OrgEpisodeDecision }> {
+    yield {
+      type: 'org_round_start',
+      round,
+      acceptedCount: this.acceptedEpisodes.length,
+      rejectedCount: this.rejectedEpisodes.length,
+    };
+
+    const workerId = `org-worker-${round + 1}`;
+    const workerStream = this.runner.streamWorker({
+      mission,
+      round,
+      acceptedEpisodes: this.acceptedEpisodes,
+      workerId,
+      model: this.config.workerModel ?? 'medium',
+      seedContext: baseSeed,
+      contextFacts: [...(this.config.contextFacts ?? []), ...sessionFacts],
+      ...(this.config.workerMaxSteps != null ? { maxSteps: this.config.workerMaxSteps } : {}),
+    }, signal)[Symbol.asyncIterator]();
+
+    yield {
+      type: 'process_dispatched',
+      id: workerId,
+      action: `Autonomous worker round ${round + 1}`,
+      model: this.config.workerModel ?? 'medium',
+    };
+
+    let workerResult: OrgWorkerRunResult | undefined;
+    while (true) {
+      const next = await workerStream.next();
+      if (next.done) {
+        workerResult = next.value;
+        break;
+      }
+      const event = next.value;
+      yield { type: 'process_activity', id: workerId, activity: event.activity };
+    }
+
+    if (!workerResult) {
+      throw new Error(`Candidate worker ${workerId} produced no result.`);
+    }
+
+    yield {
+      type: 'process_completed',
+      id: workerResult.workerId,
+      episodeId: workerResult.episode.id,
+      summary: workerResult.episode.summary,
+      durationMs: workerResult.durationMs,
+    };
+
+    if (this.config.hookRunner) {
+      await this.config.hookRunner.run({
+        event: 'AfterWorker',
+        metadata: { round, mission, workerResult, acceptedEpisodes: this.acceptedEpisodes },
+      });
+    }
+
+    return { worker: workerResult, decision: await this.evaluateWorker(workerResult) };
+  }
 }

package/src/arc/org-arc-runner.ts

@@ -20,7 +20,9 @@ const DEFAULT_ORG_WORKER_SYSTEM_PROMPT = [
   'You are one autonomous worker in a self-organizing agent organization.',
   'Review the mission and the accepted prior contributions.',
   'Choose your own role based on what would add the most value now.',
-  'Produce one useful non-duplicative contribution, or abstain if nothing meaningful remains.',
+  'Contribute only if the final answer would be materially better because of your addition.',
+  'If you would mainly reframe, relabel, or slightly extend prior accepted work, abstain.',
+  'Do not contribute just because you can name another angle; abstain unless the contribution is meaningfully additive.',
   'Use tools when needed, but keep your scope focused.',
   'At the end, give a concise final response so the system can extract your structured contribution.',
 ].join(' ');
@@ -104,8 +106,9 @@ function buildOrgWorkerPrompt(request: OrgWorkerRequest): string {
     `Round: ${request.round + 1}`,
     '',
     'Decide for yourself what role is most useful right now.',
-    'Add one distinct contribution that moves the mission forward.',
-    'If prior accepted contributions already cover the useful angles, abstain.',
+    'Contribute only if your addition would materially improve the final answer.',
+    'If prior accepted contributions already make the answer structurally sufficient, abstain.',
+    'If you are only adding a nearby variation, abstain.',
   ].join('\n');
 }
 

package/src/arc/org-types.ts

@@ -75,8 +75,6 @@ export interface OrgWorkerRequest {
 export interface OrgArcLoopConfig extends ArcLoopConfig {
   maxWorkers?: number;
   maxAbstentions?: number;
-  maxConsecutiveLowValueRounds?: number;
-  minConfidence?: number;
   workerModel?: ModelTier;
   synthesisModel?: ModelTier;
   workerMaxSteps?: number;

package/tests/arc/org-arc-loop.test.ts

@@ -113,7 +113,6 @@ describe('OrgArcLoop', () => {
       longTermStore: new InMemoryLongTermStore(),
       maxWorkers: 4,
       maxAbstentions: 1,
-      minConfidence: 0.5,
     });
 
     const events = [];
@@ -144,6 +143,7 @@ describe('OrgArcLoop', () => {
         toolCalls: [{ toolName: 'Write', input: { path: '/tmp/out.txt', content: 'nope' }, toolCallId: 'call-1' }],
       },
       { text: 'Finished after writing a file.', toolCalls: [] },
+      { text: 'I have nothing meaningful to add.', toolCalls: [] },
     );
 
     generateObjectQueue.push({
@@ -155,6 +155,15 @@ describe('OrgArcLoop', () => {
       openQuestions: [],
       nextSuggestions: [],
       confidence: 0.92,
+    }, {
+      roleLabel: 'researcher',
+      focus: 'summary',
+      contributionSummary: '',
+      abstained: true,
+      noveltyReason: 'Nothing meaningful remains after the rejected artifact attempt.',
+      openQuestions: [],
+      nextSuggestions: [],
+      confidence: 0.55,
     });
 
     streamTextQueue.push([{ type: 'text-delta', text: 'Synthesis.' }]);
@@ -174,7 +183,6 @@ describe('OrgArcLoop', () => {
       longTermStore: new InMemoryLongTermStore(),
       maxWorkers: 2,
       maxAbstentions: 1,
-      maxConsecutiveLowValueRounds: 1,
       workerDisallowedTools: ['Write'],
     });
 
@@ -192,7 +200,94 @@ describe('OrgArcLoop', () => {
     const stopped = events.find((event) => event.type === 'org_stop_condition_met');
     expect(stopped?.type).toBe('org_stop_condition_met');
     if (stopped?.type === 'org_stop_condition_met') {
-      expect(stopped.reason).toContain('novelty_exhausted');
+      expect(stopped.reason).toContain('too_many_abstentions');
+    }
+  });
+
+  it('runs a final two-choice round and keeps only one winner when both candidates contribute', async () => {
+    generateTextQueue.push(
+      { text: 'Core literature view.', toolCalls: [] },
+      { text: 'Recent developments.', toolCalls: [] },
+      { text: 'Mission studies angle.', toolCalls: [] },
+      { text: 'Observational constraints angle.', toolCalls: [] },
+    );
+
+    generateObjectQueue.push(
+      {
+        roleLabel: 'surveyor',
+        focus: 'core literature',
+        contributionSummary: 'Summarizes the core literature and the main interpretive threads.',
+        abstained: false,
+        noveltyReason: 'Provides the foundational overview.',
+        openQuestions: [],
+        nextSuggestions: ['Look at recent developments.'],
+        confidence: 0.76,
+      },
+      {
+        roleLabel: 'tracker',
+        focus: 'recent developments',
+        contributionSummary: 'Adds the most recent developments and updates to the literature.',
+        abstained: false,
+        noveltyReason: 'Adds recent work that the core survey does not cover.',
+        openQuestions: [],
+        nextSuggestions: ['Probe one last missing angle if it materially improves the answer.'],
+        confidence: 0.73,
+      },
+      {
+        roleLabel: 'planner',
+        focus: 'mission studies',
+        contributionSummary: 'Adds mission concepts motivated by the object and the literature.',
+        abstained: false,
+        noveltyReason: 'Adds one last missing implication bucket.',
+        openQuestions: [],
+        nextSuggestions: [],
+        confidence: 0.62,
+      },
+      {
+        roleLabel: 'observer',
+        focus: 'observational constraints',
+        contributionSummary: 'Adds the strongest observational constraints and how they shape interpretation.',
+        abstained: false,
+        noveltyReason: 'Adds a competing final angle.',
+        openQuestions: [],
+        nextSuggestions: [],
+        confidence: 0.81,
+      },
+    );
+
+    streamTextQueue.push([{ type: 'text-delta', text: 'Synthesis.' }]);
+
+    const loop = new OrgArcLoop({
+      taskId: 'task-3',
+      sessionId: 'session-3',
+      toolProvider: createToolProvider(),
+      processTools: {},
+      episodeStore: new InMemoryEpisodeStore(),
+      sessionMemoStore: new InMemorySessionMemoStore(),
+      longTermStore: new InMemoryLongTermStore(),
+      maxWorkers: 4,
+      maxAbstentions: 2,
+    });
+
+    const events = [];
+    for await (const event of loop.stream([{ role: 'user', content: 'Research the topic from a few angles and synthesize.' }], new AbortController().signal)) {
+      events.push(event);
+    }
+
+    const accepted = events.filter((event) => event.type === 'org_worker_accepted');
+    const rejected = events.filter((event) => event.type === 'org_worker_rejected');
+
+    expect(accepted).toHaveLength(3);
+    expect(rejected).toHaveLength(1);
+    expect(rejected[0]?.type).toBe('org_worker_rejected');
+    if (rejected[0]?.type === 'org_worker_rejected') {
+      expect(rejected[0].reason).toBe('Lost final two-choice selection.');
+    }
+
+    const stopped = events.find((event) => event.type === 'org_stop_condition_met');
+    expect(stopped?.type).toBe('org_stop_condition_met');
+    if (stopped?.type === 'org_stop_condition_met') {
+      expect(stopped.reason).toBe('finish_stage_complete');
     }
   });
 });