@a-t-h-i/bot-lobby 0.6.37 → 0.6.39

package/src/workflow/workflow.ts

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, realpathSync } from "node:fs";
-import { isAbsolute, join, relative } from "node:path";
+import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schemas/configuration.ts";
 import type { AgentRun, Pushback, ResearchResult, ReviewResult, WorkerResult } from "../schemas/findings.ts";
 import {
@@ -24,6 +24,7 @@ import { ExcalidrawBook } from "../excalidraw/sessions.ts";
 import { knowledgeDir, type KnowledgeAgent } from "../knowledge/paths.ts";
 import { lobbyTopics } from "../lobby/topics.ts";
 import { writeScratchpad } from "../state/persistence.ts";
+import { saveScript } from "../scripts/library.ts";
 import { spawnPiProcess, type ProcessRunner, type RelayAsk } from "../execution/pi-runner.ts";
 import { previewDir } from "../ask/relay.ts";
 import type { AskQuestion, AskResult } from "../ask/types.ts";
@@ -31,7 +32,7 @@ import { mapConcurrent } from "../execution/agent-runner.ts";
 import { parseWorkerResult } from "../roles/worker.ts";
 import { autoNote, DESK_TOOLS, DeskSession } from "../desk/session.ts";
 import type { Handover } from "../desk/desk.ts";
-import { changedFiles, commitBefore, headCommit, readRepositoryDiff } from "../execution/git.ts";
+import { changedFiles, commitBefore, commitFiles, commitMessage, headCommit, readRepositoryDiff, uncommitted } from "../execution/git.ts";
 import { appendChange, explainChanges, provenanceLines, provenanceSummary, readChanges, type FileProvenance } from "../state/changes.ts";
 import { budgetLine, budgetState, formatMinutes, MIN_READ_MS, parseMinutes, qaAllotment, readBudget, readerAllotment, updateBudget, workerAllotment, type Allotment, type BudgetState, type TaskBudget } from "../state/budget.ts";
 import type { AgentTime } from "../execution/agent-runner.ts";
@@ -90,6 +91,7 @@ export const ORCHESTRATE_ACTIONS = [
   "qa",
   "knowledge",
   "compact",
+  "script",
   "whiteboard",
   "complete",
   "block",
@@ -126,15 +128,21 @@ export interface OrchestrateParams {
   minutes?: number;
   /** knowledge: which persistent file the text belongs to. */
   kind?: KnowledgeKind;
-  /** compact: the knowledge file being rewritten. */
+  /** compact: the knowledge file being rewritten; script: a drafted script to take instead of `text`. */
   file?: string;
-  /** whiteboard: name for the new Excalidraw session. */
+  /** whiteboard: name for the new Excalidraw session; script: the script's file name (`seed_public_holidays.py`). */
   name?: string;
+  /** script: one line on what the script does. */
+  purpose?: string;
+  /** script: how to run it, with its arguments. */
+  usage?: string;
   approvalId?: string;
   decision?: "approved" | "rejected";
   note?: string;
   reason?: string;
   text?: string;
+  /** complete: the commit message for the agents' changes. */
+  message?: string;
   /** track: the path the task takes. */
   track?: "fast" | "full";
   /** track: who takes part (designer, backend, qa, researcher). */
@@ -635,6 +643,9 @@ function workerReport(outcome: WorkerOutcome, approvals: Approval[], pushback?:
     result.knowledgeProposals.length > 0
       ? `Knowledge proposals (accept with action=knowledge, or ignore): ${result.knowledgeProposals.map((proposal) => `${proposal.kind}: ${truncate(proposal.content, 160)}`).join("; ")}`
       : "",
+    result.scriptProposals?.length
+      ? `Script proposals (save with action=script name purpose usage file=<draft>, when the job will come back; or ignore): ${result.scriptProposals.map((proposal) => `${proposal.name}${proposal.purpose ? ` — ${truncate(proposal.purpose, 120)}` : ""}${proposal.draft ? ` (draft: ${proposal.draft})` : ""}`).join("; ")}`
+      : "",
     issues.length > 0 ? `Issues: ${issues.join("; ")}` : "",
     pushback && objection
       ? `Pushback recorded (${pushback.id}): ${truncate(objection.reason, 240)}. Resolve with action=resolve_approval before re-delegating ${result.domain}.`
@@ -1481,6 +1492,34 @@ function handleKnowledge(task: Task | undefined, params: OrchestrateParams, deps
   return `Recorded ${kind} for ${agent} in ${outcome.path}.`;
 }
 
+/**
+ * The oracle adds a script to the shared library, or replaces one, so every
+ * agent can run it the next time the job comes up. Its body is `text`, or a
+ * file a worker drafted (`file`, inside the project or the task's directory).
+ */
+function handleScript(task: Task | undefined, params: OrchestrateParams, deps: WorkflowDeps): string {
+  const name = params.name?.trim();
+  if (!name) throw new Error("script requires name: what it does in snake_case, with its extension (seed_public_holidays.py)");
+  const purpose = params.purpose?.trim();
+  if (!purpose) throw new Error("script requires purpose: one line on what it does");
+  const body = params.file?.trim() ? readDraft(params.file.trim(), task, deps) : params.text;
+  if (!body?.trim()) throw new Error("script requires text (the script) or file (a drafted script)");
+  const saved = saveScript({ dataRoot: dataRoot(deps.root, deps.configDir), name, purpose, body, ...(params.usage?.trim() ? { usage: params.usage.trim() } : {}) });
+  const { entry } = saved;
+  if (task) recordDecision(task, `${saved.archived ? "Replaced" : "Saved"} the shared script ${entry.name}: ${truncate(entry.purpose, 160)}`);
+  lobbyTopics.bump("knowledge");
+  return [`${saved.archived ? "Replaced" : "Saved"} ${entry.name} in the shared scripts library (${entry.path}); run: ${entry.usage}.`, saved.archived ? `The previous version is kept at ${saved.archived}.` : "", "Agents whose steps it fits are told to run it."].filter(Boolean).join(" ");
+}
+
+/** A drafted script, read only from inside the project, its worktree or the task's directory. */
+function readDraft(file: string, task: Task | undefined, deps: WorkflowDeps): string {
+  const roots = [deps.cwd, deps.root, ...(task ? [taskDirFor(deps.root, deps.configDir, task.id)] : [])].map((dir) => resolve(dir));
+  const path = isAbsolute(file) ? resolve(file) : resolve(deps.cwd, file);
+  if (!roots.some((root) => path === root || path.startsWith(`${root}${sep}`))) throw new Error(`the drafted script must be inside the project: ${file}`);
+  if (!existsSync(path)) throw new Error(`no drafted script at ${file}`);
+  return readFileSync(path, "utf8");
+}
+
 /**
  * §24: the Master rewrites the file (asking the user about ambiguity), the
  * engine archives the previous version and writes the compacted text.
@@ -1533,6 +1572,7 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   // The gate refuses before any side effect, so a refusal leaves the task untouched.
   const oversized = overThreshold(readDataRoots(deps.root, deps.configDir), deps.config.knowledge.compactionThreshold);
   if (oversized.length > 0) throw new Error(`cannot complete: knowledge files over the compaction threshold: ${oversized.map((entry) => `${entry.agent}/${entry.file} (${entry.chars})`).join(", ")}. First record domain-relevant facts where they belong with action=knowledge (domain=designer|backend|qa), then rewrite each oversized file with action=compact, then call complete again.`);
+  const committed = await commitTaskWork(task, params, deps);
   const summary = params.text?.trim() || task.proposal || task.title;
   recordCompletion(deps, task, summary);
   removeTaskScratchpads(deps.root, deps.configDir, task.id);
@@ -1544,7 +1584,43 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   flushDecisions(deps, task);
   const delivery = await offerDelivery(task, deps);
   const left = lint?.state === "failing" ? ` ${task.lintWaiver ? "Accepted by the user with lint errors" : "Lint (advisory)"}: ${lintSummary(lint)} Tell the user.` : "";
-  return `Task ${task.id} completed. History recorded and temporary scratchpads removed. ${delivery}${left}`;
+  return `Task ${task.id} completed.${committed} History recorded and temporary scratchpads removed. ${delivery}${left}`;
+}
+
+/** The files a task's own workers changed: not one that held changes before they started, nor another task's. */
+function agentsWork(files: readonly FileProvenance[]): string[] {
+  return files.filter((file) => file.kinds.includes("planned") && !file.kinds.includes("pre-existing") && !file.kinds.includes("other-task")).map((file) => file.path);
+}
+
+/**
+ * The oracle commits what its agents changed before the task is called done,
+ * with its own short message (`message`); nothing else in the tree is
+ * staged or committed. "" when git is not in use or nothing is left to commit.
+ */
+async function commitTaskWork(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
+  const state = await changeState(deps, task, await reviewBase(task, deps));
+  if (!state) return "";
+  const ours = agentsWork(state.files);
+  const dirty = await uncommitted(state.top, ours).catch(() => []);
+  if (dirty.length === 0) return "";
+  const listed = dirty.slice(0, 20).join(", ") + (dirty.length > 20 ? ` and ${dirty.length - 20} more` : "");
+  if (!params.message?.trim()) throw new Error(`cannot complete: commit the agents' changes first. Call complete again with message: a concise commit message for them (a first line of 72 characters or fewer saying what changed, at most three short lines below it). The engine commits only these files: ${listed}`);
+  let message: string;
+  try {
+    message = commitMessage(params.message);
+  } catch (error) {
+    throw new Error(`cannot complete: ${(error as Error).message}`);
+  }
+  let result: Awaited<ReturnType<typeof commitFiles>>;
+  try {
+    result = await commitFiles(state.top, dirty, message);
+  } catch (error) {
+    throw new Error(`cannot complete: git refused the commit: ${(error as Error).message}`);
+  }
+  if (!result) return "";
+  const others = await uncommitted(state.top, state.files.map((file) => file.path).filter((path) => !ours.includes(path))).catch(() => []);
+  const left = others.length > 0 ? ` Left uncommitted, not this task's agents' work: ${others.slice(0, 10).join(", ")}${others.length > 10 ? ` and ${others.length - 10} more` : ""}.` : "";
+  return ` Committed ${result.files.length} file${result.files.length === 1 ? "" : "s"} as ${result.commit.slice(0, 7)}: "${message.split("\n")[0]}".${left}`;
 }
 
 /** Completion always offers delivery to the user, including in auto mode. */
@@ -1990,6 +2066,7 @@ const HANDLERS: Record<OrchestrateAction, (task: Task, params: OrchestrateParams
   resolve_approval: handleResolveApproval,
   qa: handleQa,
   knowledge: handleKnowledge,
+  script: handleScript,
   compact: handleCompact,
   whiteboard: handleWhiteboard,
   complete: handleComplete,
@@ -2008,9 +2085,9 @@ const HANDLERS: Record<OrchestrateAction, (task: Task, params: OrchestrateParams
  */
 export async function runWorkflowAction(params: OrchestrateParams, deps: WorkflowDeps): Promise<WorkflowResult> {
   // Project knowledge can be learned without starting or changing a task.
-  if ((params.action === "knowledge" || params.action === "compact") && !params.taskId) {
+  if ((params.action === "knowledge" || params.action === "compact" || params.action === "script") && !params.taskId) {
     try {
-      const message = params.action === "knowledge" ? handleKnowledge(undefined, params, deps) : handleCompact(undefined, params, deps);
+      const message = params.action === "knowledge" ? handleKnowledge(undefined, params, deps) : params.action === "script" ? handleScript(undefined, params, deps) : handleCompact(undefined, params, deps);
       return { ok: true, taskId: "", state: "created", message };
     } catch (error) {
       return { ok: false, taskId: "", state: "created", message: `Rejected: ${(error as Error).message}` };
@@ -2050,6 +2127,11 @@ export async function runWorkflowAction(params: OrchestrateParams, deps: Workflo
     ...(deps.askQuestions ? { askQuestions: (...args: Parameters<NonNullable<WorkflowDeps["askQuestions"]>>) => wait(() => deps.askQuestions!(...args)) } : {}),
     // Every agent, diff and desk of a task with its own worktree works there.
     cwd: taskCwd(task, deps.cwd),
+    // An agent can work for an hour: what the action has done so far (implementing, reviewing) is saved before it starts, so every window reads it.
+    runProcess: (args, options) => {
+      saveTask(deps.root, deps.configDir, task);
+      return (deps.runProcess ?? spawnPiProcess)(args, options);
+    },
     onUpdate: (run) => {
       if (run.status !== "running") {
         finished.set(run.runId, run);