@a-t-h-i/bot-lobby 0.6.0 → 0.6.2

package/src/workflow/workflow.ts

@@ -47,6 +47,10 @@ import { assertNoPendingApprovals, pendingApprovals, requestApproval, resolveApp
 import { pingApproval } from "../pi/notify.ts";
 import { describeRun, runLogEntry } from "../pi/run-summary.ts";
 import { nextStates } from "./transitions.ts";
+import type { FileHinter } from "../classifier/files.ts";
+import type { Classifier } from "../classifier/classifier.ts";
+import type { EffortRouter } from "../classifier/effort.ts";
+import { answerClarify } from "../classifier/triage.ts";
 import { appendMetrics, metricFromRun } from "../state/metrics.ts";
 import { markCommentsAddressed, pendingComments, readPlanComments } from "../state/comments.ts";
 
@@ -116,6 +120,14 @@ export interface WorkflowDeps {
   choose: (title: string, options: string[]) => Promise<string | undefined>;
   notify: (message: string, level?: "info" | "warning" | "error") => void;
   runProcess?: ProcessRunner;
+  /** Likely files for scouts and workers, while the classifier's file hints are on. */
+  hints?: FileHinter;
+  /** Answers a clarify question whose recommended option is clearly right, when it is on. */
+  classifier?: Classifier;
+  /** Re-reads a request after an amendment (the task's triage), when the classifier is on. */
+  triage?: (request: string, signal?: AbortSignal) => Promise<Task["triage"]>;
+  /** Lowers thinking or the model for scouts and workers on steps the classifier judges simple or trivial. */
+  effort?: EffortRouter;
 }
 
 export interface WorkflowResult {
@@ -253,6 +265,11 @@ async function handleClarify(task: Task, params: OrchestrateParams, deps: Workfl
   const question = params.question?.trim();
   if (!question) throw new Error("clarify requires a question");
   transition(task, "clarifying");
+  const settled = await clarifyByClassifier(task, question, params.options ?? [], deps);
+  if (settled) {
+    recordDecision(task, `Answered by the classifier (${settled.probability.toFixed(2)}): ${truncate(question, 300)} → ${settled.answer}`);
+    return `Answered by the classifier with your recommended option (${settled.probability.toFixed(2)}): ${settled.answer}. It is recorded as a decision; mention it in your proposal so the user can amend it, and continue.`;
+  }
   const unattended = unattendedReason(task, isAutoMode(deps.root, deps.configDir, task.id));
   if (unattended) {
     recordDecision(task, `Not asked (${unattended}): ${truncate(question, 300)}`);
@@ -265,6 +282,20 @@ async function handleClarify(task: Task, params: OrchestrateParams, deps: Workfl
   return `User answered: ${answer}`;
 }
 
+/** The classifier's answer to a clarify question with options, when the request already settles it. */
+async function clarifyByClassifier(task: Task, question: string, options: readonly string[], deps: WorkflowDeps): Promise<{ answer: string; probability: number } | undefined> {
+  if (!deps.classifier || options.length < 2) return undefined;
+  const notes = [
+    ...task.amendments.map((text) => `Amendment: ${text}`),
+    ...task.decisions.slice(-12).map((decision) => `Decision: ${decision.text}`),
+  ].join("\n");
+  try {
+    return await answerClarify(deps.classifier, question, options, { request: taskRequest(task), notes, ...(task.proposal ? { proposal: task.proposal } : {}) }, deps.signal);
+  } catch {
+    return undefined;
+  }
+}
+
 async function handleScout(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
   requireState(task, ["created", "clarifying", "scouting", "synthesizing"]);
   const domains = deriveDomains(params.domains);
@@ -284,6 +315,8 @@ async function handleScout(task: Task, params: OrchestrateParams, deps: Workflow
       profile: deps.profile,
       signal: deps.signal,
       onUpdate: deps.onUpdate,
+      ...(deps.hints ? { hints: deps.hints } : {}),
+      ...(deps.effort ? { effort: deps.effort } : {}),
     },
     deps.runProcess ?? spawnPiProcess,
   );
@@ -421,7 +454,20 @@ async function handlePropose(task: Task, params: OrchestrateParams, deps: Workfl
   const lower = choice.toLowerCase();
   if (lower.startsWith("approve")) return applyApprovalChoice(task, "approve");
   if (lower.startsWith("decline")) return applyApprovalChoice(task, "decline");
-  return applyApprovalChoice(task, "amend", await deps.ask("What should change?"));
+  const result = applyApprovalChoice(task, "amend", await deps.ask("What should change?"));
+  await retriage(task, deps);
+  return result;
+}
+
+/** After an amendment, the classifier reads the request again, so the Master's hints follow the change. */
+async function retriage(task: Task, deps: WorkflowDeps): Promise<void> {
+  if (!deps.triage || !task.triage) return;
+  try {
+    const next = await deps.triage([taskRequest(task), ...task.amendments.map((text) => `Amendment: ${text}`)].join("\n\n"), deps.signal);
+    if (next) task.triage = next;
+  } catch {
+    // Hints only: the old triage stays.
+  }
 }
 
 /** States in which `plan` replaces an approved plan instead of recording the first one. */
@@ -570,6 +616,8 @@ function workerRequest(deps: WorkflowDeps, task: Task, domain: Domain, instructi
     profile: deps.profile,
     signal: deps.signal,
     onUpdate: deps.onUpdate,
+    ...(deps.hints ? { hints: deps.hints } : {}),
+    ...(deps.effort ? { effort: deps.effort } : {}),
   };
 }