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

package/README.md

@@ -106,6 +106,18 @@ first, searches the codebase for missing information, and records verified findi
 agent's knowledge. Answers appear in the side pane; the **Chat / Docs** toggle inside the composer
 switches back to the selected document. Questions do not create tasks.
 
+## Scripts
+
+Jobs that come back (seeding data, regenerating fixtures, a set of checks before review) are kept
+as scripts in `.pi/bot-lobby/scripts/`, shared by every agent, so a step done once is run the next
+time instead of being worked out again, which saves tokens and time. Each is named for what it
+does, in snake_case with its language's extension (`seed_public_holidays.py`,
+`run_changed_tests.sh`), and its first lines say what it is for and how to run it. The oracle
+decides when a step is worth a script and saves it (`action=script`); workers only propose one, and
+a replaced script is kept under `archive/`. For each step, Jev picks the scripts that do part of it
+and the agent is told to run them (**Settings → Classifier → Shared scripts**; with Jev off, scripts
+whose names share words with the step are suggested).
+
 ## Keys
 
 The lobby is keyboard-first, and every action button shows its key (`Archive E`, `Delete Del`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.37",
+  "version": "0.6.38",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/prompts/master.md

@@ -355,6 +355,31 @@ the relevant knowledge files: omit `taskId` to update project knowledge without
 creating or advancing a task. Answer from saved knowledge first, cite code
 evidence for newly learned facts, and never record a guess.
 
+## Scripts
+
+The project keeps a shared scripts library that every agent can run; your
+prompt lists it under Scripts, and each agent is shown the scripts that fit its
+step. A script saves the tokens and time of working the same job out again, so
+you decide when work becomes one.
+
+- Make a script of a job that will come back in much the same form: seeding or
+  resetting data, regenerating fixtures or generated files, a migration run per
+  environment, a set of checks run before every review, a scaffold. Not of a
+  one-off change, and not of a single command anyone would type.
+- When a step is such a job, say so in its brief: have the worker write the
+  step as a script, drafted in the task's directory under `scripts/`, and run
+  it. Then save it with `action=script`, `name`, `purpose`, `usage` and
+  `file` (the draft), or `text` (the script itself). Read it first: it runs
+  for every agent from then on.
+- Name it for what it does, in snake_case, with its language's extension:
+  `seed_public_holidays.py`, `run_changed_tests.sh`. Prefer the project's own
+  language and runtime. Arguments over hard-coded values, so it serves the
+  next case too; and it says what it did, and fails loudly.
+- Before you brief a step, look for a script that does it, and name it in the
+  brief. To improve one, save it again under the same name; the old version is
+  archived.
+- Workers may propose scripts; take one only when it meets the bar above.
+
 ## Review
 
 The repository state is the source of truth; do not blindly trust Scout or

package/prompts/worker.md

@@ -113,3 +113,14 @@ then add a `## Pushback` block to your output:
 
 The engine records the pushback and blocks that domain until the Master
 resolves it, so be specific and keep working on the rest of the task.
+
+## Shared scripts
+
+Your prompt's Scripts section lists the shared scripts that fit your step. Run
+one instead of doing its work by hand, and check its output as you would your
+own; a script that does not do what it says is a finding for `## Notes`. Do not
+edit the library yourself. When your brief asks you to write a step as a
+script, or you wrote one for a job that will clearly come back, draft it in the
+folder your Workflow Context names for script drafts, named for what it does in snake_case
+(`seed_public_holidays.py`), run it, and propose it under `## Script
+Proposals`.

package/src/classifier/instance.ts

@@ -9,6 +9,8 @@ import { appendMetrics } from "../state/metrics.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { isSubagentProcess } from "../pi/quiet.ts";
 import { Classifier } from "./classifier.ts";
+import { scriptPicker } from "./scripts.ts";
+import type { ScriptPicker } from "../scripts/pick.ts";
 import { registerJevProvider, type KeySource, type KeyStatus } from "./hosts.ts";
 import { fileHinter, type FileHinter, type FileScope } from "./files.ts";
 import { knowledgePicker, type KnowledgePicker } from "./knowledge.ts";
@@ -46,9 +48,15 @@ export function hintsFor(scope: FileScope): FileHinter {
   return fileHinter(classifier(), scope, (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
 }
 
-/** Relevant knowledge for agents, with what Jev kept of each long file logged to the lobby's activity feed. */
+/** Relevant knowledge and shared scripts for agents, with what Jev kept and matched logged to the lobby's activity feed. */
 export function knowledgeFor(): KnowledgePicker {
-  return knowledgePicker(classifier(), (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
+  const log = (text: string) => lobbyFeed.log("CLASSIFIER", text, "info");
+  return { ...knowledgePicker(classifier(), log), scripts: scriptPicker(classifier(), log) };
+}
+
+/** Shared scripts for a quick fix, with what Jev matched logged to the lobby's activity feed. */
+export function scriptsPickerFor(): ScriptPicker {
+  return scriptPicker(classifier(), (text) => lobbyFeed.log("CLASSIFIER", text, "info"));
 }
 
 /** Triage a request for a task in a tree, logged to the lobby's activity feed; undefined when triage is off or fails. */

package/src/classifier/knowledge.ts

@@ -16,6 +16,7 @@ import { score, selectRelevant, splitSections, tokenize, type KnowledgeInput, ty
 import type { Classifier } from "./classifier.ts";
 import { noul, yesOf, type SystemOneRequest } from "./client.ts";
 import { clip } from "./limits.ts";
+import type { ScriptPicker } from "../scripts/pick.ts";
 
 /** How many characters of each knowledge file a prompt has room for. */
 export const KNOWLEDGE_BUDGET_CHARS = 4000;
@@ -27,7 +28,7 @@ export const MAX_SECTIONS = 60;
 export const KNOWLEDGE_BUDGET_MS = 1500;
 
 /** The three files a prompt carries: `knowledge`, `standards` and `decisions`. */
-export type KnowledgeSlice = keyof KnowledgeSelection;
+export type KnowledgeSlice = Exclude<keyof KnowledgeSelection, "scripts">;
 export type KnowledgePaths = Partial<Record<KnowledgeSlice, string>>;
 
 export interface SectionCall {
@@ -100,9 +101,11 @@ export function leftOutNote(kept: Kept, name: string, path?: string): string {
     : `_Kept ${kept.kept} of ${kept.total} sections of ${name} for this step.${where}_`;
 }
 
-/** Picks what an agent's prompt carries of its knowledge files. */
+/** Picks what an agent's prompt carries of its knowledge files, and of the shared scripts. */
 export interface KnowledgePicker {
   select(task: string, files: KnowledgeInput, options?: { signal?: AbortSignal; paths?: KnowledgePaths }): Promise<KnowledgeSelection>;
+  /** Which shared scripts fit a step; shared words when absent. */
+  scripts?: ScriptPicker;
 }
 
 const SLICES: readonly KnowledgeSlice[] = ["knowledge", "standards", "decisions"];

package/src/classifier/scripts.ts

@@ -0,0 +1,76 @@
+/**
+ * Shared scripts for a step. Jev reads each script's name and purpose against
+ * the step (one yes/no per script) and the ones that do part of it are put in
+ * the agent's prompt with how to run them, so the agent runs the script rather
+ * than working the job out again. A library longer than Jev is asked about is
+ * narrowed by shared words first. Off, failed or out of time, shared words
+ * decide (`scripts/pick.ts`).
+ */
+import type { Classifier } from "./classifier.ts";
+import { noul, yesOf, type SystemOneRequest } from "./client.ts";
+import { clip } from "./limits.ts";
+import { score, tokenize } from "../knowledge/selector.ts";
+import { keywordScripts, MAX_SUGGESTED, type ScriptPicker } from "../scripts/pick.ts";
+import { nameWords, type ScriptEntry } from "../scripts/library.ts";
+
+/** Scripts Jev is asked about for one step. */
+export const MAX_CANDIDATES = 40;
+/** The step waits this long for Jev, then goes with shared words. */
+export const SCRIPTS_BUDGET_MS = 1500;
+
+export interface ScriptCall {
+  request: SystemOneRequest;
+  /** The script each question key stands for. */
+  keys: Map<string, ScriptEntry>;
+}
+
+/** The scripts to ask about: all of them, or the `MAX_CANDIDATES` that share the most words with the step. */
+export function candidateScripts(step: string, entries: readonly ScriptEntry[]): ScriptEntry[] {
+  if (entries.length <= MAX_CANDIDATES) return [...entries];
+  const tokens = tokenize(step);
+  return entries
+    .map((entry, index) => ({ entry, index, hits: score(`${nameWords(entry.name)} ${entry.purpose}`, tokens) }))
+    .sort((a, b) => b.hits - a.hits || a.index - b.index)
+    .slice(0, MAX_CANDIDATES)
+    .map((scored) => scored.entry);
+}
+
+/** One request that asks, for each script, whether it does part of the step. */
+export function scriptRequest(step: string, entries: readonly ScriptEntry[]): ScriptCall {
+  const scripts: Record<string, string> = {};
+  const questions: SystemOneRequest["questions"] = {};
+  const keys = new Map<string, ScriptEntry>();
+  entries.forEach((entry, position) => {
+    const key = `k${position + 1}`;
+    scripts[key] = clip(`${entry.name}: ${entry.purpose}`, 300);
+    questions[key] = noul(`Does the script \`scripts.${key}\` (its file name and purpose) do all or part of \`task\`, so an agent doing the task should run it instead of doing that work by hand? Yes when running it is a step the task needs; no when it is about something else or only shares words with it.`);
+    keys.set(key, entry);
+  });
+  return { request: { state: { task: clip(step, 3000), scripts }, questions }, keys };
+}
+
+/**
+ * A picker on Jev: the scripts it judges to do part of the step, most likely
+ * first. Shared words decide when it is off or cannot judge.
+ */
+export function scriptPicker(classifier: Classifier, log?: (text: string) => void): ScriptPicker {
+  return {
+    async pick(step, entries, options = {}) {
+      if (entries.length === 0) return [];
+      if (!step.trim() || !classifier.enabled("scripts")) return keywordScripts(step, entries);
+      const call = scriptRequest(step, candidateScripts(step, entries));
+      const result = await classifier.ask("scripts", call.request, { ...(options.signal ? { signal: options.signal } : {}), timeoutMs: Math.min(classifier.config.timeoutMs, SCRIPTS_BUDGET_MS) });
+      if (!result) return keywordScripts(step, entries);
+      const judged = [...call.keys].map(([key, entry]) => ({ entry, yes: yesOf(result.answers, key) }));
+      // An answer to none of the questions says nothing: shared words decide.
+      if (judged.every((entry) => entry.yes === undefined)) return keywordScripts(step, entries);
+      const picked = judged
+        .filter((entry) => (entry.yes ?? 0) >= classifier.config.thresholds.scriptRelevantAt)
+        .sort((a, b) => b.yes! - a.yes!)
+        .slice(0, MAX_SUGGESTED)
+        .map((entry) => entry.entry);
+      log?.(`scripts: ${picked.length > 0 ? picked.map((entry) => entry.name).join(", ") : "none"} fit the step (of ${entries.length}) · ${result.ms} ms`);
+      return picked;
+    },
+  };
+}

package/src/execution/agent-runner.ts

@@ -18,6 +18,8 @@ export interface AgentContext {
   standards?: string;
   knowledge?: string;
   decisions?: string;
+  /** The shared scripts that fit the step. */
+  scripts?: string;
   /** Per-agent custom instructions from the global config. */
   instructions?: string;
   workflowContext?: string;

package/src/knowledge/selector.ts

@@ -9,6 +9,8 @@ export interface KnowledgeSelection {
   knowledge: string;
   standards: string;
   decisions: string;
+  /** The shared scripts that fit the step and how to run them (see `scripts/pick.ts`). */
+  scripts?: string;
 }
 
 export interface KnowledgeInput {

package/src/lobby/quickfix.ts

@@ -23,6 +23,8 @@ import { isAbsolute, join, relative } from "node:path";
 import type { LintConfig } from "../schemas/configuration.ts";
 import { repositoryTop } from "../execution/git.ts";
 import type { LintExec } from "../execution/lint.ts";
+import { scriptsFor, type ScriptPicker } from "../scripts/pick.ts";
+import { dataRoot } from "../state/project.ts";
 import { lintFeed, runLintGate } from "../workflow/lint.ts";
 
 /** A quick fix edits code, so it gets the full coding tool set. */
@@ -105,6 +107,8 @@ export interface QuickFixDeps {
   notify?: (message: string, level: "info" | "warning" | "error") => void;
   /** Likely files for the prompt, and the lookup tool, while the classifier's file hints are on. */
   hints?: FileHinter;
+  /** Which shared scripts fit the request; shared words when absent. */
+  scripts?: ScriptPicker;
   /** Holds a request it judges large (a task, not a quick fix) instead of spending a run on it. */
   classifier?: Classifier;
   /** Lowers thinking or the model for a request the classifier judges simple or trivial. */
@@ -298,12 +302,16 @@ export class QuickFixQueue {
     this.deps.feed?.log(QUICK_FIX_SOURCE, `started: ${jobTitle(job)}`, "info", job.startedAt);
     this.edits.set(job.id, new EditLog(this.deps.cwd));
     try {
-      const [likely, route] = await Promise.all([this.likely(job.prompt, controller.signal), this.route(job.prompt, profile, controller.signal)]);
+      const [likely, route, scripts] = await Promise.all([
+        this.likely(job.prompt, controller.signal),
+        this.route(job.prompt, profile, controller.signal),
+        scriptsFor(dataRoot(this.deps.root, this.deps.configDir), job.prompt, this.deps.scripts, controller.signal),
+      ]);
       const quota = { used: MAX_CHILDREN };
       const attempt = (model: string | undefined, thinking: string) => runPiAgent(
         {
           cwd: this.deps.cwd,
-          task: [job.prompt, job.interrupted ? INTERRUPTED_NOTE : "", likely].filter(Boolean).join("\n\n"),
+          task: [job.prompt, job.interrupted ? INTERRUPTED_NOTE : "", likely, scripts ? `## Scripts\n\n${scripts}` : ""].filter(Boolean).join("\n\n"),
           systemPrompt: quickFixPrompt(profile.instructions),
           tools: [...QUICK_FIX_TOOLS, ...(this.deps.hints?.tools() ?? [])],
           ...grantOption("quickfix"),

package/src/lobby/runtime.ts

@@ -18,7 +18,7 @@ import { modelLookup } from "../pi/tools.ts";
 import { setQuickFixHandoff } from "../pi/route.ts";
 import type { Domain } from "../schemas/agent.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
-import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
+import { classifier, effortFor, hintsFor, scriptsPickerFor } from "../classifier/instance.ts";
 import { checkThinking } from "../pi/model-support.ts";
 import { QuickFixQueue } from "./quickfix.ts";
 import type { Asker } from "../ask/types.ts";
@@ -192,6 +192,7 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
     },
     notify: (message, level) => lobbyNotify(state, message, level),
     hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
+    scripts: scriptsPickerFor(),
     classifier: classifier(),
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
     lint: () => loadConfig().lint,

package/src/master/master.ts

@@ -7,7 +7,9 @@ import { domainSpec } from "../agents/registry.ts";
 import { boundedAgentTime, runAgent, runParallel, watchdogOptions, type AgentRequest, type AgentTime } from "../execution/agent-runner.ts";
 import { spawnPiProcess, type ProcessRunner, type RelayAsk } from "../execution/pi-runner.ts";
 import { knowledgeFilePath, readAgentKnowledge, writeFileEnsured } from "../knowledge/store.ts";
+import { taskDir } from "../knowledge/paths.ts";
 import { selectKnowledge, type KnowledgeSelection } from "../knowledge/selector.ts";
+import { scriptsFor } from "../scripts/pick.ts";
 import { summarizeOutcomes } from "./synthesis.ts";
 import { parseWorkerResult, validateWorkerResult } from "../roles/worker.ts";
 import { parseReviewResult, validateReviewResult } from "../roles/reviewer.ts";
@@ -73,9 +75,14 @@ function knowledgePaths(dataRoots: readonly string[], agent: Domain): KnowledgeP
 /**
  * What an agent's prompt carries of its knowledge for a step: Jev's picks from
  * the files that are too long when a picker is given, the keyword selection
- * otherwise and whenever the picker fails.
+ * otherwise and whenever the picker fails; and the shared scripts that fit it.
  */
 async function pickKnowledge(request: { knowledge?: KnowledgePicker; dataRoots: readonly string[]; signal?: AbortSignal }, agent: Domain, query: string): Promise<KnowledgeSelection> {
+  const [selected, scripts] = await Promise.all([pickFiles(request, agent, query), scriptsFor(request.dataRoots[0], query, request.knowledge?.scripts, request.signal)]);
+  return scripts ? { ...selected, scripts } : selected;
+}
+
+async function pickFiles(request: { knowledge?: KnowledgePicker; dataRoots: readonly string[]; signal?: AbortSignal }, agent: Domain, query: string): Promise<KnowledgeSelection> {
   const slices = readAgentKnowledge(request.dataRoots, agent);
   if (!request.knowledge) return selectKnowledge(query, slices);
   try {
@@ -271,6 +278,7 @@ function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
     request.risk ?? "",
     request.time?.note ?? "",
     request.ask ? askGuidance(request.ask.previews) : "",
+    request.dataRoots[0] ? `Scripts you draft for the shared library go in \`${join(taskDir(request.dataRoots[0], request.taskId), "scripts")}\`.` : "",
   ].filter(Boolean).join("\n\n");
 }
 

package/src/pi/activity.ts

@@ -120,6 +120,8 @@ function orchestrateStep(args: unknown): string {
       return "recording knowledge";
     case "compact":
       return `compacting ${text("file") ?? "knowledge"}`;
+    case "script":
+      return `saving the shared script ${text("name") ?? ""}`.trimEnd();
     case "resolve_approval":
       return `${text("decision") === "rejected" ? "rejecting" : "approving"} ${text("approvalId") ?? "a request"}`;
     case "complete":

package/src/pi/events.ts

@@ -4,6 +4,7 @@ import { detectProjectRoot, loadConfig, readDataRoots } from "../state/project.t
 import { compilePrompt } from "../prompts/compiler.ts";
 import { readAgentKnowledge } from "../knowledge/store.ts";
 import { selectKnowledge } from "../knowledge/selector.ts";
+import { libraryBlock } from "../scripts/pick.ts";
 import { cancelAllRuns } from "../execution/agent-runner.ts";
 import { describeTask } from "../workflow/workflow.ts";
 import { truncate } from "../text.ts";
@@ -137,7 +138,8 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       else delete event.systemPromptOptions.sections["bot-lobby"];
       return;
     }
-    const slices = readAgentKnowledge(readDataRoots(root, configDir), "master");
+    const dataRoots = readDataRoots(root, configDir);
+    const slices = readAgentKnowledge(dataRoots, "master");
     const selected = selectKnowledge(`${taskRequest(task)} ${task.proposal ?? ""}`, slices);
     event.systemPromptOptions.sections["bot-lobby"] = compilePrompt({
       domain: "master",
@@ -145,6 +147,7 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       standards: selected.standards,
       knowledge: selected.knowledge,
       decisions: selected.decisions,
+      scripts: dataRoots[0] ? libraryBlock(dataRoots[0]) : "",
       workflowContext: masterWorkflowContext(task, budgetContext(root, configDir, task)),
       instructions: loadConfig().master.instructions,
     });

package/src/pi/tools.ts

@@ -59,9 +59,11 @@ const OrchestrateSchema = Type.Object({
     StringEnum(["fast", "full"] as const, { description: "track: fast (straight to the roster's agents, no scouts, proposal or plan; QA only for tests) or full (the whole workflow)" }),
   ),
   roster: Type.Optional(Type.Array(Type.String(), { description: "track: who takes part — any of designer, backend, qa, researcher" })),
-  text: Type.Optional(Type.String({ description: "decide/complete/knowledge: the decision, completion summary, or knowledge text" })),
-  file: Type.Optional(Type.String({ description: "compact: the knowledge file to rewrite, e.g. knowledge.md" })),
-  name: Type.Optional(Type.String({ description: "whiteboard: name for the new Excalidraw session" })),
+  text: Type.Optional(Type.String({ description: "decide/complete/knowledge/script: the decision, completion summary, knowledge text, or the script itself" })),
+  file: Type.Optional(Type.String({ description: "compact: the knowledge file to rewrite, e.g. knowledge.md; script: a script a worker drafted, to save instead of text" })),
+  name: Type.Optional(Type.String({ description: "whiteboard: name for the new Excalidraw session; script: the file name, what it does in snake_case with its language's extension (seed_public_holidays.py, run_changed_tests.sh)" })),
+  purpose: Type.Optional(Type.String({ description: "script: one line on what the script does" })),
+  usage: Type.Optional(Type.String({ description: "script: the command that runs it, with its arguments" })),
   kind: Type.Optional(
     StringEnum(["knowledge", "standard", "decision", "completed"] as const, {
       description: "knowledge: which persistent file the text belongs to",
@@ -76,7 +78,7 @@ const DESCRIPTION = [
   "dependency), propose (record the proposal and request approval), plan (record the internal",
   "plan, or amend it later with the full revised plan), implement (delegate a step to a domain worker, or several domains in parallel with assignments), qa (final quality gate and the only",
   "review), knowledge (record approved project knowledge or a decision; works without a task),",
-  "compact (replace a knowledge file with a rewritten version, archiving the old one; works without a task; disperse domain-relevant facts to action=knowledge (domain=designer|backend|qa) first), whiteboard (create your own Excalidraw session and assign it to yourself),",
+  "compact (replace a knowledge file with a rewritten version, archiving the old one; works without a task; disperse domain-relevant facts to action=knowledge (domain=designer|backend|qa) first), script (save a script to the shared scripts library, or replace one, for a job that comes back; works without a task), whiteboard (create your own Excalidraw session and assign it to yourself),",
   "resolve_approval (approve or reject a request), complete (declare the task done after the gates",
   "pass, then ask the user to confirm merging and pushing main and removing its worktree), block/resume (escalate or continue), budget (under a time budget: where it stands, or ask the",
   "user for more minutes with a reason), track (the task's path and who takes part: show it, or correct it with",

package/src/prompts/compiler.ts

@@ -15,6 +15,8 @@ export interface CompileInput {
   standards?: string;
   knowledge?: string;
   decisions?: string;
+  /** The shared scripts that fit the step, or the library for the oracle. */
+  scripts?: string;
   workflowContext?: string;
 }
 
@@ -29,7 +31,7 @@ function section(title: string, body?: string): string {
 
 /**
  * Compose the layered prompt: global + domain + role + task context +
- * standards + knowledge + decisions + workflow context + output contract.
+ * standards + knowledge + decisions + scripts + workflow context + output contract.
  * Empty layers are dropped so agents never receive empty headings.
  */
 export function compilePrompt(input: CompileInput): string {
@@ -43,6 +45,7 @@ export function compilePrompt(input: CompileInput): string {
     section("Standards", input.standards),
     section("Knowledge", input.knowledge),
     section("Decisions", input.decisions),
+    section("Scripts", input.scripts),
     section("Workflow Context", input.workflowContext),
     spec?.contract ?? "",
   ];

package/src/roles/worker.ts

@@ -1,6 +1,6 @@
 import type { Domain, RoleSpec } from "../schemas/agent.ts";
 import type { Blocker } from "../schemas/task.ts";
-import type { FileChange, KnowledgeProposal, WorkerResult } from "../schemas/findings.ts";
+import type { FileChange, KnowledgeProposal, ScriptProposal, WorkerResult } from "../schemas/findings.ts";
 import { bullets, fieldValue, findSection, parseFileBullet, parsePushback, parseSections } from "./markdown.ts";
 
 /**
@@ -18,6 +18,7 @@ export const workerSpec: RoleSpec = {
     "Respond with exactly these sections and nothing else: `## Completed`, `## Files Changed`,",
     "`## Verification`, `## Brief Check` (one `- criterion — met|not met — evidence` line per \"Done when\" item of your brief), `## Notes`, `## Blockers`, `## Dependencies Needed`, `## Architecture Changes`,",
     "`## Knowledge Proposals` (`- knowledge: ...`, `- standard: ...`, or `- decision: ...`).",
+    "An optional `## Script Proposals` (`- \\`name.ext\\` — what it does — draft: \\`path\\``) proposes a script you wrote for a job that will come back, for the shared library.",
     "`## Files Changed` entries are `- \\`path\\` — change`.",
     "`## Verification` entries are `- command — result`.",
     "Blocked work uses `**Blocker:**`, `**Tried:**`, `**Need:**` under `## Blockers`.",
@@ -39,6 +40,18 @@ export function parseKnowledgeProposals(domain: Domain, text: string | undefined
   });
 }
 
+/** Parse `` - `name.ext` — purpose — draft: `path` `` proposals; one without a name is dropped. */
+export function parseScriptProposals(domain: Domain, text: string | undefined): ScriptProposal[] {
+  return bullets(text).flatMap((entry): ScriptProposal[] => {
+    const draftMatch = /\bdraft\s*:\s*`?([^`\s]+)`?/i.exec(entry);
+    const rest = (draftMatch ? entry.slice(0, draftMatch.index) : entry).replace(/[\s—–(-]+$/, "");
+    const named = /^`?([A-Za-z0-9_.-]+\.[A-Za-z0-9]+)`?\s*(?:[—–:-]+\s*)?(.*)$/.exec(rest.trim());
+    if (!named) return [];
+    const purpose = named[2]!.replace(/^[—–:-]+\s*/, "").trim();
+    return [{ domain, name: named[1]!, purpose, ...(draftMatch ? { draft: draftMatch[1]! } : {}) }];
+  });
+}
+
 function splitList(text: string | undefined): string[] {
   return (text ?? "")
     .split(/[;\n]|\s+then\s+/)
@@ -100,6 +113,7 @@ export function parseWorkerResult(domain: Domain, raw: string, now = new Date().
     notes: findSection(sections, "notes") ?? "",
     blockers: parseBlockers(sections, domain, now),
     knowledgeProposals: parseKnowledgeProposals(domain, findSection(sections, "knowledge proposals")),
+    scriptProposals: parseScriptProposals(domain, findSection(sections, "script proposals")),
     pushback: parsePushback(sections),
     dependencyNeeds: realAsks(bullets(findSection(sections, "dependencies needed"))),
     architectureChanges: realAsks(bullets(findSection(sections, "architecture changes"))),

package/src/schemas/configuration.ts

@@ -173,7 +173,7 @@ export interface LobbyConfig {
 }
 
 /** Decisions the classifier can make, each switched on or off on its own. */
-export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge", "qa"] as const;
+export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge", "scripts", "qa"] as const;
 export type ClassifierFeature = (typeof CLASSIFIER_FEATURES)[number];
 
 /** Hosts that serve Jev behind the same System One API; `auto` takes OpenCode's free Jev when pi holds an OpenCode key, else TypeSafe. */
@@ -194,6 +194,8 @@ export interface ClassifierThresholds {
   fileRelevantAt: number;
   /** A section of a knowledge file that is over the prompt budget stays in at this relevance. */
   knowledgeRelevantAt: number;
+  /** A shared script is suggested for a step at this probability that it does part of it. */
+  scriptRelevantAt: number;
   /** A step scored simple at this confidence runs one thinking level lower. */
   simpleAt: number;
   /** A step scored trivial at this confidence runs on the cheaper model. */
@@ -294,7 +296,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     model: "",
     baseUrl: "",
     timeoutMs: 4000,
-    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true, qa: true },
+    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true, scripts: true, qa: true },
     thresholds: {
       seatAt: 0.35,
       reseatReadyAt: 0.6,
@@ -302,6 +304,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
       autoAnswerMargin: 0.5,
       fileRelevantAt: 0.5,
       knowledgeRelevantAt: 0.4,
+      scriptRelevantAt: 0.5,
       simpleAt: 0.7,
       trivialAt: 0.8,
       quickFixAt: 0.7,

package/src/schemas/findings.ts

@@ -24,6 +24,16 @@ export interface KnowledgeProposal {
   content: string;
 }
 
+/** A script a worker thinks the shared library should keep, for the oracle to save or ignore. */
+export interface ScriptProposal {
+  domain: Domain;
+  /** The file name it proposes: `seed_public_holidays.py`. */
+  name: string;
+  purpose: string;
+  /** Where the worker drafted it, when it did. */
+  draft?: string;
+}
+
 export interface ScoutResult {
   domain: Domain;
   role: "scout";
@@ -51,6 +61,8 @@ export interface WorkerResult {
   notes: string;
   blockers: Blocker[];
   knowledgeProposals: KnowledgeProposal[];
+  /** Scripts the worker proposes for the shared library. */
+  scriptProposals?: ScriptProposal[];
   dependencyNeeds: string[];
   architectureChanges: string[];
   pushback?: Pushback;