ennodia 0.1.1 → 0.2.0

package/src/runs.ts

@@ -71,12 +71,17 @@ export type RunStartInput = {
   mode?: RunMode;
   compare?: RunCompareMode;
   cwd?: string;
+  isolateCwd?: boolean;
   model?: string;
   timeoutMs?: number;
   refresh?: boolean;
   judgeHarnessId?: string;
   judgeModel?: string;
+  advisorHarnessId?: string;
+  advisorModel?: string;
+  /** @deprecated Use advisorHarnessId. */
   synthesizerHarnessId?: string;
+  /** @deprecated Use advisorModel. */
   synthesizerModel?: string;
   maxOutputChars?: number;
   skills?: Skill[];
@@ -94,6 +99,11 @@ export type RunView = {
   endedAt?: string;
   elapsedMs: number;
   plan: RoutePlan;
+  /** True when harnessId was explicitly forced, meaning plan.selected /
+   * plan.candidates reflect what the auto-router would have chosen and were
+   * NOT what actually ran. Check selectedHarnessIds for the harness(es) that
+   * actually executed. */
+  harnessOverridden: boolean;
   selectedHarnessIds: string[];
   taskIds: string[];
   compareId?: string;
@@ -108,6 +118,11 @@ export type RunView = {
   eventCount: number;
   events: RunEvent[];
   appliedSkills?: AppliedSkillInfo[];
+  /** Skills discoverable in cwd's native skill directories but not part of
+   * this run's appliedSkills. A harness may self-select these on its own
+   * initiative even though this run didn't request them. Populated by
+   * EnnodiaCore.startRun; empty when cwd was not provided. */
+  unrequestedSkillsPresent?: string[];
   budget: BudgetCheck;
 };
 
@@ -152,6 +167,7 @@ type InternalRun = {
   compareMode: RunCompareMode;
   prompt: string;
   plan: RoutePlan;
+  harnessOverridden: boolean;
   selectedHarnessIds: string[];
   taskIds: string[];
   compareId?: string;
@@ -204,6 +220,8 @@ export class RunManager {
       throw new Error("RunManager is shutting down.");
     }
 
+    validateRunAdvisorAliases(input);
+
     const harnesses = await this.dependencies.discoverHarnesses({
       refresh: input.refresh,
     });
@@ -248,6 +266,7 @@ export class RunManager {
       compareMode,
       prompt: input.prompt,
       plan,
+      harnessOverridden: Boolean(input.harnessId),
       selectedHarnessIds,
       taskIds: [],
       createdAtMs: now,
@@ -368,6 +387,7 @@ export class RunManager {
       const started = this.dependencies.taskManager.start(adapter, discovery, {
         prompt: input.prompt,
         cwd: input.cwd,
+        isolateCwd: input.isolateCwd,
         model: input.model,
         timeoutMs: input.timeoutMs,
         skills: input.skills,
@@ -466,6 +486,8 @@ export class RunManager {
       taskIds,
       judgeHarnessId: input.judgeHarnessId,
       judgeModel: input.judgeModel,
+      advisorHarnessId: input.advisorHarnessId,
+      advisorModel: input.advisorModel,
       synthesizerHarnessId: input.synthesizerHarnessId,
       synthesizerModel: input.synthesizerModel,
       cwd: input.cwd,
@@ -485,13 +507,15 @@ export class RunManager {
       return;
     }
 
-    if (result.status === "succeeded" && result.synthesis?.text.trim()) {
+    const finalAnswer = result.advisor?.answer.trim() ||
+      result.synthesis?.text.trim();
+    if (result.status === "succeeded" && finalAnswer) {
       this.pushEvent(run, {
         type: "compare-succeeded",
         compareId: compare.id,
-        message: "Compare returned the final answer.",
+        message: "Compare returned the Advisor recommendation.",
       });
-      this.succeedRun(run, result.synthesis.text.trim());
+      this.succeedRun(run, finalAnswer);
       return;
     }
 
@@ -566,6 +590,7 @@ export class RunManager {
       endedAt: run.endedAtMs ? new Date(run.endedAtMs).toISOString() : undefined,
       elapsedMs: Math.max(0, end - run.createdAtMs),
       plan: run.plan,
+      harnessOverridden: run.harnessOverridden,
       selectedHarnessIds: run.selectedHarnessIds,
       taskIds: run.taskIds,
       compareId: run.compareId,
@@ -865,21 +890,25 @@ function eventFromTask(task: TaskView): Omit<RunEvent, "at"> {
   };
 }
 
+function taskOutputText(task: TaskView): string {
+  return task.finalMessage?.trim() ||
+    `${task.stdout.trim()}\n${task.stderr.trim()}`.trim();
+}
+
 function hasComparableOutput(task: TaskView): boolean {
-  return `${task.stdout.trim()}\n${task.stderr.trim()}`.trim().length > 0;
+  return taskOutputText(task).length > 0;
 }
 
 function formatTaskOutputs(tasks: TaskView[]): string {
   if (tasks.length === 1) {
-    return `${tasks[0].stdout.trim()}\n${tasks[0].stderr.trim()}`.trim();
+    return taskOutputText(tasks[0]);
   }
 
   return tasks
     .map((task) =>
       [
         `## ${task.harnessName} (${task.id})`,
-        `${task.stdout.trim()}\n${task.stderr.trim()}`.trim() ||
-          "(no output)",
+        taskOutputText(task) || "(no output)",
       ].join("\n\n")
     )
     .join("\n\n");
@@ -911,11 +940,47 @@ function compareTaskIds(compare: CompareView | undefined): string[] {
     return [];
   }
 
-  return [compare.judgeTaskId, compare.synthesizerTaskId].filter(
-    (taskId): taskId is string => Boolean(taskId),
+  return [
+    ...new Set([
+      compare.judgeTaskId,
+      compare.advisorTaskId,
+      compare.synthesizerTaskId,
+    ].filter((taskId): taskId is string => Boolean(taskId))),
+  ];
+}
+
+function validateRunAdvisorAliases(input: RunStartInput): void {
+  validateRunAliasPair(
+    "advisorHarnessId",
+    input.advisorHarnessId,
+    "synthesizerHarnessId",
+    input.synthesizerHarnessId,
+  );
+  validateRunAliasPair(
+    "advisorModel",
+    input.advisorModel,
+    "synthesizerModel",
+    input.synthesizerModel,
   );
 }
 
+function validateRunAliasPair(
+  preferredName: string,
+  preferredValue: string | undefined,
+  legacyName: string,
+  legacyValue: string | undefined,
+): void {
+  if (
+    preferredValue !== undefined &&
+    legacyValue !== undefined &&
+    preferredValue !== legacyValue
+  ) {
+    throw new Error(
+      `Conflicting Run fields: ${preferredName} and deprecated ${legacyName}.`,
+    );
+  }
+}
+
 function isTerminalRun(run: InternalRun): boolean {
   return (
     run.status === "succeeded" ||