@tamsensedev/runner 0.5.1 → 0.9.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 import process5 from "process";
 
@@ -33,9 +33,9 @@ function textOf(value) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 async function errorOf(response) {
-  const reply2 = await response.json().catch(() => ({}));
-  const code = textOf(reply2.data?.code);
-  const message = textOf(reply2.message) ?? textOf(reply2.statusMessage) ?? `TAMsense answered with status ${response.status}`;
+  const reply3 = await response.json().catch(() => ({}));
+  const code = textOf(reply3.data?.code);
+  const message = textOf(reply3.message) ?? textOf(reply3.statusMessage) ?? `TAMsense answered with status ${response.status}`;
   return new ApiError(response.status, code, message);
 }
 function createApi(server, token = null, fetchImpl = fetch) {
@@ -187,7 +187,7 @@ function findNpm(nodePath, env, exists) {
   }
   return null;
 }
-var runProcess = (command, args, options) => new Promise((resolve, reject) => {
+var runProcess = (command, args, options) => new Promise((resolve3, reject) => {
   const child = spawn(command, args, { cwd: options.cwd, env: options.env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
   const tail = [];
   for (const stream of [child.stdout, child.stderr]) {
@@ -201,7 +201,7 @@ var runProcess = (command, args, options) => new Promise((resolve, reject) => {
     });
   }
   child.on("error", reject);
-  child.on("close", (code) => resolve({ code: code ?? 1, output: tail.join("\n") }));
+  child.on("close", (code) => resolve3({ code: code ?? 1, output: tail.join("\n") }));
 });
 function failureText(what, result) {
   if (OFFLINE_PATTERN.test(result.output)) {
@@ -314,8 +314,8 @@ async function probeCapabilities(stop) {
   stop?.throwIfAborted();
   let release = () => {
   };
-  const released = new Promise((resolve) => {
-    release = resolve;
+  const released = new Promise((resolve3) => {
+    release = resolve3;
   });
   const nothing = {
     [Symbol.asyncIterator]: () => ({
@@ -340,9 +340,8 @@ async function probeCapabilities(stop) {
 }
 
 // src/claude.ts
-import { fileURLToPath } from "url";
-import { createSdkMcpServer, query as query2, tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z3 } from "zod";
+import { createSdkMcpServer, query as query2, tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z4 } from "zod";
 
 // src/askPerson.ts
 var MAX_ASK_TRIES = 5;
@@ -402,21 +401,21 @@ function shorten(text2) {
   const line = text2.replace(/\s+/g, " ").trim();
   return line.length > MAX_ACTIVITY_LENGTH ? `${line.slice(0, MAX_ACTIVITY_LENGTH - 1)}\u2026` : line;
 }
-function activityLine(tool4, input) {
+function activityLine(tool5, input) {
   const fields = typeof input === "object" && input !== null ? input : {};
-  if (tool4 === "Bash" && typeof fields.command === "string") {
+  if (tool5 === "Bash" && typeof fields.command === "string") {
     return `$ ${shorten(fields.command)}`;
   }
-  if (FILE_TOOLS.has(tool4) && typeof fields.file_path === "string") {
-    return `${tool4} ${shorten(fields.file_path)}`;
+  if (FILE_TOOLS.has(tool5) && typeof fields.file_path === "string") {
+    return `${tool5} ${shorten(fields.file_path)}`;
   }
-  if (tool4 === "Skill" && typeof fields.skill === "string") {
+  if (tool5 === "Skill" && typeof fields.skill === "string") {
     return `Skill ${shorten(fields.skill)}`;
   }
-  if (HELPER_TOOLS.has(tool4) && typeof fields.subagent_type === "string") {
+  if (HELPER_TOOLS.has(tool5) && typeof fields.subagent_type === "string") {
     return `Agent ${shorten(fields.subagent_type)}`;
   }
-  return tool4;
+  return tool5;
 }
 function usageOf(modelUsage) {
   const entries = Object.values(modelUsage);
@@ -440,6 +439,33 @@ function outcomeOf(result, lastText) {
   return { completed: false, report: result.errors.join("\n") || `Claude stopped early: ${result.subtype}`, ...measured };
 }
 
+// src/protocol.ts
+var MAX_RESULT_FILE_BYTES = 10 * 1024 * 1024;
+var HELPER_STOPPED = "stopped";
+var MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+var MAX_ATTACHMENTS_PER_RUN = 20;
+var MAX_VIDEO_BYTES = 200 * 1024 * 1024;
+var PAIRINGS_PATH = "/api/runner/pairings";
+var PAIRING_TOKEN_PATH = "/api/runner/pairings/token";
+var IDENTITY_PATH = "/api/runner/me";
+var NEXT_RUN_PATH = "/api/runner/runs/next";
+var CAPABILITIES_PATH = "/api/runner/me/capabilities";
+function runPath(runId, action) {
+  return `/api/runner/runs/${runId}/${action}`;
+}
+function resultFilePath(runId, resultId) {
+  return `/api/runner/runs/${runId}/results/${resultId}`;
+}
+function knowledgePath(runId, entryId) {
+  return `/api/runner/runs/${runId}/knowledge/${entryId}`;
+}
+function permissionPath(runId, permissionId) {
+  return `/api/runner/runs/${runId}/permissions/${permissionId}`;
+}
+function recordingUploadPath(runId, upload, part) {
+  return `/api/runner/runs/${runId}/recordings/${upload}/${part}`;
+}
+
 // src/feed.ts
 var MAX_TEXT_LENGTH = 8e3;
 var MAX_RESULT_LENGTH = 2e3;
@@ -459,29 +485,29 @@ function textField(fields, name) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 function toolDraft(block, parent) {
-  const tool4 = (block.name ?? "tool").replace(MCP_PREFIX, "");
+  const tool5 = (block.name ?? "tool").replace(MCP_PREFIX, "");
   const fields = fieldsOf(block.input);
-  const base = { tool: tool4, ref: block.id ?? null, parent, failed: false };
-  if (tool4 === "Skill" && textField(fields, "skill")) {
+  const base = { tool: tool5, ref: block.id ?? null, parent, failed: false };
+  if (tool5 === "Skill" && textField(fields, "skill")) {
     return { ...base, kind: "skill", text: clip(textField(fields, "skill"), MAX_SUMMARY_LENGTH) };
   }
-  if (HELPER_TOOLS2.has(tool4)) {
+  if (HELPER_TOOLS2.has(tool5)) {
     const who = textField(fields, "subagent_type") ?? "general-purpose";
     const what = textField(fields, "description");
     return { ...base, kind: "agent", text: clip(what ? `${who}: ${what}` : who, MAX_SUMMARY_LENGTH) };
   }
-  if (tool4 === "submit_verdict") {
+  if (tool5 === "submit_verdict") {
     const verdict = fields.couldNotRun === true ? "Could not run" : fields.passed === true ? "Passed" : "Did not pass";
     return { ...base, kind: "tool", text: clip(`${verdict}. ${textField(fields, "report") ?? ""}`, MAX_SUMMARY_LENGTH) };
   }
-  if (tool4 === "hand_off") {
+  if (tool5 === "hand_off") {
     return { ...base, kind: "tool", text: clip(`Hand off to ${textField(fields, "to") ?? "?"}: ${textField(fields, "note") ?? ""}`, MAX_SUMMARY_LENGTH) };
   }
-  if (tool4 in ATTACH_LABELS) {
-    return { ...base, kind: "tool", text: clip(`${ATTACH_LABELS[tool4]}: ${textField(fields, "title") ?? textField(fields, "path") ?? ""}`, MAX_SUMMARY_LENGTH) };
+  if (tool5 in ATTACH_LABELS) {
+    return { ...base, kind: "tool", text: clip(`${ATTACH_LABELS[tool5]}: ${textField(fields, "title") ?? textField(fields, "path") ?? ""}`, MAX_SUMMARY_LENGTH) };
   }
   const command = textField(fields, "command");
-  const summary = tool4 === "Bash" && command ? `$ ${command}` : activityLine(tool4, block.input);
+  const summary = tool5 === "Bash" && command ? `$ ${command}` : activityLine(tool5, block.input);
   return { ...base, kind: "tool", text: clip(summary, MAX_SUMMARY_LENGTH) };
 }
 function resultText(content) {
@@ -493,6 +519,10 @@ function resultText(content) {
   }
   return content.map((part) => part.type === "text" ? part.text ?? "" : part.type === "image" ? "[image]" : "").filter(Boolean).join("\n");
 }
+function helperEndDraft(ref, parent, end, text2) {
+  const stopped = end === "stopped";
+  return { kind: "result", text: stopped ? "" : clip(text2, MAX_RESULT_LENGTH), tool: stopped ? HELPER_STOPPED : null, ref, parent, failed: end === "failed" };
+}
 function feedOf(message) {
   if (message.type !== "assistant" && message.type !== "user") {
     return [];
@@ -561,6 +591,77 @@ function chooseHandoff(targets, request) {
   return { handoff: { toColumnId: edge.columnId, outcome: edge.outcome, note } };
 }
 
+// src/helpers.ts
+function helperTasks() {
+  const byRef = /* @__PURE__ */ new Map();
+  const refByTask = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  function observe(message) {
+    if (message.type !== "system") {
+      return [];
+    }
+    if (message.subtype === "task_started" && message.task_type === "local_agent" && message.tool_use_id) {
+      byRef.set(message.tool_use_id, { taskId: message.task_id, background: message.is_backgrounded === true, stopped: false, over: false });
+      refByTask.set(message.task_id, message.tool_use_id);
+      return [];
+    }
+    if (message.subtype === "task_updated" && message.patch.is_backgrounded !== void 0) {
+      const ref2 = refByTask.get(message.task_id);
+      const task2 = ref2 ? byRef.get(ref2) : void 0;
+      if (task2) {
+        task2.background = message.patch.is_backgrounded;
+      }
+      return [];
+    }
+    if (message.subtype !== "task_notification") {
+      return [];
+    }
+    const ref = message.tool_use_id ?? refByTask.get(message.task_id);
+    const task = ref ? byRef.get(ref) : void 0;
+    if (!ref || !task || task.over) {
+      return [];
+    }
+    task.stopped = message.status === "stopped";
+    if (!task.background) {
+      return [];
+    }
+    task.over = true;
+    return [helperEndDraft(ref, parents.get(ref) ?? null, message.status, message.summary)];
+  }
+  function adjust(draft) {
+    if (draft.kind === "agent" && draft.ref) {
+      parents.set(draft.ref, draft.parent);
+    }
+    const task = draft.kind === "result" && draft.ref ? byRef.get(draft.ref) : void 0;
+    if (!task || !draft.ref) {
+      return [draft];
+    }
+    if (task.background) {
+      return [];
+    }
+    task.over = true;
+    return task.stopped ? [helperEndDraft(draft.ref, draft.parent, "stopped", "")] : [draft];
+  }
+  async function stop(target, ref) {
+    const task = byRef.get(ref);
+    if (!task) {
+      return "unknown";
+    }
+    if (task.over || task.stopped) {
+      return "finished";
+    }
+    await target.stopTask(task.taskId);
+    return "stopped";
+  }
+  return { observe, adjust, stop };
+}
+function helperStoppedNote(stop) {
+  return `${stop.byName} stopped your helper ${stop.name} on TAMsense. Go on without it and say in your result what it did not finish. Start it again only if a person asks.`;
+}
+function helperStopRequest(stop) {
+  return `${stop.byName} asked on TAMsense to stop your helper ${stop.name}. Stop it now, go on without it and say in your result what it did not finish. Start it again only if a person asks.`;
+}
+
 // src/input.ts
 var DEFAULT_MODEL = "default";
 var QUIET_MS = 1e3;
@@ -571,8 +672,11 @@ function userMessage(text2) {
 function humanText(message) {
   return `Message from ${message.authorName}: ${message.text}`;
 }
+function priorityOf(mode) {
+  return mode === "steer" ? "now" : "next";
+}
 function humanMessage(message) {
-  return { ...userMessage(humanText(message)), priority: message.mode === "steer" ? "now" : "next", client_composed: true };
+  return { ...userMessage(humanText(message)), priority: priorityOf(message.mode), client_composed: true };
 }
 function switchLine(change) {
   const model = change.model === DEFAULT_MODEL ? "the default model" : change.model;
@@ -601,6 +705,7 @@ function inputChannel(options = {}) {
   let wake = null;
   let timers = [];
   let applySwitch2 = null;
+  let applyStop = null;
   let waitingSwitch = null;
   function wakeUp() {
     wake?.();
@@ -653,8 +758,8 @@ function inputChannel(options = {}) {
       }
       const next = queue.shift();
       if (!next) {
-        await new Promise((resolve) => {
-          wake = resolve;
+        await new Promise((resolve3) => {
+          wake = resolve3;
         });
         continue;
       }
@@ -714,11 +819,14 @@ function inputChannel(options = {}) {
     onSwitch(apply) {
       applySwitch2 = apply;
       if (waitingSwitch) {
-        const { change, resolve } = waitingSwitch;
+        const { change, resolve: resolve3 } = waitingSwitch;
         waitingSwitch = null;
-        void apply(change).then(() => resolve(true), () => resolve(false));
+        void apply(change).then(() => resolve3(true), () => resolve3(false));
       }
     },
+    onStopHelper(stop) {
+      applyStop = stop;
+    },
     close,
     push(message) {
       if (closed || seen.has(message.id)) {
@@ -729,6 +837,17 @@ function inputChannel(options = {}) {
       wakeUp();
       return true;
     },
+    note(text2, mode) {
+      if (closed) {
+        return false;
+      }
+      queue.push({ ids: [], message: { ...userMessage(text2), priority: priorityOf(mode) } });
+      wakeUp();
+      return true;
+    },
+    async stopHelper(ref) {
+      return closed || !applyStop ? "unknown" : await applyStop(ref);
+    },
     async checking(work2) {
       const epoch = idle ? idleEpoch : null;
       inFlight += 1;
@@ -763,8 +882,8 @@ function inputChannel(options = {}) {
       const earlier = waitingSwitch;
       earlier?.resolve(false);
       const merged = { model: change.model ?? earlier?.change.model ?? null, effort: change.effort ?? earlier?.change.effort ?? null };
-      return new Promise((resolve) => {
-        waitingSwitch = { change: merged, resolve };
+      return new Promise((resolve3) => {
+        waitingSwitch = { change: merged, resolve: resolve3 };
       });
     }
   };
@@ -927,8 +1046,8 @@ function messageOf2(error) {
 async function decisionOf(tools, first, signal) {
   const now = tools.now ?? Date.now;
   const giveUpAt = Date.parse(first.waitUntil) + SITE_SILENCE_MS;
-  let reply2 = first;
-  while (reply2.decision === "wait") {
+  let reply3 = first;
+  while (reply3.decision === "wait") {
     await tools.sleep(CHECK_INTERVAL_MS, signal);
     if (signal.aborted) {
       return STOPPED_TEXT2;
@@ -936,9 +1055,9 @@ async function decisionOf(tools, first, signal) {
     if (now() > giveUpAt) {
       return SITE_SILENT_TEXT;
     }
-    reply2 = await tools.check(reply2.id).catch(() => reply2);
+    reply3 = await tools.check(reply3.id).catch(() => reply3);
   }
-  return reply2;
+  return reply3;
 }
 function askPermission(tools, lastWords, folder) {
   return async (toolName, input, options) => {
@@ -959,15 +1078,203 @@ function askPermission(tools, lastWords, folder) {
     } catch (error) {
       return deny(`Could not ask for permission on TAMsense: ${messageOf2(error)}. Do it another way, or explain in your report why it is needed.`);
     }
-    const reply2 = await decisionOf(tools, first, options.signal);
-    if (typeof reply2 === "string") {
-      return deny(reply2);
+    const reply3 = await decisionOf(tools, first, options.signal);
+    if (typeof reply3 === "string") {
+      return deny(reply3);
     }
-    return reply2.decision === "allow" ? { behavior: "allow", updatedInput: input } : deny(reply2.message);
+    return reply3.decision === "allow" ? { behavior: "allow", updatedInput: input } : deny(reply3.message);
   };
 }
 var denyWhenAsked = async () => deny(NOBODY_TO_ASK);
 
+// src/results.ts
+import { mkdir as mkdir2, readFile as readFile2, rm as rm2, stat, writeFile as writeFile2 } from "fs/promises";
+import { basename, extname, isAbsolute, join as join2, resolve } from "path";
+import { tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
+var SAVE_DOCUMENT_TOOL_NAME = "save_result_document";
+var SAVE_TABLE_TOOL_NAME = "save_result_table";
+var ATTACH_FILE_TOOL_NAME = "attach_result_file";
+var ADD_LINK_TOOL_NAME = "add_result_link";
+var HAND_OVER_TOOL_NAME = "hand_over";
+var RESULTS_FOLDER = "results";
+var MAX_NAME_LENGTH = 60;
+var TYPES_BY_EXTENSION = {
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".csv": "text/csv",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".zip": "application/zip"
+};
+var EXTENSIONS = { document: ".md", table: ".csv", file: "", link: "" };
+function isFolderJob(job) {
+  return job.workspace === "folder";
+}
+function resultTools(job, api, root) {
+  if (!isFolderJob(job) || job.stage.kind !== "code") {
+    return null;
+  }
+  return {
+    root,
+    save: (body) => api.request("POST", runPath(job.runId, "results"), body),
+    attach: (body) => api.request("POST", runPath(job.runId, "result-files"), body)
+  };
+}
+function handOverTools(job, api) {
+  const boards = job.handOverBoards ?? [];
+  if (boards.length === 0 || job.stage.kind !== "code") {
+    return null;
+  }
+  return { boards, send: (body) => api.request("POST", runPath(job.runId, "hand-over"), body) };
+}
+function resultFileName(result, taken) {
+  const stem = (result.kind === "file" && result.fileName ? result.fileName.replace(/\.[^.]*$/, "") : result.title).normalize("NFKC").replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, MAX_NAME_LENGTH) || "result";
+  const extension = result.kind === "file" ? extname(result.fileName ?? "") : EXTENSIONS[result.kind];
+  let name = `${stem}${extension}`;
+  for (let index = 2; taken.has(name.toLowerCase()); index += 1) {
+    name = `${stem}-${index}${extension}`;
+  }
+  taken.add(name.toLowerCase());
+  return name;
+}
+function linksText(links) {
+  return links.map((link) => `- ${link.title}: ${link.url ?? ""}`).join("\n");
+}
+async function writeResults(folder, job, api) {
+  const results = job.results ?? [];
+  await rm2(folder, { recursive: true, force: true });
+  if (results.length === 0) {
+    return [];
+  }
+  await mkdir2(folder, { recursive: true });
+  const taken = /* @__PURE__ */ new Set();
+  const lines = [];
+  const missing = [];
+  for (const result of results.filter((item) => item.kind !== "link")) {
+    const name = resultFileName(result, taken);
+    if (result.kind === "file") {
+      try {
+        const file = await api.request("GET", resultFilePath(job.runId, result.id));
+        await writeFile2(join2(folder, name), Buffer.from(file.data, "base64"));
+      } catch (error) {
+        missing.push(`${result.title}: ${error instanceof Error ? error.message : String(error)}`);
+        continue;
+      }
+    } else {
+      await writeFile2(join2(folder, name), result.content ?? "");
+    }
+    lines.push(`${RESULTS_FOLDER}/${name}: ${result.title}${result.version ? `, version ${result.version}` : ""}`);
+  }
+  const links = results.filter((item) => item.kind === "link");
+  if (links.length > 0) {
+    await writeFile2(join2(folder, "links.md"), `${linksText(links)}
+`);
+    lines.push(`${RESULTS_FOLDER}/links.md: ${links.length} link(s)`);
+  }
+  if (missing.length > 0) {
+    await writeFile2(join2(folder, "notes.md"), `These files could not be downloaded:
+${missing.map((line) => `- ${line}`).join("\n")}
+`);
+  }
+  return lines;
+}
+async function prepareFolder(job, root, api) {
+  if (!job.keepWorkspace) {
+    await rm2(root, { recursive: true, force: true });
+  }
+  await mkdir2(root, { recursive: true });
+  return { root, repositories: [], results: await writeResults(join2(root, RESULTS_FOLDER), job, api) };
+}
+async function readResultFile(root, path, title) {
+  const full = isAbsolute(path) ? path : resolve(root, path);
+  const info = await stat(full).catch(() => null);
+  if (!info?.isFile()) {
+    return `There is no file at ${full}.`;
+  }
+  if (info.size > MAX_RESULT_FILE_BYTES) {
+    return `The file is larger than ${MAX_RESULT_FILE_BYTES / 1024 / 1024} MB. Attach a smaller one or split it.`;
+  }
+  const name = basename(full);
+  return { name, title: title.trim() || name, contentType: TYPES_BY_EXTENSION[extname(full).toLowerCase()] ?? "application/octet-stream", data: (await readFile2(full)).toString("base64") };
+}
+function reply(text2, isError = false) {
+  return { content: [{ type: "text", text: text2 }], ...isError ? { isError: true } : {} };
+}
+async function sent(send) {
+  try {
+    return reply((await send()).text);
+  } catch (error) {
+    return reply(`Could not save it on TAMsense: ${error instanceof Error ? error.message : String(error)}. Try again once; if it fails again, say so in your report.`, true);
+  }
+}
+function resultToolset(tools) {
+  return [
+    tool2(
+      SAVE_DOCUMENT_TOOL_NAME,
+      "Save a document as the result of this step on the TAMsense task: Markdown text such as a letter, a reply, a brief or a report. Saving again with the same title makes a new version of that document; every version is kept and people compare them.",
+      {
+        title: z2.string().describe("short name of the document, the same for every version of it"),
+        content: z2.string().describe("the full text in Markdown, never a diff or a part"),
+        note: z2.string().describe('one line on what this version is or what changed: "First draft", "Fixed the prices after the check"')
+      },
+      async (args) => await sent(() => tools.save({ kind: "document", ...args }))
+    ),
+    tool2(
+      SAVE_TABLE_TOOL_NAME,
+      "Save a table as the result of this step, as CSV with a header row. Saving again with the same title makes a new version of that table.",
+      {
+        title: z2.string().describe("short name of the table, the same for every version of it"),
+        csv: z2.string().describe("the full table as CSV, the first row holds the column names"),
+        note: z2.string().describe("one line on what this version is or what changed")
+      },
+      async (args) => await sent(() => tools.save({ kind: "table", title: args.title, content: args.csv, note: args.note }))
+    ),
+    tool2(
+      ATTACH_FILE_TOOL_NAME,
+      `Attach a file you made in the task folder to the TAMsense task as part of the result: a PDF, a spreadsheet, an image. Up to ${MAX_RESULT_FILE_BYTES / 1024 / 1024} MB.`,
+      {
+        path: z2.string().describe("path of the file, from the task folder or absolute"),
+        title: z2.string().describe("what the file is, in a few words")
+      },
+      async (args) => {
+        const body = await readResultFile(tools.root, args.path, args.title);
+        return typeof body === "string" ? reply(body, true) : await sent(() => tools.attach(body));
+      }
+    ),
+    tool2(
+      ADD_LINK_TOOL_NAME,
+      "Attach a link to the TAMsense task as part of the result: a page or a file the result relies on.",
+      {
+        title: z2.string().describe("what the link is, in a few words"),
+        url: z2.string().describe("the full address starting with https://")
+      },
+      async (args) => await sent(() => tools.save({ kind: "link", ...args }))
+    )
+  ];
+}
+function handOverTool(tools) {
+  return tool2(
+    HAND_OVER_TOOL_NAME,
+    `Hand the task to another board of the project as a linked task, when part of the work belongs to that board. Boards you may hand to: ${tools.boards.map((board) => board.name).join(", ")}. Without autopilot a person confirms it first.`,
+    {
+      board: z2.string().describe("name of the board"),
+      title: z2.string().describe("title of the new task on that board, one plain sentence"),
+      note: z2.string().describe("what you found and what that board should do; never names, emails or other personal data of clients"),
+      wait: z2.boolean().describe("true when this task should wait on its step until the linked task is done")
+    },
+    async (args) => await sent(() => tools.send(args))
+  );
+}
+
 // src/specText.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1020,10 +1327,31 @@ var RISK_LEVELS = ["low", "medium", "high"];
 function present(lines) {
   return lines.filter((line) => line !== null);
 }
+function decisionLines(spec) {
+  return records(spec.decisions).filter((item) => text(item.question) && text(item.answer)).map((item) => `- ${text(item.question)} \u2192 ${text(item.answer)} (${item.by === "agent" ? "agent's call" : "owner"})`);
+}
+function briefPromptText(brief) {
+  return [
+    text(brief.goal) && `Goal: ${text(brief.goal)}`,
+    text(brief.context) && `Summary: ${text(brief.context)}`,
+    section("The result must contain:", texts(brief.contains).map((item) => `- ${item}`)),
+    section("Acceptance criteria:", present(Array.isArray(brief.acceptance) ? brief.acceptance.map(criterionLine) : [])),
+    section("Constraints:", texts(brief.constraints).map((item) => `- ${item}`)),
+    section("Out of scope (do not make):", texts(brief.outOfScope).map((item) => `- ${item}`)),
+    section("Sources to use:", records(brief.sources).filter((item) => text(item.source)).map((item) => `- ${text(item.source)}${text(item.use) ? `: ${text(item.use)}` : ""}`)),
+    text(brief.approver) && `Approved by: ${text(brief.approver)}`,
+    section("Decisions:", decisionLines(brief)),
+    section("Assumptions:", present(Array.isArray(brief.assumptions) ? brief.assumptions.map(assumptionLine) : [])),
+    section("Open questions (not answered yet):", records(brief.openQuestions).filter((item) => text(item.question)).map((item) => `- ${text(item.question)}`))
+  ].filter(Boolean).join("\n\n");
+}
 function specPromptText(spec) {
   if (!isRecord(spec)) {
     return null;
   }
+  if (spec.format === "brief") {
+    return briefPromptText(spec);
+  }
   const structured = Array.isArray(spec.outOfScope) || isRecord(spec.testPlan);
   const plan = isRecord(spec.testPlan) ? spec.testPlan : {};
   const risks = records(spec.risks).filter((item) => text(item.risk));
@@ -1033,7 +1361,7 @@ function specPromptText(spec) {
     text(spec.context) && `${structured ? "Summary" : "Context"}: ${text(spec.context)}`,
     section("In scope:", texts(spec.inScope).map((item) => `- ${item}`)),
     section("Out of scope (do not build):", texts(spec.outOfScope).map((item) => `- ${item}`)),
-    section("Decisions:", records(spec.decisions).filter((item) => text(item.question) && text(item.answer)).map((item) => `- ${text(item.question)} \u2192 ${text(item.answer)} (${item.by === "agent" ? "agent's call" : "owner"})`)),
+    section("Decisions:", decisionLines(spec)),
     section("Code map:", records(spec.codeMap).filter((item) => text(item.file)).map((item) => `- ${text(item.repo) ? `${text(item.repo)} ` : ""}${text(item.file)}: ${text(item.role)}${CODE_USE_TEXT[item.use] ? ` [${CODE_USE_TEXT[item.use]}]` : ""}`)),
     section("Changes, in order:", records(spec.changes).filter((item) => text(item.file)).flatMap(changeLines)),
     section("Acceptance criteria:", present(Array.isArray(spec.acceptance) ? spec.acceptance.map(criterionLine) : [])),
@@ -1048,6 +1376,209 @@ function specPromptText(spec) {
   ].filter(Boolean).join("\n\n");
 }
 
+// src/workspace.ts
+import { existsSync as existsSync2 } from "fs";
+import { rm as rm3 } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+
+// src/git.ts
+import { Buffer as Buffer2 } from "buffer";
+import { spawn as spawn2 } from "child_process";
+var GITHUB_ORIGIN = "https://github.com/";
+function githubAuthEnv(token) {
+  const credentials = Buffer2.from(`x-access-token:${token}`).toString("base64");
+  return {
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: `http.${GITHUB_ORIGIN}.extraheader`,
+    GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${credentials}`,
+    GIT_TERMINAL_PROMPT: "0"
+  };
+}
+function runGit(args, options) {
+  const env = { ...process.env, ...options.env, ...options.token ? githubAuthEnv(options.token) : {} };
+  return new Promise((resolve3, reject) => {
+    const child = spawn2("git", args, { cwd: options.cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve3({ code: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() }));
+  });
+}
+async function git(args, options) {
+  const result = await runGit(args, options);
+  if (result.code !== 0) {
+    throw new Error(`git ${args[0]} failed: ${result.stderr || result.stdout || `exit code ${result.code}`}`);
+  }
+  return result.stdout;
+}
+
+// src/lock.ts
+function keyedLock() {
+  const tails = /* @__PURE__ */ new Map();
+  return {
+    async run(key, work2) {
+      const previous = tails.get(key) ?? Promise.resolve();
+      let release = () => {
+      };
+      const done2 = new Promise((resolve3) => {
+        release = resolve3;
+      });
+      const tail = previous.then(() => done2);
+      tails.set(key, tail);
+      await previous;
+      try {
+        return await work2();
+      } finally {
+        release();
+        if (tails.get(key) === tail) {
+          tails.delete(key);
+        }
+      }
+    }
+  };
+}
+
+// src/workspace.ts
+var FALLBACK_IDENTITY = { name: "TAMsense", email: "noreply@tamsense.com" };
+var cacheLock = keyedLock();
+function githubRemoteUrl(fullName) {
+  return `https://github.com/${fullName}.git`;
+}
+function tamsenseFolder(home, ...parts) {
+  return join3(home, ".tamsense", ...parts);
+}
+function folderNames(repositories) {
+  const shortName = (fullName) => fullName.split("/").pop() ?? fullName;
+  const counts = /* @__PURE__ */ new Map();
+  for (const repository of repositories) {
+    counts.set(shortName(repository.fullName), (counts.get(shortName(repository.fullName)) ?? 0) + 1);
+  }
+  return repositories.map((repository) => counts.get(shortName(repository.fullName)) === 1 ? shortName(repository.fullName) : repository.fullName.replace("/", "__"));
+}
+async function refreshCache(cache, repository, token, tools) {
+  if (existsSync2(join3(cache, ".git"))) {
+    await git(["fetch", "--prune", "origin"], { cwd: cache, token });
+    return;
+  }
+  await git(["clone", "--no-checkout", tools.remoteUrl(repository.fullName), cache], { cwd: tools.home, token });
+}
+async function removeWorktree(cache, path) {
+  await runGit(["worktree", "remove", "--force", path], { cwd: cache });
+  await rm3(path, { recursive: true, force: true });
+  await git(["worktree", "prune"], { cwd: cache });
+}
+function stepFolder(job) {
+  const task = `task-${job.taskId}`;
+  return typeof job.stage.columnId === "number" ? [task, `step-${job.stage.columnId}`] : [task];
+}
+function isReadOnlyCheck(job) {
+  return job.stage.kind === "review" || job.stage.kind === "test";
+}
+function branchHolders(porcelain, branch) {
+  const holders = [];
+  let path = null;
+  for (const line of porcelain.split("\n").map((text2) => text2.trim())) {
+    if (line.startsWith("worktree ")) {
+      path = line.slice("worktree ".length);
+    } else if (path && line === `branch refs/heads/${branch}`) {
+      holders.push(path);
+    }
+  }
+  return holders;
+}
+async function releaseBranch(cache, branch, keep) {
+  const listed = await runGit(["worktree", "list", "--porcelain"], { cwd: cache });
+  for (const path of branchHolders(listed.stdout, branch).filter((holder) => resolve2(holder) !== resolve2(keep))) {
+    await removeWorktree(cache, path);
+  }
+}
+async function baseRef(cache, job, repository) {
+  const pushed = await runGit(["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${job.branch}`], { cwd: cache });
+  return pushed.code === 0 ? `origin/${job.branch}` : `origin/${repository.defaultBranch}`;
+}
+async function keptBase(cache, path, job, repository) {
+  if (!job.keepWorkspace || !existsSync2(join3(path, ".git"))) {
+    return null;
+  }
+  const branch = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: path });
+  if (branch.code !== 0 || branch.stdout !== (isReadOnlyCheck(job) ? "HEAD" : job.branch)) {
+    return null;
+  }
+  return git(["rev-parse", await baseRef(cache, job, repository)], { cwd: cache });
+}
+function taskFolder(home, job) {
+  return tamsenseFolder(home, "work", ...stepFolder(job));
+}
+async function prepareWorkspace(job, token, tools) {
+  const root = taskFolder(tools.home, job);
+  const folders = folderNames(job.repositories);
+  const repositories = [];
+  for (const [index, repository] of job.repositories.entries()) {
+    const cache = tamsenseFolder(tools.home, "repos", repository.fullName.replace("/", "__"));
+    const folder = folders[index] ?? repository.fullName;
+    const path = join3(root, folder);
+    const baseSha = await cacheLock.run(repository.fullName, async () => {
+      await refreshCache(cache, repository, token, tools);
+      const kept = await keptBase(cache, path, job, repository);
+      if (kept) {
+        return kept;
+      }
+      await removeWorktree(cache, path);
+      const base = await baseRef(cache, job, repository);
+      if (isReadOnlyCheck(job)) {
+        await git(["worktree", "add", "--force", "--detach", path, base], { cwd: cache });
+      } else {
+        await releaseBranch(cache, job.branch, path);
+        await git(["worktree", "add", "--force", "-B", job.branch, path, base], { cwd: cache });
+      }
+      return git(["rev-parse", "HEAD"], { cwd: path });
+    });
+    repositories.push({ fullName: repository.fullName, folder, path, baseSha });
+  }
+  return { root, repositories };
+}
+async function commitIdentityEnv(home) {
+  const configured = await runGit(["config", "--get", "user.email"], { cwd: home });
+  if (configured.code === 0 && configured.stdout) {
+    return {};
+  }
+  return {
+    GIT_AUTHOR_NAME: FALLBACK_IDENTITY.name,
+    GIT_AUTHOR_EMAIL: FALLBACK_IDENTITY.email,
+    GIT_COMMITTER_NAME: FALLBACK_IDENTITY.name,
+    GIT_COMMITTER_EMAIL: FALLBACK_IDENTITY.email
+  };
+}
+async function publishWorkspace(workspace, job, token, identity) {
+  const pushed = [];
+  for (const repository of workspace.repositories) {
+    const options = { cwd: repository.path, env: identity };
+    const sha = await cacheLock.run(repository.fullName, async () => {
+      await git(["add", "--all"], options);
+      const hasStaged = (await runGit(["diff", "--cached", "--quiet"], options)).code === 1;
+      if (hasStaged) {
+        await git(["commit", "--message", `Task #${job.taskId}: ${job.title}`], options);
+      }
+      const newCommits = Number(await git(["rev-list", "--count", `${repository.baseSha}..HEAD`], options));
+      if (newCommits === 0) {
+        return null;
+      }
+      await git(["push", "origin", `HEAD:refs/heads/${job.branch}`], { ...options, token });
+      return git(["rev-parse", "HEAD"], options);
+    });
+    if (sha) {
+      pushed.push({ repository: repository.fullName, branch: job.branch, sha });
+    }
+  }
+  return pushed;
+}
+
 // src/prompt.ts
 var VERDICT_TOOL_NAME = "submit_verdict";
 var SCREENSHOT_TOOL_NAME = "attach_screenshot";
@@ -1070,6 +1601,11 @@ var CODE_RULES = [
 ];
 var REWORK_RULE = "This is a rework. The branch already has the earlier work and maybe the reviewer's own commits: treat the current branch as the source of truth, keep the reviewer's changes unless a comment asks otherwise, and address every comment.";
 var CODE_REPORT_RULE = "End with a short report for the reviewer: what you changed, how you checked it, and anything left open.";
+var READ_ONLY_CODE_RULES = [
+  "Your role on this step only reads. Do the work the task asks for by researching and running what helps, then report. Do not change, commit or push product code: nothing from this run is pushed. You may create throwaway files outside the repositories.",
+  "Check what you report with the project's own tools where they exist, and say how you checked it."
+];
+var READ_ONLY_REPORT_RULE = "End with a short report: what you found, how you checked it, and what is left open.";
 var CHECK_RULES = [
   "The work to check is on the current branch. See it with git diff against the base branch named for each repository below, and read the code around it.",
   "Do not change, commit or push product code. You may run anything and create throwaway files outside the repositories.",
@@ -1080,9 +1616,27 @@ var SCREENSHOT_RULE = `If you render screens (screenshots of the interface), att
 var NAMING_RULE = 'Name everything you attach (screenshots, replays, videos) by what it shows and why it was made: a short title such as "Design option 1", "Feature testing" or "Feature testing, attempt 2", and a one-line purpose such as "Comparing two layouts for the empty orders state". Number design variants, name test runs by their goal and attempt, and never use generic names like "screenshot1".';
 var RECORDING_RULE = `Every browser you open with Playwright from Node is recorded for the task as a replay people can watch, requests from the tested site to the TAMsense tracker are blocked, so your runs never reach analytics, and requests other than GET, HEAD and OPTIONS to addresses outside this computer are aborted. In every browser script, load the recorder from the TAMSENSE_RECORDER environment variable (require(process.env.TAMSENSE_RECORDER), or createRequire(import.meta.url)(process.env.TAMSENSE_RECORDER) in an .mjs script), open each context with await recorder.newRecordedContext(browser, { title, purpose, context: { viewport } }), call await recorder.mark(page, 'what just happened') at every meaningful step, and end with await recorder.closeRecorded(context). Add video: true when the page has a canvas, a map, a video player or iframes from another site (a replay cannot show them), or when someone asks for a video. Recordings are attached to the task when the run ends; ${REPLAY_TOOL_NAME} and ${VIDEO_TOOL_NAME} attach one earlier with a better title.`;
 var BROWSER_RULE = "A headless browser is installed for interface checks. If the project has no Playwright of its own, load playwright-core from the folder in the TAMSENSE_PLAYWRIGHT environment variable, with PLAYWRIGHT_BROWSERS_PATH set to the folder in TAMSENSE_PLAYWRIGHT_BROWSERS.";
+var FOLDER_RULE = "This board works without code: there are no repositories. The current folder belongs to this task: work in it and keep your throwaway files here.";
+var RESULT_HOME_RULE = "The result lives only on the TAMsense task: never save it in outside services such as Google Drive or a shared folder. Use connected services only to read. Sending anything to real people, such as an email or a message, is an action that needs approval like any other.";
+var FOLDER_DO_RULES = [
+  `Save what you make on the task with the TAMsense tools: ${SAVE_DOCUMENT_TOOL_NAME} for text in Markdown, ${SAVE_TABLE_TOOL_NAME} for rows of data as CSV, ${ATTACH_FILE_TOOL_NAME} for files you made in this folder, ${ADD_LINK_TOOL_NAME} for pages the result relies on. Keep one title per document and save every change as a new version of it.`,
+  "Use only facts from the task, the notes, the earlier results and what you read yourself; never invent numbers, names or dates.",
+  RESULT_HOME_RULE
+];
+var FOLDER_REWORK_RULE = "The task came back with notes. Read the earlier results in the results folder, fix what the notes ask and save new versions of the same documents.";
+var FOLDER_REPORT_RULE = "End with a short report for the people on the task: what you made, what you decided yourself and what is still open.";
+var FOLDER_CHECK_RULES = [
+  `The result to check is in the ${RESULTS_FOLDER} folder: the latest version of each document (.md) and table (.csv), the files and links.md. Read all of it.`,
+  `Do not change the result. You may create throwaway files outside the ${RESULTS_FOLDER} folder.`,
+  "Judge it against the task, the notes of earlier steps and the instructions of this step. Be specific: every problem names the document, the place in it and what to change.",
+  `Finish by calling the ${VERDICT_TOOL_NAME} tool exactly once: passed is true only if nothing must be fixed; report says what you checked and, if it failed, exactly what to fix.`
+];
 var DEPENDENCIES_RULE = "The checkout may have no dependencies installed. To run the app or its tests, install the project's own dependencies from its lockfile with its package manager (pnpm install --frozen-lockfile, npm ci, yarn install --immutable and similar). Never add packages, change a lockfile or download browsers.";
-function localAppRule(taskId, isCheck, canAsk) {
-  const project = `tamsense-task-${taskId}`;
+function composeProjectName(job) {
+  return ["tamsense", ...stepFolder(job)].join("-");
+}
+function localAppRule(job, isCheck, canAsk) {
+  const project = composeProjectName(job);
   const cannotRun = isCheck ? `call ${VERDICT_TOOL_NAME} with passed false and couldNotRun true, write the exact reason and what a person should do in the report, and do not hand off: the task waits on this step for a person.` : "say so in your report with the exact reason and what a person should do.";
   return [
     "When you need the running app, start a local copy from this task folder only.",
@@ -1099,6 +1653,10 @@ var STAGE_GOALS = {
   review: "Review the code for",
   test: "Test"
 };
+var READ_ONLY_GOAL = "Work on";
+function isReadOnlyCode(stage) {
+  return stage.kind === "code" && stage.role?.access === "read";
+}
 var SPEC_UNATTENDED_RULE = `You are preparing a TAMsense task on the user's own computer. Nobody answers you during this run: the owner answers your questions and reviews the spec on the task page after it. So never stop to wait for a reply and never ask in your messages: hand in what this stage asks for with the TAMsense tool, then finish. People on the task may send you messages during this run, each starting with "Message from <name>:". Follow them.`;
 var READ_ONLY_RULE = "Read the code to research the task. Do not change, commit or push anything: nothing from this run is pushed, and the code step starts from a clean branch.";
 var RESEARCH_RULE = "Start by loading the tamsense:task-interview skill with the Skill tool and follow it: it holds the question test, the corner sweep and the rules for rounds. Research before asking: read the code in the repositories here and the evidence of the linked action, if there is one. Finding facts is your job; the decisions about intent are the owner's.";
@@ -1116,12 +1674,29 @@ var SPEC_RULES = [
   "Then reply with a short plain summary: the approach, the risk level and the open questions, if any. Do not paste the spec: the page shows it."
 ];
 var SPEC_WORK_MISSING = "TAMsense sent a spec step without its round and brief.";
+var BRIEF_UNATTENDED_RULE = `You are preparing a TAMsense task on the user's own computer. Nobody answers you during this run: the owner answers your questions and reviews the brief on the task page after it. So never stop to wait for a reply and never ask in your messages: hand in what this stage asks for with the TAMsense tool, then finish. People on the task may send you messages during this run, each starting with "Message from <name>:". Follow them.`;
+var BRIEF_RESEARCH_RULE = "Research before asking: read what the task, the project knowledge, the files in this folder and the connected services give you. Finding facts is your job; the decisions about intent are the owner's.";
+var RESEARCH_BRIEF_RULE = "Write the research brief as you go: findings (what the sources say that matters, each with where: the source), dataFacts (numbers and facts, each with its source; empty when none), approach (2 to 4 sentences), codeMap (always empty: this board has no code), assumptions (each corner you settled with a default, with the reason) and pendingDecisions (decisions that depend on an answer to this round; empty when none).";
+var RESULT_BRIEF_RULES = [
+  'Write the brief of the result: goal, context (the summary), contains (what the result must contain), acceptance (criteria with ids AC-1, AC-2 and so on in order, each one observable property a checker confirms by reading the result), constraints, outOfScope, sources (where the facts come from: knowledge, linked items, files of the task, connected services that are read only), approver (who approves the result), decisions, assumptions and openQuestions. Set format to "brief". Never write a code map, files to touch or repositories.',
+  'Start from the research brief and the conversation below. Apply the answers: an answer the owner gave is a decision with by: owner; an answer marked "Recommended option applied, not answered" is an assumption with the reason "not answered, the recommended option applies".',
+  "Where the task, the answers and the project context are silent and a safe default exists, choose it and record it as an assumption with its reason. A point with no safe default that changes the result becomes an open question; keep them to 3 at most. Never invent numbers, names or dates.",
+  `Hand in the FULL brief with ${SUBMIT_SPEC_TOOL_NAME}. TAMsense lints it; if it returns feedback, the brief was not saved: fix it and call ${SUBMIT_SPEC_TOOL_NAME} again. After two rounds of feedback the brief is saved as it is.`,
+  "When the task already has a saved brief, the conversation holds the owner's feedback or answers to its open questions: apply them and hand in the full updated brief. An answered open question becomes a decision.",
+  "Then reply with a short plain summary: what the result is and the open questions, if any. Do not paste the brief: the page shows it."
+];
+var BRIEF_STYLE_RULE = "Write the research brief, the questions, the brief and your reply in the language the task is written in. Replies are plain text, no Markdown. Use real names, numbers and sources; if you could not verify something, say so. No em dashes and no en dashes; use commas, colons or a plain hyphen.";
 var SPEC_STYLE_RULE = "Write the brief, the questions, the spec and your reply in the language the task is written in. Replies are plain text, no Markdown. Use real file paths, function and table names; if you could not verify something, say so. No em dashes and no en dashes; use commas, colons or a plain hyphen.";
 function specText(spec) {
   const text2 = specPromptText(spec);
   return text2 ? `Approved spec:
 ${text2}` : null;
 }
+function briefText(spec) {
+  const text2 = specPromptText(spec);
+  return text2 ? `Approved brief:
+${text2}` : null;
+}
 function contextText(context) {
   return context.trim() ? `Project context from the team (follow it like the project's own rules):
 ${context.trim()}` : null;
@@ -1160,6 +1735,18 @@ function peopleText(people) {
 function canProposeKnowledge(job) {
   return job.knowledge !== void 0 && (job.people ?? []).length > 0 && job.stage.kind !== "interview" && job.stage.kind !== "spec";
 }
+function folderText(root, results) {
+  const lines = results ?? [];
+  return lines.length > 0 ? `The task folder is ${root}. The results of the task so far, latest versions:
+${bulletList(lines)}` : `The task folder is ${root}. The task has no result yet.`;
+}
+function handOverText(boards) {
+  const names = (boards ?? []).map((board) => board.name);
+  if (names.length === 0) {
+    return null;
+  }
+  return `When part of the work belongs to another board, hand it over with the ${HAND_OVER_TOOL_NAME} tool: ${names.join(", ")}. Write a plain title and a note on what you found and what that board should do; never put names, emails or other personal data of clients in the note. With wait true this task waits on its step until the linked task is done, then it goes on and you get its result note.`;
+}
 function handoffText(targets, isCheck) {
   if (targets.length === 0) {
     return null;
@@ -1206,6 +1793,64 @@ function specGoal(job, work2) {
   }
   return work2.round > 1 ? `Follow-up questions for TAMsense task #${job.taskId}: ${job.title}` : `Prepare TAMsense task #${job.taskId} for its spec: ${job.title}`;
 }
+function briefQuestionRules(work2) {
+  const handIn = `Call ${SUBMIT_QUESTIONS_TOOL_NAME} once with the research brief and the questions, or an empty list when none are needed. If it returns problems, fix them and call it again.`;
+  if (work2.round === 1) {
+    return [
+      BRIEF_RESEARCH_RULE,
+      RESEARCH_BRIEF_RULE,
+      `Ask 0 to ${work2.maxQuestions} questions, ideally 2 or 3, the most important first, and only the ones research cannot settle, whose answers change the result, and where a wrong default is costly. Zero questions is a good result: the brief is then written right away.`,
+      QUESTION_SHAPE_RULE,
+      handIn,
+      QUESTIONS_REPLY_RULE
+    ];
+  }
+  const taken = work2.takenIds.length > 0 ? ` These ids are taken by round 1: ${work2.takenIds.join(", ")}.` : "";
+  return [
+    `This is the follow-up round ${work2.round} of 2, and there is no round after it. Read the answers in the conversation below; do not research again what your research brief covers.`,
+    `Ask at most ${work2.maxQuestions} more questions, and only when an answer is vague, contradicts another answer or the facts, or unlocked a decision from pendingDecisions. Otherwise hand in no questions: whatever is still open becomes an assumption.${taken}`,
+    QUESTION_SHAPE_RULE,
+    "Update the research brief with what the answers changed and leave pendingDecisions empty.",
+    handIn,
+    QUESTIONS_REPLY_RULE
+  ];
+}
+function briefGoal(job, work2) {
+  if (work2.round === null) {
+    return `Write the brief for TAMsense task #${job.taskId}: ${job.title}`;
+  }
+  return work2.round > 1 ? `Follow-up questions for TAMsense task #${job.taskId}: ${job.title}` : `Prepare TAMsense task #${job.taskId} for its brief: ${job.title}`;
+}
+function buildBriefPrompt(job, work2, workspace) {
+  const prompt = [
+    briefGoal(job, work2),
+    job.description,
+    work2.linkedAction,
+    work2.brief ? `Research brief from the clarification phase (verify only what you rely on):
+${JSON.stringify(work2.brief)}` : null,
+    work2.round === null && job.spec ? `Current saved brief (hand in the full updated version):
+${JSON.stringify(job.spec)}` : null,
+    job.handoffNote && `Note from another step: ${job.handoffNote}`,
+    threadText(work2.thread),
+    teamMessagesText(job.messages)
+  ].filter(Boolean).join("\n\n");
+  const instructions = [
+    BRIEF_UNATTENDED_RULE,
+    MACHINE_RULE,
+    workplaceText(job.computer, workspace.root),
+    stepLine(job.stage),
+    job.stage.instructions,
+    contextText(job.projectContext),
+    FOLDER_RULE,
+    RESULT_HOME_RULE,
+    `How to work:
+${bulletList(work2.round === null ? RESULT_BRIEF_RULES : briefQuestionRules(work2))}`,
+    safetyText(job),
+    knowledgeText(job.knowledge, job.computer, false),
+    BRIEF_STYLE_RULE
+  ].filter(Boolean).join("\n\n");
+  return { prompt, instructions };
+}
 function buildSpecPrompt(job, work2, workspace) {
   const prompt = [
     specGoal(job, work2),
@@ -1230,10 +1875,50 @@ ${JSON.stringify(job.spec)}` : null,
 ${bulletList(repositoryLines(job, workspace))}`,
     READ_ONLY_RULE,
     `How to work:
-${bulletList(work2.round === null ? SPEC_RULES : questionRules(work2))}`,
+${bulletList(work2.round === null ? SPEC_RULES : questionRules(work2))}`,
+    safetyText(job),
+    knowledgeText(job.knowledge, job.computer, false),
+    SPEC_STYLE_RULE
+  ].filter(Boolean).join("\n\n");
+  return { prompt, instructions };
+}
+var FOLDER_GOALS = {
+  code: "Work on",
+  review: "Check the result of",
+  test: "Check the result of"
+};
+function buildFolderPrompt(job, workspace, options) {
+  const kind = job.stage.kind === "review" || job.stage.kind === "test" ? job.stage.kind : "code";
+  const isCheck = kind !== "code";
+  const people = job.people ?? [];
+  const canAsk = people.length > 0;
+  const prompt = [
+    `${FOLDER_GOALS[kind]} TAMsense task #${job.taskId}: ${job.title}`,
+    job.description,
+    briefText(job.spec),
+    job.handoffNote && `Note from the previous step: ${job.handoffNote}`,
+    job.review && `Notes to address:
+${job.review}`,
+    teamMessagesText(job.messages)
+  ].filter(Boolean).join("\n\n");
+  const rules = isCheck ? FOLDER_CHECK_RULES : [...FOLDER_DO_RULES, ...job.review ? [FOLDER_REWORK_RULE] : [], FOLDER_REPORT_RULE];
+  const instructions = [
+    canAsk ? ASKING_RULE : UNATTENDED_RULE,
+    MACHINE_RULE,
+    workplaceText(job.computer, workspace.root),
+    stepLine(job.stage),
+    job.stage.instructions,
+    contextText(job.projectContext),
+    `${FOLDER_RULE} ${folderText(workspace.root, options.results)}`,
+    `How to work:
+${bulletList(rules)}`,
     safetyText(job),
-    knowledgeText(job.knowledge, job.computer, false),
-    SPEC_STYLE_RULE
+    knowledgeText(job.knowledge, job.computer, canProposeKnowledge(job)),
+    APPROVAL_RULE,
+    peopleText(people),
+    isCheck ? null : handOverText(job.handOverBoards),
+    handoffText(job.allowedHandoffs, isCheck),
+    options.browser && BROWSER_RULE
   ].filter(Boolean).join("\n\n");
   return { prompt, instructions };
 }
@@ -1243,13 +1928,17 @@ function buildTaskPrompt(job, workspace, options = {}) {
     if (!job.specWork) {
       throw new Error(SPEC_WORK_MISSING);
     }
-    return buildSpecPrompt(job, job.specWork, workspace);
+    return isFolderJob(job) ? buildBriefPrompt(job, job.specWork, workspace) : buildSpecPrompt(job, job.specWork, workspace);
+  }
+  if (isFolderJob(job)) {
+    return buildFolderPrompt(job, workspace, options);
   }
   const isCheck = kind !== "code";
+  const readOnly = isReadOnlyCode(job.stage);
   const people = job.people ?? [];
   const canAsk = people.length > 0;
   const prompt = [
-    `${STAGE_GOALS[kind]} TAMsense task #${job.taskId}: ${job.title}`,
+    `${readOnly ? READ_ONLY_GOAL : STAGE_GOALS[kind]} TAMsense task #${job.taskId}: ${job.title}`,
     job.description,
     specText(job.spec),
     job.handoffNote && `Note from the previous step: ${job.handoffNote}`,
@@ -1258,8 +1947,8 @@ ${job.review}`,
     teamMessagesText(job.messages)
   ].filter(Boolean).join("\n\n");
   const evidence = [SCREENSHOT_RULE, ...options.recorder ? [RECORDING_RULE] : [], NAMING_RULE];
-  const localApp = localAppRule(job.taskId, isCheck, canAsk);
-  const rules = isCheck ? [...CHECK_RULES, DEPENDENCIES_RULE, localApp, ...evidence] : [...CODE_RULES, ...job.review ? [REWORK_RULE] : [], DEPENDENCIES_RULE, localApp, ...evidence, CODE_REPORT_RULE];
+  const localApp = localAppRule(job, isCheck, canAsk);
+  const rules = isCheck ? [...CHECK_RULES, DEPENDENCIES_RULE, localApp, ...evidence] : readOnly ? [...READ_ONLY_CODE_RULES, DEPENDENCIES_RULE, localApp, ...evidence, READ_ONLY_REPORT_RULE] : [...CODE_RULES, ...job.review ? [REWORK_RULE] : [], DEPENDENCIES_RULE, localApp, ...evidence, CODE_REPORT_RULE];
   const instructions = [
     canAsk ? ASKING_RULE : UNATTENDED_RULE,
     MACHINE_RULE,
@@ -1267,7 +1956,7 @@ ${job.review}`,
     stepLine(job.stage),
     job.stage.instructions,
     contextText(job.projectContext),
-    `The repositories for this task are checked out in the current folder, one subfolder each, on branch ${job.branch}:
+    `The repositories for this task are checked out in the current folder, one subfolder each, ${isCheck ? "at the latest commit of branch" : "on branch"} ${job.branch}:
 ${bulletList(repositoryLines(job, workspace))}`,
     `How to work:
 ${bulletList(rules)}`,
@@ -1282,108 +1971,135 @@ ${bulletList(rules)}`,
 }
 
 // src/specTools.ts
-import { tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z2 } from "zod";
+import { tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z3 } from "zod";
 var MAX_FIRST_ROUND = 4;
-var questionSchema = z2.object({
-  id: z2.string().describe('Stable snake_case id, unique in the task, for example "empty_state"'),
-  question: z2.string().describe("One plain sentence the owner can answer without reading code"),
-  whyItMatters: z2.string().describe("One line: what changes in the result depending on the answer"),
-  options: z2.array(z2.object({
-    label: z2.string().describe('Short, concrete answer (1-6 words), without "(Recommended)": use the recommended flag'),
-    description: z2.string().describe("One sentence: what happens if this option is chosen"),
-    recommended: z2.boolean().describe("true on the option you recommend (in a multiSelect question, on every option you recommend). Recommended options come first")
+var questionSchema = z3.object({
+  id: z3.string().describe('Stable snake_case id, unique in the task, for example "empty_state"'),
+  question: z3.string().describe("One plain sentence the owner can answer without reading code"),
+  whyItMatters: z3.string().describe("One line: what changes in the result depending on the answer"),
+  options: z3.array(z3.object({
+    label: z3.string().describe('Short, concrete answer (1-6 words), without "(Recommended)": use the recommended flag'),
+    description: z3.string().describe("One sentence: what happens if this option is chosen"),
+    recommended: z3.boolean().describe("true on the option you recommend (in a multiSelect question, on every option you recommend). Recommended options come first")
   })).min(2).max(4).describe('2-4 mutually exclusive options grounded in the code and data. The UI always adds a free-text "Other" field, so never add "Other" yourself'),
-  multiSelect: z2.boolean().describe("true only when the options are additive and several can apply together")
+  multiSelect: z3.boolean().describe("true only when the options are additive and several can apply together")
 });
-var briefSchema = z2.object({
-  findings: z2.array(z2.object({
-    fact: z2.string().describe("What the code does today that matters for this task"),
-    where: z2.string().describe("Where it is: owner/repo path:line")
+var briefSchema = z3.object({
+  findings: z3.array(z3.object({
+    fact: z3.string().describe("What the code does today that matters for this task"),
+    where: z3.string().describe("Where it is: owner/repo path:line")
   })).describe("Findings from the code"),
-  dataFacts: z2.array(z2.string()).describe("Numbers and facts from the events or the business data, each with its source. Empty when the task needs no data"),
-  approach: z2.string().describe("The approach you would take, in 2-4 sentences"),
-  codeMap: z2.array(z2.object({
-    repo: z2.string().describe("Repository full name (owner/name)"),
-    file: z2.string().describe("Path relative to the repository root"),
-    role: z2.string().describe("Why it matters: what to change or reuse there")
+  dataFacts: z3.array(z3.string()).describe("Numbers and facts from the events or the business data, each with its source. Empty when the task needs no data"),
+  approach: z3.string().describe("The approach you would take, in 2-4 sentences"),
+  codeMap: z3.array(z3.object({
+    repo: z3.string().describe("Repository full name (owner/name)"),
+    file: z3.string().describe("Path relative to the repository root"),
+    role: z3.string().describe("Why it matters: what to change or reuse there")
   })).describe("The files the change will touch or must reuse"),
-  assumptions: z2.array(z2.object({
-    text: z2.string().describe("The default you chose"),
-    reason: z2.string().describe("Why it is safe or why it was chosen")
+  assumptions: z3.array(z3.object({
+    text: z3.string().describe("The default you chose"),
+    reason: z3.string().describe("Why it is safe or why it was chosen")
   })).describe("Corners settled with a default instead of a question"),
-  pendingDecisions: z2.array(z2.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
+  pendingDecisions: z3.array(z3.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
 });
-var questionsPayloadSchema = z2.object({
+var questionsPayloadSchema = z3.object({
   brief: briefSchema,
-  questions: z2.array(questionSchema).max(MAX_FIRST_ROUND).describe(`0-${MAX_FIRST_ROUND} questions that pass the question test, most important first. An empty list when research settled everything`)
+  questions: z3.array(questionSchema).max(MAX_FIRST_ROUND).describe(`0-${MAX_FIRST_ROUND} questions that pass the question test, most important first. An empty list when research settled everything`)
 });
-var specSchema = z2.object({
-  goal: z2.string().describe("The problem solved, for whom, and the outcome a user or the business will notice"),
-  context: z2.string().describe("Summary: the problem in 1-2 sentences, then the chosen approach in 1-2 sentences"),
-  inScope: z2.array(z2.string()).describe("What this task delivers, one item each"),
-  outOfScope: z2.array(z2.string()).describe("What this task does not do: nearby additions a coder might be tempted to make and approaches that are ruled out. Never empty"),
-  decisions: z2.array(z2.object({
-    question: z2.string(),
-    answer: z2.string(),
-    by: z2.enum(["owner", "agent"]).describe("owner: answered by a person; agent: your own call")
+var specSchema = z3.object({
+  goal: z3.string().describe("The problem solved, for whom, and the outcome a user or the business will notice"),
+  context: z3.string().describe("Summary: the problem in 1-2 sentences, then the chosen approach in 1-2 sentences"),
+  inScope: z3.array(z3.string()).describe("What this task delivers, one item each"),
+  outOfScope: z3.array(z3.string()).describe("What this task does not do: nearby additions a coder might be tempted to make and approaches that are ruled out. Never empty"),
+  decisions: z3.array(z3.object({
+    question: z3.string(),
+    answer: z3.string(),
+    by: z3.enum(["owner", "agent"]).describe("owner: answered by a person; agent: your own call")
   })).describe("Every answered question with by: owner, and your own calls that matter with by: agent"),
-  codeMap: z2.array(z2.object({
-    repo: z2.string().describe("Repository full name (owner/name)"),
-    file: z2.string().describe("Path relative to the repository root"),
-    role: z2.string().describe("What the coder needs to know about this file"),
-    use: z2.enum(["reuse", "change", "keep"]).describe("reuse: build on it; change: it is in changes; keep: do not touch")
+  codeMap: z3.array(z3.object({
+    repo: z3.string().describe("Repository full name (owner/name)"),
+    file: z3.string().describe("Path relative to the repository root"),
+    role: z3.string().describe("What the coder needs to know about this file"),
+    use: z3.enum(["reuse", "change", "keep"]).describe("reuse: build on it; change: it is in changes; keep: do not touch")
   })).describe("The files a coder must read before starting"),
-  changes: z2.array(z2.object({
-    repo: z2.string().describe("Repository full name (owner/name) where the change happens"),
-    file: z2.string().describe("Path to the file, relative to the repository root"),
-    action: z2.enum(["create", "modify", "delete"]),
-    description: z2.string().describe("The behaviour the file has after the change and which existing functions or patterns to extend. No code snippets or diffs"),
-    produces: z2.array(z2.string()).describe("Names with signatures or data shapes this change creates or changes for other changes. Empty when none"),
-    consumes: z2.array(z2.string()).describe("Names with signatures or data shapes this change uses from earlier changes. Empty when none"),
-    acceptance: z2.array(z2.string()).describe("Ids of the criteria this change makes true, like AC-1")
+  changes: z3.array(z3.object({
+    repo: z3.string().describe("Repository full name (owner/name) where the change happens"),
+    file: z3.string().describe("Path to the file, relative to the repository root"),
+    action: z3.enum(["create", "modify", "delete"]),
+    description: z3.string().describe("The behaviour the file has after the change and which existing functions or patterns to extend. No code snippets or diffs"),
+    produces: z3.array(z3.string()).describe("Names with signatures or data shapes this change creates or changes for other changes. Empty when none"),
+    consumes: z3.array(z3.string()).describe("Names with signatures or data shapes this change uses from earlier changes. Empty when none"),
+    acceptance: z3.array(z3.string()).describe("Ids of the criteria this change makes true, like AC-1")
   })).min(1).describe("File changes in dependency order: each uses only what earlier changes or the code already provide"),
-  acceptance: z2.array(z2.object({
-    id: z2.string().describe("AC-1, AC-2 and so on, in order"),
-    kind: z2.enum(["main", "edge", "keep"]).describe("main: the main path; edge: an error, empty or limit case; keep: existing behaviour that must keep working"),
-    text: z2.string().describe('"Given <state>, when <action>, then <observable result>", saying where to look. No file paths or function names')
+  acceptance: z3.array(z3.object({
+    id: z3.string().describe("AC-1, AC-2 and so on, in order"),
+    kind: z3.enum(["main", "edge", "keep"]).describe("main: the main path; edge: an error, empty or limit case; keep: existing behaviour that must keep working"),
+    text: z3.string().describe('"Given <state>, when <action>, then <observable result>", saying where to look. No file paths or function names')
   })).min(1).describe("Acceptance criteria: main path first, then edge cases, then what must keep working"),
-  testPlan: z2.object({
-    automated: z2.array(z2.object({
-      repo: z2.string(),
-      command: z2.string().describe("The exact command to run"),
-      expect: z2.string().describe("What passing looks like")
+  testPlan: z3.object({
+    automated: z3.array(z3.object({
+      repo: z3.string(),
+      command: z3.string().describe("The exact command to run"),
+      expect: z3.string().describe("What passing looks like")
     })).describe("At least one command"),
-    newTests: z2.array(z2.object({
-      seam: z2.string().describe("Where the test goes: the highest seam that covers the behaviour (an endpoint, a page, a public function)"),
-      covers: z2.array(z2.string()).describe("Ids of the criteria it covers")
+    newTests: z3.array(z3.object({
+      seam: z3.string().describe("Where the test goes: the highest seam that covers the behaviour (an endpoint, a page, a public function)"),
+      covers: z3.array(z3.string()).describe("Ids of the criteria it covers")
     })),
-    manual: z2.array(z2.object({
-      page: z2.string().describe("The page or screen"),
-      steps: z2.string().describe("What a person does and sees")
+    manual: z3.array(z3.object({
+      page: z3.string().describe("The page or screen"),
+      steps: z3.string().describe("What a person does and sees")
     }))
   }),
-  risks: z2.array(z2.object({
-    risk: z2.string(),
-    mitigation: z2.string()
+  risks: z3.array(z3.object({
+    risk: z3.string(),
+    mitigation: z3.string()
   })).describe("What could go wrong: migrations, existing data, access, performance, compatibility"),
-  riskLevel: z2.enum(["low", "medium", "high"]).describe("How closely a person should review the result"),
-  assumptions: z2.array(z2.object({
-    text: z2.string().describe("The default you chose"),
-    reason: z2.string().describe("Why, so the owner can confirm or correct it quickly")
+  riskLevel: z3.enum(["low", "medium", "high"]).describe("How closely a person should review the result"),
+  assumptions: z3.array(z3.object({
+    text: z3.string().describe("The default you chose"),
+    reason: z3.string().describe("Why, so the owner can confirm or correct it quickly")
   })).describe("Defaults chosen where the task was silent. Empty when nothing was assumed"),
-  openQuestions: z2.array(questionSchema).describe("Questions only the owner can settle; the spec cannot be approved until each is answered or dismissed. Empty when none"),
-  split: z2.array(z2.string()).describe("When the task holds more than one shippable goal or more than about 8 files: the separate tasks you propose, one line each. Empty otherwise")
+  openQuestions: z3.array(questionSchema).describe("Questions only the owner can settle; the spec cannot be approved until each is answered or dismissed. Empty when none"),
+  split: z3.array(z3.string()).describe("When the task holds more than one shippable goal or more than about 8 files: the separate tasks you propose, one line each. Empty otherwise")
 });
-function reply(text2, isError = false) {
+var resultBriefSchema = z3.object({
+  format: z3.literal("brief").describe('Always "brief"'),
+  goal: z3.string().describe("What the work is for, for whom, and the outcome people will notice"),
+  context: z3.string().describe("Summary: the situation in 1-2 sentences, then how the work will be done in 1-2 sentences"),
+  contains: z3.array(z3.string()).min(1).describe("What the result must contain, one item each: the parts, facts and attachments a reader expects"),
+  acceptance: z3.array(z3.object({
+    id: z3.string().describe("AC-1, AC-2 and so on, in order"),
+    text: z3.string().describe("One observable property of the result that a checker can confirm by reading it")
+  })).min(1).describe("Acceptance criteria the checks judge the result by, the most important first"),
+  constraints: z3.array(z3.string()).describe("Rules the result must keep: length, tone, language, deadlines, what must not be promised. Empty when none"),
+  outOfScope: z3.array(z3.string()).describe("What this work does not do: nearby things someone might be tempted to add. Empty when nothing is tempting"),
+  sources: z3.array(z3.object({
+    source: z3.string().describe("Where the facts come from: a project knowledge note, a linked item, a file of the task, a connected service read only"),
+    use: z3.string().describe("What to take from it")
+  })).describe("Sources the work must use. Empty when the task itself is enough"),
+  approver: z3.string().describe("Who approves the result, as the task or the board names them"),
+  decisions: z3.array(z3.object({
+    question: z3.string(),
+    answer: z3.string(),
+    by: z3.enum(["owner", "agent"]).describe("owner: answered by a person; agent: your own call")
+  })).describe("Every answered question with by: owner, and your own calls that matter with by: agent"),
+  assumptions: z3.array(z3.object({
+    text: z3.string().describe("The default you chose"),
+    reason: z3.string().describe("Why, so the owner can confirm or correct it quickly")
+  })).describe("Defaults chosen where the task was silent. Empty when nothing was assumed"),
+  openQuestions: z3.array(questionSchema).describe("Questions only the owner can settle; the brief cannot be approved until each is answered or dismissed. Empty when none")
+});
+function reply2(text2, isError = false) {
   return { content: [{ type: "text", text: text2 }], ...isError ? { isError: true } : {} };
 }
 function unreachable(error, toolName) {
   const message = error instanceof Error ? error.message : String(error);
-  return reply(`Could not reach TAMsense to check this: ${message}. Call ${toolName} again in a moment.`, true);
+  return reply2(`Could not reach TAMsense to check this: ${message}. Call ${toolName} again in a moment.`, true);
 }
 function questionsTool(review, onSubmit) {
-  return tool2(
+  return tool3(
     SUBMIT_QUESTIONS_TOOL_NAME,
     "Hand in the brief and the clarifying questions of this round. Call it once, after the research. Pass an empty questions list when research settled everything: the spec is then written next. If it returns problems, the questions were not saved: fix them and call it again.",
     questionsPayloadSchema.shape,
@@ -1395,10 +2111,10 @@ function questionsTool(review, onSubmit) {
         return unreachable(error, SUBMIT_QUESTIONS_TOOL_NAME);
       }
       if (!verdict.accepted) {
-        return reply(verdict.feedback, true);
+        return reply2(verdict.feedback, true);
       }
       onSubmit(args);
-      return reply(args.questions.length > 0 ? "Questions saved. The owner answers them on the task page after this run. Finish now with a reply of one or two sentences." : "Saved with no questions: the spec is written next. Finish now with a reply of one or two sentences.");
+      return reply2(args.questions.length > 0 ? "Questions saved. The owner answers them on the task page after this run. Finish now with a reply of one or two sentences." : "Saved with no questions: the spec is written next. Finish now with a reply of one or two sentences.");
     }
   );
 }
@@ -1406,7 +2122,7 @@ var BUILDER_CHECK_FIRST = "The spec passed the lint but was not saved yet: the b
 function specTool(review, onSubmit, builderCheckRan) {
   let repairs = 0;
   let reminded = false;
-  return tool2(
+  return tool3(
     SUBMIT_SPEC_TOOL_NAME,
     "Hand in the implementation spec. It replaces the previous version entirely, so always send the FULL spec. TAMsense lints it and checks the files first; if it returns feedback, the spec was not saved: fix it and call submit_spec again.",
     specSchema.shape,
@@ -1419,14 +2135,36 @@ function specTool(review, onSubmit, builderCheckRan) {
       }
       if (!verdict.accepted) {
         repairs += 1;
-        return reply(verdict.feedback, true);
+        return reply2(verdict.feedback, true);
       }
       if (!builderCheckRan() && !reminded) {
         reminded = true;
-        return reply(BUILDER_CHECK_FIRST, true);
+        return reply2(BUILDER_CHECK_FIRST, true);
+      }
+      onSubmit({ spec: args, problems: verdict.problems });
+      return reply2(verdict.problems.length > 0 ? `Spec saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Spec saved.");
+    }
+  );
+}
+function briefTool(review, onSubmit) {
+  let repairs = 0;
+  return tool3(
+    SUBMIT_SPEC_TOOL_NAME,
+    "Hand in the brief of the result. It replaces the previous version entirely, so always send the FULL brief. TAMsense lints it first; if it returns feedback, the brief was not saved: fix it and call submit_spec again.",
+    resultBriefSchema.shape,
+    async (args) => {
+      let verdict;
+      try {
+        verdict = await review({ spec: args, repairs });
+      } catch (error) {
+        return unreachable(error, SUBMIT_SPEC_TOOL_NAME);
+      }
+      if (!verdict.accepted) {
+        repairs += 1;
+        return reply2(verdict.feedback, true);
       }
       onSubmit({ spec: args, problems: verdict.problems });
-      return reply(verdict.problems.length > 0 ? `Spec saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Spec saved.");
+      return reply2(verdict.problems.length > 0 ? `Brief saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Brief saved.");
     }
   );
 }
@@ -1528,10 +2266,9 @@ function usageLimitWatch() {
 // src/claude.ts
 var NO_RESULT_TEXT = "Claude finished without a result.";
 var SERVER_NAME = "tamsense";
-var LIBRARY_PATH = fileURLToPath(new URL("../library", import.meta.url));
 var CAPTION_FIELDS = {
-  title: z3.string().describe('short name of what it shows, at most 60 characters: "Design option 1", "Feature testing", "Feature testing, attempt 2". Never generic names like "screenshot1"'),
-  purpose: z3.string().describe('one line, at most 160 characters, on why it was made: "Comparing two layouts for the empty orders state"')
+  title: z4.string().describe('short name of what it shows, at most 60 characters: "Design option 1", "Feature testing", "Feature testing, attempt 2". Never generic names like "screenshot1"'),
+  purpose: z4.string().describe('one line, at most 160 characters, on why it was made: "Comparing two layouts for the empty orders state"')
 };
 var ATTACH_TOOLS = {
   screenshot: {
@@ -1552,21 +2289,21 @@ var ATTACH_TOOLS = {
 };
 function attachTool(kind, attach) {
   const spec = ATTACH_TOOLS[kind];
-  return tool3(
+  return tool4(
     spec.name,
     spec.description,
-    { path: z3.string().describe(spec.path), ...CAPTION_FIELDS },
+    { path: z4.string().describe(spec.path), ...CAPTION_FIELDS },
     async (args) => ({ content: [{ type: "text", text: await attach({ kind, ...args }) }] })
   );
 }
 function verdictTool(onVerdict) {
-  return tool3(
+  return tool4(
     VERDICT_TOOL_NAME,
     "Hand in the result of this check. Call it exactly once, at the very end.",
     {
-      passed: z3.boolean().describe("true only if nothing must be fixed"),
-      report: z3.string().describe("what you checked and, if it failed, exactly what to fix with file and line"),
-      couldNotRun: z3.boolean().optional().describe("true when the check could not run at all because of this computer: Docker not running, no local setup, or settings that point outside this computer; passed must be false and the report gives the exact reason and what a person should do")
+      passed: z4.boolean().describe("true only if nothing must be fixed"),
+      report: z4.string().describe("what you checked and, if it failed, exactly what to fix with file and line"),
+      couldNotRun: z4.boolean().optional().describe("true when the check could not run at all because of this computer: Docker not running, no local setup, or settings that point outside this computer; passed must be false and the report gives the exact reason and what a person should do")
     },
     async (args) => {
       onVerdict(args.couldNotRun ? { passed: false, report: args.report, couldNotRun: true } : { passed: args.passed, report: args.report });
@@ -1575,13 +2312,13 @@ function verdictTool(onVerdict) {
   );
 }
 function handoffTool(targets, onHandoff) {
-  return tool3(
+  return tool4(
     HANDOFF_TOOL_NAME,
     "Hand the task to the next step of the TAMsense board when you finish. The next agent and the task owner read your note. Only one handoff counts: calling it again replaces the earlier one.",
     {
-      to: z3.string().describe("name or id of the step to hand the task to"),
-      outcome: z3.enum(HANDOFF_OUTCOMES).describe("pass: the work is done; problems: something must be fixed; ask: a question for that step"),
-      note: z3.string().describe("for the next agent and the owner: what was done, what to check, what is open")
+      to: z4.string().describe("name or id of the step to hand the task to"),
+      outcome: z4.enum(HANDOFF_OUTCOMES).describe("pass: the work is done; problems: something must be fixed; ask: a question for that step"),
+      note: z4.string().describe("for the next agent and the owner: what was done, what to check, what is open")
     },
     async (args) => {
       const choice = chooseHandoff(targets, args);
@@ -1594,25 +2331,25 @@ function handoffTool(targets, onHandoff) {
   );
 }
 function askPersonTool(asking, waiting) {
-  return tool3(
+  return tool4(
     ASK_PERSON_TOOL_NAME,
     "Ask a person on this TAMsense task when you are stuck or the decision belongs to a person: intent, design, access, or how the team runs something locally. Never ask what the code or the project knowledge already answers. With blocking true the run pauses and frees the computer until the answer comes; with blocking false you keep working on your assumption.",
     {
-      to: z3.union([z3.number(), z3.string()]).describe("id of the person from the people list in your instructions: the assignee first; a topic question goes to the person whose role fits"),
-      why: z3.string().describe('one line on why this person: "assignee, and the run is on her computer", "Designer, owns empty states"'),
-      question: z3.string().describe("one plain question the person can answer without reading the code"),
-      context: z3.string().optional().describe("one line on what you saw that led to the question"),
-      tried: z3.array(z3.object({
-        did: z3.string().describe("the command or step"),
-        error: z3.string().optional().describe("the exact error line, if there was one"),
-        result: z3.string().describe("what it showed, one line")
+      to: z4.union([z4.number(), z4.string()]).describe("id of the person from the people list in your instructions: the assignee first; a topic question goes to the person whose role fits"),
+      why: z4.string().describe('one line on why this person: "assignee, and the run is on her computer", "Designer, owns empty states"'),
+      question: z4.string().describe("one plain question the person can answer without reading the code"),
+      context: z4.string().optional().describe("one line on what you saw that led to the question"),
+      tried: z4.array(z4.object({
+        did: z4.string().describe("the command or step"),
+        error: z4.string().optional().describe("the exact error line, if there was one"),
+        result: z4.string().describe("what it showed, one line")
       })).max(MAX_ASK_TRIES).optional().describe("what you already tried, the most telling first"),
-      options: z3.array(z3.object({
-        label: z3.string().describe("a short answer the person can pick"),
-        detail: z3.string().describe("one line on what happens if it is picked")
+      options: z4.array(z4.object({
+        label: z4.string().describe("a short answer the person can pick"),
+        detail: z4.string().describe("one line on what happens if it is picked")
       })).max(MAX_ASK_OPTIONS).optional().describe("2 to 4 answers you suggest, the one you would pick first"),
-      blocking: z3.boolean().describe("true when you cannot go on without the answer"),
-      assumption: z3.string().optional().describe("when blocking is false: what you continue with until the answer comes")
+      blocking: z4.boolean().describe("true when you cannot go on without the answer"),
+      assumption: z4.string().optional().describe("when blocking is false: what you continue with until the answer comes")
     },
     async (args) => {
       if (waiting.waitingFor !== null) {
@@ -1622,16 +2359,16 @@ function askPersonTool(asking, waiting) {
       if ("error" in choice) {
         return { content: [{ type: "text", text: choice.error }], isError: true };
       }
-      let reply2;
+      let reply3;
       try {
-        reply2 = await asking.send(choice.body);
+        reply3 = await asking.send(choice.body);
       } catch (error) {
         return { content: [{ type: "text", text: `Could not send the question: ${error instanceof Error ? error.message : String(error)}. Decide yourself and say so in your report.` }], isError: true };
       }
       if (choice.body.blocking) {
-        waiting.waitingFor = reply2.id;
+        waiting.waitingFor = reply3.id;
       }
-      return { content: [{ type: "text", text: askedText(reply2.name, choice.body) }] };
+      return { content: [{ type: "text", text: askedText(reply3.name, choice.body) }] };
     }
   );
 }
@@ -1639,8 +2376,13 @@ function specWorkTools(specWork, submitted) {
   if (!specWork) {
     return [];
   }
-  return specWork.stage === "interview" ? [questionsTool(specWork.review, (questions) => {
-    submitted.questions = questions;
+  if (specWork.stage === "interview") {
+    return [questionsTool(specWork.review, (questions) => {
+      submitted.questions = questions;
+    })];
+  }
+  return specWork.brief ? [briefTool(specWork.review, (brief) => {
+    submitted.spec = brief;
   })] : [specTool(specWork.review, (spec) => {
     submitted.spec = spec;
   }, () => submitted.helperStarted)];
@@ -1668,7 +2410,9 @@ function tamsenseServer(request, submitted) {
     ...knowledgeTools(request.knowledge),
     ...request.handoffs.length > 0 ? [handoffTool(request.handoffs, (handoff) => {
       submitted.handoff = handoff;
-    })] : []
+    })] : [],
+    ...request.results ? resultToolset(request.results) : [],
+    ...request.handOver ? [handOverTool(request.handOver)] : []
   ];
   return {
     server: createSdkMcpServer({ name: SERVER_NAME, version: "1.0.0", tools }),
@@ -1695,6 +2439,7 @@ async function attempt(request, context, resume) {
   let outcome = { completed: false, report: NO_RESULT_TEXT, model: null, usage: null, verdict: null };
   const tamsense = tamsenseServer(request, context.submitted);
   const shown = hiddenStepsFilter();
+  const helpers = helperTasks();
   const messages = context.startQuery({
     prompt: request.input.start(request.prompt.prompt),
     options: {
@@ -1706,7 +2451,7 @@ async function attempt(request, context, resume) {
       thinking: { type: "adaptive", display: "summarized" },
       // режим auto сам решает, что можно; о чём он спросил бы человека, решают правила проекта или люди задачи
       canUseTool: request.permissions ? askPermission(request.permissions, () => context.lastWords.text, request.cwd) : denyWhenAsked,
-      plugins: [{ type: "local", path: LIBRARY_PATH }],
+      plugins: [{ type: "local", path: request.library }],
       mcpServers: { [SERVER_NAME]: tamsense.server },
       allowedTools: tamsense.allowed,
       abortController: context.abortController,
@@ -1716,6 +2461,7 @@ async function attempt(request, context, resume) {
     }
   });
   request.input.onSwitch((change) => applySwitch(messages, change));
+  request.input.onStopHelper((ref) => helpers.stop(messages, ref));
   const failedToResume = () => resume !== null && sessionId === null && !request.signal.aborted;
   try {
     for await (const message of messages) {
@@ -1727,7 +2473,7 @@ async function attempt(request, context, resume) {
         messages.close();
         return { outcome, sessionId, resumeFailed: true };
       }
-      for (const draft of feedOf(message).filter(shown)) {
+      for (const draft of [...helpers.observe(message), ...feedOf(message).filter(shown).flatMap(helpers.adjust)]) {
         if (draft.kind === "agent" && draft.parent === null) {
           context.submitted.helperStarted = true;
         }
@@ -1778,13 +2524,13 @@ function claudeRunner(startQuery) {
 var runClaude = claudeRunner(query2);
 
 // src/config.ts
-import { mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile3, rm as rm4, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 var OWNER_ONLY_FILE = 384;
 var OWNER_ONLY_FOLDER = 448;
 function configPath(home = homedir2()) {
-  return join2(home, ".tamsense", "runner.json");
+  return join4(home, ".tamsense", "runner.json");
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1802,7 +2548,7 @@ function isMissingFile(error) {
 }
 async function readConfig(path = configPath()) {
   try {
-    return parseConfig(JSON.parse(await readFile2(path, "utf8")));
+    return parseConfig(JSON.parse(await readFile3(path, "utf8")));
   } catch (error) {
     if (isMissingFile(error) || error instanceof SyntaxError) {
       return null;
@@ -1811,34 +2557,12 @@ async function readConfig(path = configPath()) {
   }
 }
 async function writeConfig(config, path = configPath()) {
-  await mkdir2(dirname2(path), { recursive: true, mode: OWNER_ONLY_FOLDER });
-  await writeFile2(path, `${JSON.stringify(config, null, 4)}
+  await mkdir3(dirname2(path), { recursive: true, mode: OWNER_ONLY_FOLDER });
+  await writeFile3(path, `${JSON.stringify(config, null, 4)}
 `, { mode: OWNER_ONLY_FILE });
 }
 async function removeConfig(path = configPath()) {
-  await rm2(path, { force: true });
-}
-
-// src/protocol.ts
-var MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
-var MAX_ATTACHMENTS_PER_RUN = 20;
-var MAX_VIDEO_BYTES = 200 * 1024 * 1024;
-var PAIRINGS_PATH = "/api/runner/pairings";
-var PAIRING_TOKEN_PATH = "/api/runner/pairings/token";
-var IDENTITY_PATH = "/api/runner/me";
-var NEXT_RUN_PATH = "/api/runner/runs/next";
-var CAPABILITIES_PATH = "/api/runner/me/capabilities";
-function runPath(runId, action) {
-  return `/api/runner/runs/${runId}/${action}`;
-}
-function knowledgePath(runId, entryId) {
-  return `/api/runner/runs/${runId}/knowledge/${entryId}`;
-}
-function permissionPath(runId, permissionId) {
-  return `/api/runner/runs/${runId}/permissions/${permissionId}`;
-}
-function recordingUploadPath(runId, upload, part) {
-  return `/api/runner/runs/${runId}/recordings/${upload}/${part}`;
+  await rm4(path, { force: true });
 }
 
 // src/login.ts
@@ -1855,14 +2579,14 @@ async function login(tools, request) {
   tools.openBrowser(pageUrl);
   while (tools.now() < expiresAt) {
     await tools.sleep(pairing.intervalSeconds * MS_PER_SECOND);
-    const reply2 = await tools.api.request("POST", PAIRING_TOKEN_PATH, { deviceCode: pairing.deviceCode });
-    if (reply2.status === "connected") {
-      return { token: reply2.token, device: reply2.device };
+    const reply3 = await tools.api.request("POST", PAIRING_TOKEN_PATH, { deviceCode: pairing.deviceCode });
+    if (reply3.status === "connected") {
+      return { token: reply3.token, device: reply3.device };
     }
-    if (reply2.status === "denied") {
+    if (reply3.status === "denied") {
       throw new Error(DENIED_TEXT);
     }
-    if (reply2.status === "expired") {
+    if (reply3.status === "expired") {
       break;
     }
   }
@@ -1870,14 +2594,14 @@ async function login(tools, request) {
 }
 
 // src/recorderEnv.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
+import { fileURLToPath } from "url";
 
 // src/recorder.ts
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import Module, { createRequire } from "module";
-import { basename, dirname as dirname3, join as join3 } from "path";
+import { basename as basename2, dirname as dirname3, join as join5 } from "path";
 import process2 from "process";
 var RECORDINGS_DIR_ENV = "TAMSENSE_RECORDINGS_DIR";
 var SERVER_ENV = "TAMSENSE_SERVER";
@@ -1950,7 +2674,7 @@ function clip2(text2, max) {
   return text2.length > max ? `${text2.slice(0, max - 1).trimEnd()}\u2026` : text2;
 }
 function automaticCaption(env = process2.env, script2 = process2.argv[1]) {
-  const from = script2 ? `, opened by ${basename(script2)}` : "";
+  const from = script2 ? `, opened by ${basename2(script2)}` : "";
   return {
     title: clip2(env[DEFAULT_TITLE_ENV]?.trim() || "Browser session", MAX_TITLE_LENGTH),
     purpose: clip2(`${env[DEFAULT_PURPOSE_ENV]?.trim() || "Recorded automatically while the agent used a browser"}${from}`, MAX_PURPOSE_LENGTH)
@@ -1958,7 +2682,7 @@ function automaticCaption(env = process2.env, script2 = process2.argv[1]) {
 }
 function rrwebSource() {
   const entry = createRequire(import.meta.url).resolve("rrweb");
-  return readFileSync(join3(dirname3(entry), "rrweb.umd.min.cjs"), "utf8");
+  return readFileSync(join5(dirname3(entry), "rrweb.umd.min.cjs"), "utf8");
 }
 function pageScript(rrweb) {
   return `(() => {
@@ -2009,8 +2733,8 @@ var Session = class {
   bytes = 0;
   constructor(dir, recording, url) {
     const id = `${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
-    this.file = join3(dir, `${id}${REPLAY_SUFFIX}`);
-    this.metaFile = join3(dir, `${id}${META_SUFFIX}`);
+    this.file = join5(dir, `${id}${REPLAY_SUFFIX}`);
+    this.metaFile = join5(dir, `${id}${META_SUFFIX}`);
     this.meta = { version: 1, id, ...recording.caption, startedAt: Date.now(), endedAt: null, url, marks: [], video: null, gaps: [], blockedTrackerRequests: 0, blockedExternalWrites: 0, truncated: false, automatic: recording.automatic };
     writeFileSync(this.file, "");
     this.save();
@@ -2182,11 +2906,11 @@ if (process2.env[RECORDINGS_DIR_ENV]) {
 // src/recorderEnv.ts
 var RECORDER_ENV = "TAMSENSE_RECORDER";
 function bundledRecorder() {
-  const path = fileURLToPath2(new URL("./recorder.cjs", import.meta.url));
-  return existsSync2(path) ? path : null;
+  const path = fileURLToPath(new URL("./recorder.cjs", import.meta.url));
+  return existsSync3(path) ? path : null;
 }
 function recordingsFolder(home, runId) {
-  return join4(home, ".tamsense", "recordings", `run-${runId}`);
+  return join6(home, ".tamsense", "recordings", `run-${runId}`);
 }
 function nodeOptionsWithRecorder(recorder, nodeOptions) {
   return [nodeOptions?.trim(), `--require "${recorder.replaceAll("\\", "/")}"`].filter(Boolean).join(" ");
@@ -2213,7 +2937,7 @@ function describeDevice(identity) {
 }
 
 // src/system.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { hostname } from "os";
 import { delimiter as delimiter2 } from "path";
 import { setTimeout as wait } from "timers/promises";
@@ -2222,12 +2946,12 @@ var PLATFORM_LABELS = {
   darwin: "macOS",
   linux: "Linux"
 };
-var MAX_NAME_LENGTH = 80;
+var MAX_NAME_LENGTH2 = 80;
 function platformLabel(platform = process.platform) {
   return PLATFORM_LABELS[platform] ?? platform;
 }
 function defaultDeviceName() {
-  return hostname().slice(0, MAX_NAME_LENGTH) || "My computer";
+  return hostname().slice(0, MAX_NAME_LENGTH2) || "My computer";
 }
 function browserCommand(url, platform) {
   if (platform === "win32") {
@@ -2237,7 +2961,7 @@ function browserCommand(url, platform) {
 }
 function openBrowser(url, platform = process.platform) {
   const [command, args] = browserCommand(url, platform);
-  const child = spawn2(command, args, { detached: true, stdio: "ignore" });
+  const child = spawn3(command, args, { detached: true, stdio: "ignore" });
   child.on("error", () => {
   });
   child.unref();
@@ -2257,7 +2981,7 @@ async function sleep(ms, signal) {
 }
 
 // src/update.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { readFileSync as readFileSync2 } from "fs";
 import process3 from "process";
 var PACKAGE_NAME = "@tamsensedev/runner";
@@ -2312,8 +3036,8 @@ function relaunchArgs(argv) {
 }
 function relaunch(argv, env) {
   const isWindows = process3.platform === "win32";
-  return new Promise((resolve, reject) => {
-    const child = spawn3(isWindows ? "npx.cmd" : "npx", relaunchArgs(argv), { stdio: "inherit", shell: isWindows, env: { ...env, [RELAUNCHED_ENV]: "1" } });
+  return new Promise((resolve3, reject) => {
+    const child = spawn4(isWindows ? "npx.cmd" : "npx", relaunchArgs(argv), { stdio: "inherit", shell: isWindows, env: { ...env, [RELAUNCHED_ENV]: "1" } });
     const ignoreInterrupt = () => {
     };
     process3.on("SIGINT", ignoreInterrupt);
@@ -2323,13 +3047,13 @@ function relaunch(argv, env) {
     });
     child.on("close", (code) => {
       process3.off("SIGINT", ignoreInterrupt);
-      resolve(code ?? 1);
+      resolve3(code ?? 1);
     });
   });
 }
 
 // src/worker.ts
-import { rm as rm4 } from "fs/promises";
+import { rm as rm6 } from "fs/promises";
 import { dirname as dirname5 } from "path";
 import process4 from "process";
 
@@ -2369,37 +3093,43 @@ function feedQueue(send) {
   };
 }
 
-// src/lock.ts
-function keyedLock() {
-  const tails = /* @__PURE__ */ new Map();
-  return {
-    async run(key, work2) {
-      const previous = tails.get(key) ?? Promise.resolve();
-      let release = () => {
-      };
-      const done2 = new Promise((resolve) => {
-        release = resolve;
-      });
-      const tail = previous.then(() => done2);
-      tails.set(key, tail);
-      await previous;
-      try {
-        return await work2();
-      } finally {
-        release();
-        if (tails.get(key) === tail) {
-          tails.delete(key);
-        }
-      }
-    }
-  };
+// src/library.ts
+import { existsSync as existsSync4 } from "fs";
+import { cp, mkdir as mkdir4, rm as rm5 } from "fs/promises";
+import { join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var LIBRARY_PATH = fileURLToPath2(new URL("../library", import.meta.url));
+var SKILL_NAME = /^[a-z0-9-]+$/;
+var STAGE_SKILLS = {
+  interview: ["task-interview"],
+  spec: ["spec-writing", "task-interview"]
+};
+function allowedSkills(stage) {
+  const skills = stage.role?.skills ?? null;
+  return skills && [.../* @__PURE__ */ new Set([...skills, ...STAGE_SKILLS[stage.kind] ?? []])].filter((name) => SKILL_NAME.test(name));
+}
+function roleLibraryFolder(home, runId) {
+  return join7(home, ".tamsense", "libraries", `run-${runId}`);
+}
+async function prepareLibrary(folder, skills, source = LIBRARY_PATH) {
+  if (skills === null) {
+    return source;
+  }
+  await rm5(folder, { recursive: true, force: true });
+  await mkdir4(join7(folder, "skills"), { recursive: true });
+  await cp(join7(source, ".claude-plugin"), join7(folder, ".claude-plugin"), { recursive: true });
+  await cp(join7(source, "agents"), join7(folder, "agents"), { recursive: true });
+  for (const skill of skills.filter((name) => SKILL_NAME.test(name) && existsSync4(join7(source, "skills", name)))) {
+    await cp(join7(source, "skills", skill), join7(folder, "skills", skill), { recursive: true });
+  }
+  return folder;
 }
 
 // src/recordings.ts
 import { randomUUID } from "crypto";
 import { createReadStream } from "fs";
-import { readdir, readFile as readFile3, stat, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename2, dirname as dirname4, extname, isAbsolute, join as join5 } from "path";
+import { readdir, readFile as readFile4, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename3, dirname as dirname4, extname as extname2, isAbsolute as isAbsolute2, join as join8 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { Readable } from "stream";
 import { promisify } from "util";
@@ -2460,23 +3190,23 @@ function marksFrom(marks, startTs) {
   return marks.map((mark) => ({ at: Math.max(0, mark.ts - startTs), label: mark.label })).sort((a, b) => a.at - b.at);
 }
 function sessionIdOf(file) {
-  return basename2(file).replace(REPLAY_SUFFIX, "");
+  return basename3(file).replace(REPLAY_SUFFIX, "");
 }
 async function readMeta(file) {
   try {
-    return JSON.parse(await readFile3(file, "utf8"));
+    return JSON.parse(await readFile4(file, "utf8"));
   } catch {
     return null;
   }
 }
 async function metaFor(kind, file) {
   if (kind === "replay") {
-    return readMeta(join5(dirname4(file), `${sessionIdOf(file)}${META_SUFFIX}`));
+    return readMeta(join8(dirname4(file), `${sessionIdOf(file)}${META_SUFFIX}`));
   }
-  const folder = basename2(dirname4(file)) === "video" ? dirname4(dirname4(file)) : dirname4(file);
+  const folder = basename3(dirname4(file)) === "video" ? dirname4(dirname4(file)) : dirname4(file);
   for (const name of await readdir(folder).catch(() => [])) {
     if (name.endsWith(META_SUFFIX) && name !== LEDGER_FILE) {
-      const meta = await readMeta(join5(folder, name));
+      const meta = await readMeta(join8(folder, name));
       if (meta?.video === file) {
         return meta;
       }
@@ -2486,7 +3216,7 @@ async function metaFor(kind, file) {
 }
 async function ledger(dir) {
   try {
-    return new Set(JSON.parse(await readFile3(join5(dir, LEDGER_FILE), "utf8")));
+    return new Set(JSON.parse(await readFile4(join8(dir, LEDGER_FILE), "utf8")));
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -2494,10 +3224,10 @@ async function ledger(dir) {
 async function remember(dir, file) {
   const done2 = await ledger(dir);
   done2.add(file);
-  await writeFile3(join5(dir, LEDGER_FILE), JSON.stringify([...done2]));
+  await writeFile4(join8(dir, LEDGER_FILE), JSON.stringify([...done2]));
 }
 async function nonEmpty(file) {
-  return file !== null && ((await stat(file).catch(() => null))?.size ?? 0) > 0;
+  return file !== null && ((await stat2(file).catch(() => null))?.size ?? 0) > 0;
 }
 async function pendingRecordings(dir) {
   const done2 = await ledger(dir);
@@ -2507,8 +3237,8 @@ async function pendingRecordings(dir) {
     if (!name.endsWith(META_SUFFIX) || name === LEDGER_FILE) {
       continue;
     }
-    const meta = await readMeta(join5(dir, name));
-    const replay = join5(dir, `${name.slice(0, -META_SUFFIX.length)}${REPLAY_SUFFIX}`);
+    const meta = await readMeta(join8(dir, name));
+    const replay = join8(dir, `${name.slice(0, -META_SUFFIX.length)}${REPLAY_SUFFIX}`);
     if (!done2.has(replay) && await nonEmpty(replay)) {
       pending.push({ kind: "replay", file: replay, meta });
     }
@@ -2528,11 +3258,11 @@ async function uploadReplay(upload, file, caption) {
   if (!scan.snapshot) {
     throw new Error("This replay has no page snapshot, so it cannot be played. Was the page ever opened?");
   }
-  return finish(upload, { kind: "replay", upload: id, name: basename2(file), ...caption, contentType: "application/x-ndjson", durationMs: null, marks: marksFrom(scan.marks, scan.startTs) });
+  return finish(upload, { kind: "replay", upload: id, name: basename3(file), ...caption, contentType: "application/x-ndjson", durationMs: null, marks: marksFrom(scan.marks, scan.startTs) });
 }
 async function uploadVideo(upload, file, caption, meta) {
-  const contentType = VIDEO_TYPES_BY_EXTENSION[extname(file).toLowerCase()];
-  const info = await stat(file);
+  const contentType = VIDEO_TYPES_BY_EXTENSION[extname2(file).toLowerCase()];
+  const info = await stat2(file);
   if (info.size > MAX_VIDEO_BYTES) {
     throw new Error(`The video is larger than ${MAX_VIDEO_BYTES / 1024 / 1024} MB. Record a shorter one.`);
   }
@@ -2543,16 +3273,16 @@ async function uploadVideo(upload, file, caption, meta) {
   const endedAt = meta?.endedAt ?? info.mtimeMs;
   const durationMs = Math.max(0, Math.round(endedAt - startedAt));
   const marks = marksFrom(meta?.marks ?? [], startedAt).filter((mark) => mark.at <= durationMs);
-  return finish(upload, { kind: "video", upload: id, name: basename2(file), ...caption, contentType, durationMs, marks });
+  return finish(upload, { kind: "video", upload: id, name: basename3(file), ...caption, contentType, durationMs, marks });
 }
 async function finish(upload, body) {
   return (await upload.api.request("POST", runPath(upload.runId, "recordings"), body)).id;
 }
 async function attachRecording(api, runId, recordingsDir2, request) {
-  if (!isAbsolute(request.path)) {
+  if (!isAbsolute2(request.path)) {
     return `Give the absolute path of the ${request.kind === "replay" ? "replay (.rrweb.ndjson)" : "video (.webm or .mp4)"} file.`;
   }
-  const fitsKind = request.kind === "replay" ? request.path.endsWith(REPLAY_SUFFIX) : extname(request.path).toLowerCase() in VIDEO_TYPES_BY_EXTENSION;
+  const fitsKind = request.kind === "replay" ? request.path.endsWith(REPLAY_SUFFIX) : extname2(request.path).toLowerCase() in VIDEO_TYPES_BY_EXTENSION;
   if (!fitsKind) {
     return request.kind === "replay" ? `A replay is the ${REPLAY_SUFFIX} file the TAMsense recorder wrote.` : "Only WebM and MP4 videos can be attached.";
   }
@@ -2617,19 +3347,19 @@ async function uploadPendingRecordings(api, runId, dir) {
 }
 
 // src/screenshot.ts
-import { readFile as readFile4, stat as stat2 } from "fs/promises";
-import { basename as basename3, extname as extname2, isAbsolute as isAbsolute2 } from "path";
-var TYPES_BY_EXTENSION = {
+import { readFile as readFile5, stat as stat3 } from "fs/promises";
+import { basename as basename4, extname as extname3, isAbsolute as isAbsolute3 } from "path";
+var TYPES_BY_EXTENSION2 = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
   ".webp": "image/webp"
 };
 async function readScreenshot(request) {
-  if (!isAbsolute2(request.path)) {
+  if (!isAbsolute3(request.path)) {
     return "Give the absolute path of the image file.";
   }
-  const contentType = TYPES_BY_EXTENSION[extname2(request.path).toLowerCase()];
+  const contentType = TYPES_BY_EXTENSION2[extname3(request.path).toLowerCase()];
   if (!contentType) {
     return "Only PNG, JPEG and WebP images can be attached.";
   }
@@ -2639,158 +3369,15 @@ async function readScreenshot(request) {
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
   }
-  const info = await stat2(request.path).catch(() => null);
+  const info = await stat3(request.path).catch(() => null);
   if (!info?.isFile()) {
     return `There is no file at ${request.path}.`;
   }
   if (info.size > MAX_ATTACHMENT_BYTES) {
     return "The image is larger than 5 MB. Take a smaller screenshot (viewport instead of full page, or JPEG).";
   }
-  const data = (await readFile4(request.path)).toString("base64");
-  return { name: basename3(request.path), ...caption, contentType, data };
-}
-
-// src/workspace.ts
-import { existsSync as existsSync3 } from "fs";
-import { rm as rm3 } from "fs/promises";
-import { join as join6 } from "path";
-
-// src/git.ts
-import { Buffer } from "buffer";
-import { spawn as spawn4 } from "child_process";
-var GITHUB_ORIGIN = "https://github.com/";
-function githubAuthEnv(token) {
-  const credentials = Buffer.from(`x-access-token:${token}`).toString("base64");
-  return {
-    GIT_CONFIG_COUNT: "1",
-    GIT_CONFIG_KEY_0: `http.${GITHUB_ORIGIN}.extraheader`,
-    GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${credentials}`,
-    GIT_TERMINAL_PROMPT: "0"
-  };
-}
-function runGit(args, options) {
-  const env = { ...process.env, ...options.env, ...options.token ? githubAuthEnv(options.token) : {} };
-  return new Promise((resolve, reject) => {
-    const child = spawn4("git", args, { cwd: options.cwd, env, stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve({ code: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() }));
-  });
-}
-async function git(args, options) {
-  const result = await runGit(args, options);
-  if (result.code !== 0) {
-    throw new Error(`git ${args[0]} failed: ${result.stderr || result.stdout || `exit code ${result.code}`}`);
-  }
-  return result.stdout;
-}
-
-// src/workspace.ts
-var FALLBACK_IDENTITY = { name: "TAMsense", email: "noreply@tamsense.com" };
-var cacheLock = keyedLock();
-function githubRemoteUrl(fullName) {
-  return `https://github.com/${fullName}.git`;
-}
-function tamsenseFolder(home, ...parts) {
-  return join6(home, ".tamsense", ...parts);
-}
-function folderNames(repositories) {
-  const shortName = (fullName) => fullName.split("/").pop() ?? fullName;
-  const counts = /* @__PURE__ */ new Map();
-  for (const repository of repositories) {
-    counts.set(shortName(repository.fullName), (counts.get(shortName(repository.fullName)) ?? 0) + 1);
-  }
-  return repositories.map((repository) => counts.get(shortName(repository.fullName)) === 1 ? shortName(repository.fullName) : repository.fullName.replace("/", "__"));
-}
-async function refreshCache(cache, repository, token, tools) {
-  if (existsSync3(join6(cache, ".git"))) {
-    await git(["fetch", "--prune", "origin"], { cwd: cache, token });
-    return;
-  }
-  await git(["clone", "--no-checkout", tools.remoteUrl(repository.fullName), cache], { cwd: tools.home, token });
-}
-async function removeWorktree(cache, path) {
-  await runGit(["worktree", "remove", "--force", path], { cwd: cache });
-  await rm3(path, { recursive: true, force: true });
-  await git(["worktree", "prune"], { cwd: cache });
-}
-async function baseRef(cache, job, repository) {
-  const pushed = await runGit(["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${job.branch}`], { cwd: cache });
-  return pushed.code === 0 ? `origin/${job.branch}` : `origin/${repository.defaultBranch}`;
-}
-async function keptBase(cache, path, job, repository) {
-  if (!job.keepWorkspace || !existsSync3(join6(path, ".git"))) {
-    return null;
-  }
-  const branch = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: path });
-  if (branch.code !== 0 || branch.stdout !== job.branch) {
-    return null;
-  }
-  return git(["rev-parse", await baseRef(cache, job, repository)], { cwd: cache });
-}
-async function prepareWorkspace(job, token, tools) {
-  const root = tamsenseFolder(tools.home, "work", `task-${job.taskId}`);
-  const folders = folderNames(job.repositories);
-  const repositories = [];
-  for (const [index, repository] of job.repositories.entries()) {
-    const cache = tamsenseFolder(tools.home, "repos", repository.fullName.replace("/", "__"));
-    const folder = folders[index] ?? repository.fullName;
-    const path = join6(root, folder);
-    const baseSha = await cacheLock.run(repository.fullName, async () => {
-      await refreshCache(cache, repository, token, tools);
-      const kept = await keptBase(cache, path, job, repository);
-      if (kept) {
-        return kept;
-      }
-      await removeWorktree(cache, path);
-      await git(["worktree", "add", "--force", "-B", job.branch, path, await baseRef(cache, job, repository)], { cwd: cache });
-      return git(["rev-parse", "HEAD"], { cwd: path });
-    });
-    repositories.push({ fullName: repository.fullName, folder, path, baseSha });
-  }
-  return { root, repositories };
-}
-async function commitIdentityEnv(home) {
-  const configured = await runGit(["config", "--get", "user.email"], { cwd: home });
-  if (configured.code === 0 && configured.stdout) {
-    return {};
-  }
-  return {
-    GIT_AUTHOR_NAME: FALLBACK_IDENTITY.name,
-    GIT_AUTHOR_EMAIL: FALLBACK_IDENTITY.email,
-    GIT_COMMITTER_NAME: FALLBACK_IDENTITY.name,
-    GIT_COMMITTER_EMAIL: FALLBACK_IDENTITY.email
-  };
-}
-async function publishWorkspace(workspace, job, token, identity) {
-  const pushed = [];
-  for (const repository of workspace.repositories) {
-    const options = { cwd: repository.path, env: identity };
-    const sha = await cacheLock.run(repository.fullName, async () => {
-      await git(["add", "--all"], options);
-      const hasStaged = (await runGit(["diff", "--cached", "--quiet"], options)).code === 1;
-      if (hasStaged) {
-        await git(["commit", "--message", `Task #${job.taskId}: ${job.title}`], options);
-      }
-      const newCommits = Number(await git(["rev-list", "--count", `${repository.baseSha}..HEAD`], options));
-      if (newCommits === 0) {
-        return null;
-      }
-      await git(["push", "origin", `HEAD:refs/heads/${job.branch}`], { ...options, token });
-      return git(["rev-parse", "HEAD"], options);
-    });
-    if (sha) {
-      pushed.push({ repository: repository.fullName, branch: job.branch, sha });
-    }
-  }
-  return pushed;
+  const data = (await readFile5(request.path)).toString("base64");
+  return { name: basename4(request.path), ...caption, contentType, data };
 }
 
 // src/worker.ts
@@ -2853,17 +3440,31 @@ function messageLine(message) {
   const line = `Message from ${message.authorName}: ${message.text}`.replace(/\s+/g, " ").trim();
   return line.length > MAX_MESSAGE_LINE ? `${line.slice(0, MAX_MESSAGE_LINE - 1)}\u2026` : line;
 }
+async function stopHelper(input, stop, print2) {
+  try {
+    const result = await input.stopHelper(stop.ref);
+    if (result === "stopped") {
+      input.note(helperStoppedNote(stop), "queue");
+      print2(`  ${stop.byName} stopped the helper ${stop.name}`);
+    } else if (result === "unknown" && input.note(helperStopRequest(stop), "steer")) {
+      print2(`  ${stop.byName} asked Claude to stop the helper ${stop.name}`);
+    }
+  } catch (error) {
+    print2(`Could not stop the helper ${stop.name}: ${messageOf3(error)}`);
+  }
+}
 function inbox(job, tools, record, closedOnSite) {
   const input = inputChannel({ onIdle: () => void poll() });
+  const stopsSeen = /* @__PURE__ */ new Set();
   let running = null;
   let again = false;
   let failing = false;
   async function check() {
     const ack = input.takeDelivered();
     const body = { ack };
-    let reply2;
+    let reply3;
     try {
-      reply2 = await tools.api.request("POST", runPath(job.runId, "inbox"), body);
+      reply3 = await tools.api.request("POST", runPath(job.runId, "inbox"), body);
     } catch (error) {
       input.restoreDelivered(ack);
       if (!failing) {
@@ -2873,17 +3474,23 @@ function inbox(job, tools, record, closedOnSite) {
       return;
     }
     failing = false;
-    if (!reply2.keepGoing) {
+    if (!reply3.keepGoing) {
       closedOnSite();
       return;
     }
-    for (const message of reply2.messages) {
+    for (const message of reply3.messages) {
       if (input.push(message)) {
         tools.print(`  ${messageLine(message)}`);
       }
     }
-    if (reply2.model !== null || reply2.effort !== null) {
-      const change = { model: reply2.model, effort: reply2.effort };
+    for (const stop of reply3.helperStops ?? []) {
+      if (!stopsSeen.has(stop.ref)) {
+        stopsSeen.add(stop.ref);
+        void stopHelper(input, stop, tools.print);
+      }
+    }
+    if (reply3.model !== null || reply3.effort !== null) {
+      const change = { model: reply3.model, effort: reply3.effort };
       void input.switchModel(change).then(
         (applied) => {
           if (applied) {
@@ -2923,7 +3530,7 @@ function specWorkTools2(job, api) {
   if (kind !== "interview" && kind !== "spec") {
     return null;
   }
-  return { stage: kind, review: (body) => api.request("POST", runPath(job.runId, "review"), body) };
+  return { stage: kind, review: (body) => api.request("POST", runPath(job.runId, "review"), body), brief: isFolderJob(job) };
 }
 function askingTools(job, api) {
   const people = job.people ?? [];
@@ -2938,11 +3545,11 @@ function permissionTools(job, tools) {
   }
   return {
     send: async (body) => {
-      const reply2 = await tools.api.request("POST", runPath(job.runId, "permissions"), body);
-      if (reply2.decision === "wait") {
+      const reply3 = await tools.api.request("POST", runPath(job.runId, "permissions"), body);
+      if (reply3.decision === "wait") {
         tools.print(`  Waiting for a person on TAMsense to allow: ${body.title || body.action}`);
       }
-      return reply2;
+      return reply3;
     },
     check: (id) => tools.api.request("GET", permissionPath(job.runId, id)),
     sleep: tools.sleep
@@ -2961,11 +3568,27 @@ function knowledgeTools2(job, api) {
     read: (entryId) => api.request("GET", knowledgePath(job.runId, entryId))
   };
 }
-async function executeJob(job, tools, signal, input, record) {
-  const isCheck = job.stage.kind === "review" || job.stage.kind === "test";
+function skillsLine(skills) {
+  return `This role uses ${skills.length} skill(s) from the library: ${skills.join(", ")}.`;
+}
+async function prepare(job, tools) {
+  if (isFolderJob(job)) {
+    tools.print("Preparing the task folder\u2026");
+    const { results, ...workspace2 } = await prepareFolder(job, taskFolder(tools.home, job), tools.api);
+    return { workspace: workspace2, results, identity: {} };
+  }
   tools.print("Preparing the code\u2026");
   const workspace = await prepareWorkspace(job, await gitToken(tools.api, job), tools);
-  const identity = await commitIdentityEnv(tools.home);
+  return { workspace, results: null, identity: await commitIdentityEnv(tools.home) };
+}
+async function executeJob(job, tools, signal, input, record) {
+  const isCheck = job.stage.kind === "review" || job.stage.kind === "test";
+  const { workspace, results, identity } = await prepare(job, tools);
+  const skills = allowedSkills(job.stage);
+  if (skills) {
+    tools.print(skillsLine(skills));
+  }
+  const library = await prepareLibrary(roleLibraryFolder(tools.home, job.runId), skills);
   signal.throwIfAborted();
   tools.print("Claude is working\u2026");
   const attached = { count: 0 };
@@ -2975,7 +3598,8 @@ async function executeJob(job, tools, signal, input, record) {
   const recording = tools.recorder ? recorderEnv({ recorder: tools.recorder, folder: recordings, server: tools.api.server, job, nodeOptions: baseEnv.NODE_OPTIONS }) : {};
   const outcome = await tools.runAgent({
     cwd: workspace.root,
-    prompt: buildTaskPrompt(job, workspace, { browser: Boolean(tools.browser), recorder: Boolean(tools.recorder) }),
+    library,
+    prompt: buildTaskPrompt(job, workspace, { browser: Boolean(tools.browser), recorder: Boolean(tools.recorder), results }),
     input,
     env: { ...baseEnv, ...tools.browser ? browserEnv(tools.browser) : {}, ...recording, ...identity },
     signal,
@@ -2990,12 +3614,14 @@ async function executeJob(job, tools, signal, input, record) {
     effort: job.effort,
     onFeed: record,
     onSession: session.report,
-    attach: (request) => request.kind === "screenshot" ? attachScreenshot(tools.api, job, request, attached) : attachRecording(tools.api, job.runId, recordings, request)
+    attach: (request) => request.kind === "screenshot" ? attachScreenshot(tools.api, job, request, attached) : attachRecording(tools.api, job.runId, recordings, request),
+    results: resultTools(job, tools.api, workspace.root),
+    handOver: handOverTools(job, tools.api)
   });
   await session.sent();
   signal.throwIfAborted();
   const waitingFor = outcome.waitingFor ?? null;
-  const shouldPublish = job.stage.kind === "code" && outcome.completed && waitingFor === null;
+  const shouldPublish = job.stage.kind === "code" && !isFolderJob(job) && !isReadOnlyCode(job.stage) && outcome.completed && waitingFor === null;
   const pushed = shouldPublish ? await publishWorkspace(workspace, job, await gitToken(tools.api, job), identity) : [];
   return {
     outcome: outcome.completed ? "succeeded" : "failed",
@@ -3016,7 +3642,7 @@ function clockOf(iso) {
   const time = new Date(iso);
   return `${String(time.getHours()).padStart(2, "0")}:${String(time.getMinutes()).padStart(2, "0")}`;
 }
-function resultLine(finish2) {
+function resultLine(finish2, folder = false) {
   if (finish2.pausedUntil) {
     return `Paused: ${USAGE_LIMIT_REPORT}, resumes at ${clockOf(finish2.pausedUntil)}`;
   }
@@ -3035,7 +3661,10 @@ function resultLine(finish2) {
   if (finish2.spec) {
     return "Done. The spec waits for the owner on TAMsense.";
   }
-  return finish2.outcome === "succeeded" ? `Done. Pushed ${finish2.pushed.length} branch(es), the pull requests open on TAMsense.` : `Failed: ${finish2.report}`;
+  if (finish2.outcome !== "succeeded") {
+    return `Failed: ${finish2.report}`;
+  }
+  return folder ? "Done. The result is on the task on TAMsense." : `Done. Pushed ${finish2.pushed.length} branch(es), the pull requests open on TAMsense.`;
 }
 async function sendRecordings(job, tools) {
   const folder = recordingsFolder(tools.home, job.runId);
@@ -3051,7 +3680,7 @@ async function sendRecordings(job, tools) {
       tools.print(`Could not attach a recording: ${line}`);
     }
   } finally {
-    await rm4(folder, { recursive: true, force: true });
+    await rm6(folder, { recursive: true, force: true });
   }
 }
 function failureReport(error, signal) {
@@ -3079,6 +3708,7 @@ async function runJob(job, tools, stop) {
   } catch (error) {
     finish2 = { outcome: "failed", report: failureReport(error, run2.signal), pushed: [], model: null, usage: null, verdict: null, handoff: null, sessionId: null, pausedUntil: null, questions: null, spec: null, waitingFor: null };
   } finally {
+    await rm6(roleLibraryFolder(tools.home, job.runId), { recursive: true, force: true });
     clearInterval(polling);
     clearInterval(feeding);
     stop.removeEventListener("abort", stopRun);
@@ -3090,14 +3720,14 @@ async function runJob(job, tools, stop) {
   }
   await feed.flush();
   if (run2.signal.reason === CLOSED_ON_SITE) {
-    await rm4(recordingsFolder(tools.home, job.runId), { recursive: true, force: true });
+    await rm6(recordingsFolder(tools.home, job.runId), { recursive: true, force: true });
     tools.print("TAMsense closed this run while it was in progress. The result was not sent.");
     return;
   }
   await sendRecordings(job, tools).catch((error) => tools.print(`Could not attach the browser recordings: ${messageOf3(error)}`));
   try {
     await tools.api.request("POST", runPath(job.runId, "finish"), finish2);
-    tools.print(resultLine(finish2));
+    tools.print(resultLine(finish2, isFolderJob(job)));
   } catch (error) {
     tools.print(`Could not send the result to TAMsense: ${messageOf3(error)}`);
   }
@@ -3126,18 +3756,18 @@ async function reportCapabilities(tools, stop) {
   }
 }
 function jobTools(job, tools, parallel) {
-  return parallel > 1 ? { ...tools, print: (line) => tools.print(`[#${job.taskId}] ${line}`) } : tools;
+  return parallel > 1 ? { ...tools, print: (line) => tools.print(`[#${job.taskId} ${job.stage.name}] ${line}`) } : tools;
 }
 async function work(tools, stop, parallel = 1) {
   tools.print(parallel > 1 ? `Waiting for tasks, up to ${parallel} at once. Press Ctrl+C to stop.` : "Waiting for tasks. Press Ctrl+C to stop.");
   const halt = new AbortController();
   const stopAll = AbortSignal.any([stop, halt.signal]);
   const running = /* @__PURE__ */ new Set();
-  const taskLock = keyedLock();
+  const folderLock = keyedLock();
   const reporting = reportCapabilities(tools, stopAll);
   const start = (job) => {
     const runTools = jobTools(job, tools, parallel);
-    const task = taskLock.run(String(job.taskId), () => runJob(job, runTools, stopAll)).catch((error) => runTools.print(`The run stopped: ${messageOf3(error)}`)).finally(() => running.delete(task));
+    const task = folderLock.run(stepFolder(job).join("/"), () => runJob(job, runTools, stopAll)).catch((error) => runTools.print(`The run stopped: ${messageOf3(error)}`)).finally(() => running.delete(task));
     running.add(task);
   };
   try {
@@ -3146,9 +3776,9 @@ async function work(tools, stop, parallel = 1) {
         await Promise.race(running);
         continue;
       }
-      let reply2;
+      let reply3;
       try {
-        reply2 = await tools.api.request("POST", NEXT_RUN_PATH);
+        reply3 = await tools.api.request("POST", NEXT_RUN_PATH);
       } catch (error) {
         if (isFatal(error)) {
           halt.abort();
@@ -3158,8 +3788,8 @@ async function work(tools, stop, parallel = 1) {
         await tools.sleep(RETRY_AFTER_ERROR_MS, stopAll);
         continue;
       }
-      if (reply2.job) {
-        start(reply2.job);
+      if (reply3.job) {
+        start(reply3.job);
       } else {
         await tools.sleep(POLL_INTERVAL_MS, stopAll);
       }
@@ -3214,7 +3844,7 @@ function stopOnInterrupt() {
   return stop.signal;
 }
 function installTools(home) {
-  return { home, nodePath: process5.execPath, env: process5.env, print, run: runProcess, exists: existsSync4 };
+  return { home, nodePath: process5.execPath, env: process5.env, print, run: runProcess, exists: existsSync5 };
 }
 async function browserForStart(home, install) {
   const installed = await installedBrowser(home);