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

package/package.json

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

package/src/arc/arc-loop.ts

@@ -632,12 +632,15 @@ export class ArcLoop {
     // Resolve skill — pass content + pre-read sub-guides
     const skillRefPromise = this.skillResolver
       ? this.skillResolver.resolve(request.action, profileSkills).then(r => {
-          if (r) {
-            resolvedSkillName = r.name;
-            resolvedSkillPath = r.path;
-            return { name: r.name, path: r.path, content: r.systemPrompt, subGuides: r.subGuides };
-          }
-          return null;
+          if (!r) return null;
+          resolvedSkillName = r.name;
+          resolvedSkillPath = r.path;
+          return {
+            name: r.name,
+            path: r.path,
+            ...(r.systemPrompt ? { content: r.systemPrompt } : {}),
+            ...(r.subGuides ? { subGuides: r.subGuides } : {}),
+          };
         })
       : undefined;
     // Keep legacy promise for backward compat (returns null — progressive loading handles it)
@@ -661,20 +664,22 @@ export class ArcLoop {
       processTimeout: this.config.processTimeout ?? 120_000,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       processTools: (profile?.tools ?? globalTools) as any,
-      processSystemPrompt: profile?.systemPrompt ?? this.config.processSystemPrompt,
-      allowedToolNames: profile?.allowedToolNames,
-      outputSchema: profile?.outputSchema,
-      demoMessages: profile?.demoMessages,
-      toolChoice: this.config.processToolChoice,
-      resultPager: this.config.resultPager,
-      resultPageThreshold: this.config.resultPageThreshold,
-      pagingExclude: this.config.pagingExclude,
-      maxToolResultLength: this.config.maxToolResultLength,
+      ...(profile?.systemPrompt ?? this.config.processSystemPrompt
+        ? { processSystemPrompt: profile?.systemPrompt ?? this.config.processSystemPrompt }
+        : {}),
+      ...(profile?.allowedToolNames ? { allowedToolNames: profile.allowedToolNames } : {}),
+      ...(profile?.outputSchema ? { outputSchema: profile.outputSchema } : {}),
+      ...(profile?.demoMessages ? { demoMessages: profile.demoMessages } : {}),
+      ...(this.config.processToolChoice ? { toolChoice: this.config.processToolChoice } : {}),
+      ...(this.config.resultPager ? { resultPager: this.config.resultPager } : {}),
+      ...(this.config.resultPageThreshold != null ? { resultPageThreshold: this.config.resultPageThreshold } : {}),
+      ...(this.config.pagingExclude ? { pagingExclude: this.config.pagingExclude } : {}),
+      ...(this.config.maxToolResultLength != null ? { maxToolResultLength: this.config.maxToolResultLength } : {}),
       contextFacts: threadContextFacts,
-      maxContextTokens: this.config.maxContextTokens,
-      processSeedContext: this.config.processSeedContext,
-      skillPromptPromise,
-      skillRefPromise,
+      ...(this.config.maxContextTokens != null ? { maxContextTokens: this.config.maxContextTokens } : {}),
+      ...(this.config.processSeedContext ? { processSeedContext: this.config.processSeedContext } : {}),
+      ...(skillPromptPromise ? { skillPromptPromise } : {}),
+      ...(skillRefPromise ? { skillRefPromise } : {}),
       parentSignal,
       ...pickDefined(this.config, [
         'hookRunner',

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

@@ -1,6 +1,13 @@
+import { generateObject } from 'ai';
+import { anthropic as defaultAnthropicProvider } from '@ai-sdk/anthropic';
+import { z } from 'zod';
 import { getTextContent, type AgentMessage } from '../agent/types';
+import { DEFAULT_MODEL_MAP, resolveModel, type ModelTier } from './arc-types';
+import type { ModelFactory } from './types';
+import { builtinTools } from './tools';
 import { type OrgAcceptedEpisode, type OrgArcEvent, type OrgArcLoopConfig, type OrgArcRunResult, type OrgEpisodeDecision, type OrgRejectedEpisode, type OrgWorkerRunResult } from './org-types';
 import { OrgArcRunner } from './org-arc-runner';
+import { buildOrchestratorPrompt } from './profile-builder';
 
 function normalizeSeedContext(ctx: string | AgentMessage[] | undefined): AgentMessage[] {
   if (!ctx) return [];
@@ -15,14 +22,39 @@ function renderUserMission(messages: AgentMessage[]): string {
   }).join('\n\n').trim();
 }
 
+const orgDirectReplySchema = z.object({
+  route: z.enum(['direct', 'workers']).describe('Whether to answer now with no workers, or continue into worker rounds.'),
+  response: z.string().default('').describe('The exact user-facing response when route is direct. Empty when route is workers.'),
+  reason: z.string().default('').describe('Short rationale for the routing decision.'),
+});
+
+function renderCoordinatorContext(messages: AgentMessage[]): string {
+  return messages.map((message) => {
+    const prefix = message.role === 'user'
+      ? 'User'
+      : message.role === 'assistant'
+        ? 'Assistant'
+        : message.role === 'system'
+          ? 'System'
+          : 'Context';
+    return `${prefix}: ${getTextContent(message.content)}`;
+  }).join('\n\n').trim();
+}
+
 export class OrgArcLoop {
   private readonly runner: OrgArcRunner;
   private readonly acceptedEpisodes: OrgAcceptedEpisode[] = [];
   private readonly rejectedEpisodes: OrgRejectedEpisode[] = [];
   private readonly config: OrgArcLoopConfig;
+  private readonly createModel: ModelFactory;
+  private readonly modelMap: Record<ModelTier, string>;
+  private readonly coordinatorModel: string;
 
   constructor(config: OrgArcLoopConfig) {
     this.config = config;
+    this.createModel = config.createModel ?? defaultAnthropicProvider;
+    this.modelMap = { ...DEFAULT_MODEL_MAP, ...(config.modelMap ?? {}) };
+    this.coordinatorModel = resolveModel(config.model ?? 'strong', this.modelMap, this.modelMap.strong);
     this.runner = new OrgArcRunner({
       toolProvider: config.toolProvider,
       episodeStore: config.episodeStore,
@@ -32,7 +64,7 @@ export class OrgArcLoop {
       ...(config.modelMap ? { modelMap: config.modelMap } : {}),
       ...((config.workerMaxSteps ?? config.processMaxSteps) != null ? { workerMaxSteps: config.workerMaxSteps ?? config.processMaxSteps } : {}),
       ...(config.processTimeout != null ? { processTimeout: config.processTimeout } : {}),
-      ...(config.processTools ? { processTools: config.processTools as Record<string, unknown> } : {}),
+      processTools: (config.processTools ?? builtinTools) as Record<string, unknown>,
       ...(config.workerSystemPrompt ? { workerSystemPrompt: config.workerSystemPrompt } : {}),
       ...(config.synthesisSystemPrompt ? { synthesisSystemPrompt: config.synthesisSystemPrompt } : {}),
       ...(config.workerAllowedTools ? { workerAllowedTools: config.workerAllowedTools } : {}),
@@ -41,6 +73,9 @@ export class OrgArcLoop {
       ...(config.permissionManager ? { permissionManager: config.permissionManager } : {}),
       ...(config.telemetry ? { telemetry: config.telemetry } : {}),
       ...(config.executeToolAction ? { executeToolAction: config.executeToolAction } : {}),
+      ...(config.askUser ? { askUser: config.askUser } : {}),
+      ...(config.tellUser ? { tellUser: config.tellUser } : {}),
+      ...(config.downloadRawFile ? { downloadRawFile: config.downloadRawFile } : {}),
     });
   }
 
@@ -59,7 +94,23 @@ export class OrgArcLoop {
   }
 
   async *stream(messages: AgentMessage[], signal: AbortSignal): AsyncGenerator<OrgArcEvent> {
+    const startTime = Date.now();
     const mission = renderUserMission(messages);
+    const directResponse = await this.maybeReplyDirectly(messages, mission, signal);
+    if (directResponse) {
+      yield { type: 'text_delta', text: directResponse };
+      yield {
+        type: 'done',
+        output: directResponse,
+        stats: {
+          turns: 1,
+          processes: 0,
+          durationMs: Date.now() - startTime,
+        },
+      };
+      return;
+    }
+
     const maxWorkers = this.config.maxWorkers ?? 4;
     const maxAbstentions = this.config.maxAbstentions ?? 2;
     const baseSeed = [
@@ -73,7 +124,6 @@ export class OrgArcLoop {
     const sessionFacts = await this.loadSessionFacts();
     let consecutiveAbstentions = 0;
     let stopReason: string | null = null;
-    const startTime = Date.now();
     let round = 0;
 
     while (round < maxWorkers) {
@@ -493,4 +543,65 @@ export class OrgArcLoop {
 
     return { worker: workerResult, decision: await this.evaluateWorker(workerResult) };
   }
+
+  private buildCoordinatorPrompt(): string | null {
+    if (this.config.systemPrompt?.trim()) {
+      return [
+        this.config.systemPrompt.trim(),
+        '',
+        'You are deciding whether this OrgArc run should answer directly with no worker rounds, or continue into worker rounds.',
+        'Prefer a direct answer for greetings, thanks, clarifications, simple factual questions, or summaries already supported by context.',
+        'Choose worker rounds only when tools, repo inspection, command execution, file changes, or materially different parallel contributions are likely to improve the answer.',
+        'If you choose a direct answer, write the exact reply in simple English and keep it brief.',
+      ].join('\n');
+    }
+
+    if (this.config.processProfiles && Object.keys(this.config.processProfiles).length > 0) {
+      return [
+        buildOrchestratorPrompt(this.config.processProfiles),
+        '',
+        'This decision happens before any worker rounds start.',
+        'If the task can be answered well without workers, choose a direct answer and provide the exact user-facing reply.',
+      ].join('\n');
+    }
+
+    return null;
+  }
+
+  private async maybeReplyDirectly(
+    messages: AgentMessage[],
+    mission: string,
+    signal: AbortSignal,
+  ): Promise<string | null> {
+    const systemPrompt = this.buildCoordinatorPrompt();
+    if (!systemPrompt) return null;
+
+    const seedContext = normalizeSeedContext(this.config.processSeedContext);
+    const seedText = seedContext.length > 0 ? renderCoordinatorContext(seedContext) : '';
+
+    try {
+      const { object } = await generateObject({
+        model: this.createModel(this.coordinatorModel),
+        schema: orgDirectReplySchema,
+        system: systemPrompt,
+        prompt: [
+          'Conversation:',
+          renderCoordinatorContext(messages),
+          '',
+          seedText ? `Process seed context:\n${seedText}\n` : '',
+          `Mission:\n${mission}`,
+          '',
+          'Return route="direct" only if the user should receive an immediate answer with no worker rounds.',
+          'Return route="workers" when worker rounds are needed.',
+        ].filter(Boolean).join('\n'),
+        abortSignal: signal,
+      });
+
+      if (object.route !== 'direct') return null;
+      const response = object.response.trim();
+      return response ? response : null;
+    } catch {
+      return null;
+    }
+  }
 }

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

@@ -21,8 +21,11 @@ const DEFAULT_ORG_WORKER_SYSTEM_PROMPT = [
   'Review the mission and the accepted prior contributions.',
   'Choose your own role based on what would add the most value now.',
   'Contribute only if the final answer would be materially better because of your addition.',
+  'If the accepted contributions already support a strong final answer, abstain.',
   '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.',
+  'Do not add a fourth angle unless it would change the final synthesis in a meaningful way.',
+  'If your addition would not deserve its own paragraph, section, or bullet in the final answer, abstain.',
   '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(' ');
@@ -95,7 +98,7 @@ function buildAcceptedEpisodeSeed(acceptedEpisodes: OrgAcceptedEpisode[]): Agent
 
   return [{
     role: 'system',
-    content: `Accepted prior contributions:\n\n${lines.join('\n\n')}\n\nUse these to avoid repetition. If you need more detail, refer to the episode IDs in your context.`,
+    content: `Accepted prior contributions:\n\n${lines.join('\n\n')}\n\nUse these to avoid repetition. If these contributions already support a strong final answer, abstain. If you need more detail, refer to the episode IDs in your context.`,
   }];
 }
 
@@ -109,6 +112,8 @@ function buildOrgWorkerPrompt(request: OrgWorkerRequest): string {
     '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.',
+    'If your addition would not clearly earn its own paragraph, section, or bullet in the final answer, abstain.',
+    'Do not add another angle just because one exists.',
   ].join('\n');
 }
 

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

@@ -69,6 +69,43 @@ describe('OrgArcLoop', () => {
     streamTextQueue = [];
   });
 
+  it('replies directly without worker rounds when the coordinator prompt can answer simply', async () => {
+    generateObjectQueue.push({
+      route: 'direct',
+      response: 'Hello! How can I help?',
+      reason: 'Simple greeting.',
+    });
+
+    const loop = new OrgArcLoop({
+      taskId: 'task-direct',
+      sessionId: 'session-direct',
+      toolProvider: createToolProvider(),
+      processTools: {},
+      episodeStore: new InMemoryEpisodeStore(),
+      sessionMemoStore: new InMemorySessionMemoStore(),
+      longTermStore: new InMemoryLongTermStore(),
+      systemPrompt: 'You are an orchestrator. Respond directly to greetings and simple questions when no tools are needed.',
+    });
+
+    const events = [];
+    for await (const event of loop.stream([{ role: 'user', content: 'hello' }], new AbortController().signal)) {
+      events.push(event);
+    }
+
+    expect(events.some((event) => event.type === 'org_round_start')).toBe(false);
+    expect(events.some((event) => event.type === 'org_synthesis_started')).toBe(false);
+
+    const deltas = events.filter((event) => event.type === 'text_delta').map((event) => event.text).join('');
+    expect(deltas).toBe('Hello! How can I help?');
+
+    const done = [...events].reverse().find((event) => event.type === 'done');
+    expect(done?.type).toBe('done');
+    if (done?.type === 'done') {
+      expect(done.output).toBe('Hello! How can I help?');
+      expect(done.stats.processes).toBe(0);
+    }
+  });
+
   it('accepts novel worker output, stops after abstention, and synthesizes final output', async () => {
     generateTextQueue.push(
       { text: 'I analyzed the architecture and found the main leverage point.', toolCalls: [] },

package/tests/arc/process-profiles.test.ts

@@ -25,7 +25,7 @@ let orchestratorScript: Array<() => unknown> = [];
 function mockStreamText() {
   const callNum = orchestratorCallCount++;
   if (callNum < orchestratorScript.length) {
-    return orchestratorScript[callNum]();
+    return orchestratorScript[callNum]!();
   }
   // Default: final text
   return {

package/tests/arc/result-paging.test.ts

@@ -341,7 +341,9 @@ describe('Context Paging', () => {
     const toolMessage = result.messages.find(m => m.role === 'tool' && m.toolResults?.[0]?.toolName === 'ReadFullResult');
     expect(toolMessage).toBeDefined();
     expect(toolMessage!.content).toContain('expired or not found');
-    expect(toolMessage!.toolResults![0].isError).toBe(true);
+    const firstToolResult = toolMessage!.toolResults?.[0];
+    expect(firstToolResult).toBeDefined();
+    expect(firstToolResult!.isError).toBe(true);
   });
 
   it('falls back to truncation when pager.page() throws', async () => {