@tamsensedev/runner 0.3.0 → 0.6.0

package/dist/cli.js

@@ -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((resolve2, 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) => resolve2({ 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((resolve2) => {
+    release = resolve2;
   });
   const nothing = {
     [Symbol.asyncIterator]: () => ({
@@ -341,15 +341,15 @@ async function probeCapabilities(stop) {
 
 // src/claude.ts
 import { fileURLToPath } from "url";
-import { createSdkMcpServer, query as query2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z2 } from "zod";
+import { createSdkMcpServer, query as query2, tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z3 } from "zod";
 
 // src/askPerson.ts
 var MAX_ASK_TRIES = 5;
 var MAX_ASK_OPTIONS = 4;
 function personLine(person) {
-  const roles = person.roles.length > 0 ? `, ${person.roles.join(", ")}` : "";
-  return `${person.id}: ${person.name} (${person.relation}, ${person.access} access${roles})`;
+  const roles = person.roles.length > 0 ? `. Team roles: ${person.roles.join("; ")}` : "";
+  return `${person.id}: ${person.name} (${person.relation}, ${person.access} access)${roles}`;
 }
 function findPerson(people, to) {
   const key = String(to).trim().toLowerCase();
@@ -402,21 +402,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(tool3, input) {
+function activityLine(tool4, input) {
   const fields = typeof input === "object" && input !== null ? input : {};
-  if (tool3 === "Bash" && typeof fields.command === "string") {
+  if (tool4 === "Bash" && typeof fields.command === "string") {
     return `$ ${shorten(fields.command)}`;
   }
-  if (FILE_TOOLS.has(tool3) && typeof fields.file_path === "string") {
-    return `${tool3} ${shorten(fields.file_path)}`;
+  if (FILE_TOOLS.has(tool4) && typeof fields.file_path === "string") {
+    return `${tool4} ${shorten(fields.file_path)}`;
   }
-  if (tool3 === "Skill" && typeof fields.skill === "string") {
+  if (tool4 === "Skill" && typeof fields.skill === "string") {
     return `Skill ${shorten(fields.skill)}`;
   }
-  if (HELPER_TOOLS.has(tool3) && typeof fields.subagent_type === "string") {
+  if (HELPER_TOOLS.has(tool4) && typeof fields.subagent_type === "string") {
     return `Agent ${shorten(fields.subagent_type)}`;
   }
-  return tool3;
+  return tool4;
 }
 function usageOf(modelUsage) {
   const entries = Object.values(modelUsage);
@@ -459,29 +459,29 @@ function textField(fields, name) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 function toolDraft(block, parent) {
-  const tool3 = (block.name ?? "tool").replace(MCP_PREFIX, "");
+  const tool4 = (block.name ?? "tool").replace(MCP_PREFIX, "");
   const fields = fieldsOf(block.input);
-  const base = { tool: tool3, ref: block.id ?? null, parent, failed: false };
-  if (tool3 === "Skill" && textField(fields, "skill")) {
+  const base = { tool: tool4, ref: block.id ?? null, parent, failed: false };
+  if (tool4 === "Skill" && textField(fields, "skill")) {
     return { ...base, kind: "skill", text: clip(textField(fields, "skill"), MAX_SUMMARY_LENGTH) };
   }
-  if (HELPER_TOOLS2.has(tool3)) {
+  if (HELPER_TOOLS2.has(tool4)) {
     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 (tool3 === "submit_verdict") {
+  if (tool4 === "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 (tool3 === "hand_off") {
+  if (tool4 === "hand_off") {
     return { ...base, kind: "tool", text: clip(`Hand off to ${textField(fields, "to") ?? "?"}: ${textField(fields, "note") ?? ""}`, MAX_SUMMARY_LENGTH) };
   }
-  if (tool3 in ATTACH_LABELS) {
-    return { ...base, kind: "tool", text: clip(`${ATTACH_LABELS[tool3]}: ${textField(fields, "title") ?? textField(fields, "path") ?? ""}`, 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) };
   }
   const command = textField(fields, "command");
-  const summary = tool3 === "Bash" && command ? `$ ${command}` : activityLine(tool3, block.input);
+  const summary = tool4 === "Bash" && command ? `$ ${command}` : activityLine(tool4, block.input);
   return { ...base, kind: "tool", text: clip(summary, MAX_SUMMARY_LENGTH) };
 }
 function resultText(content) {
@@ -653,8 +653,8 @@ function inputChannel(options = {}) {
       }
       const next = queue.shift();
       if (!next) {
-        await new Promise((resolve) => {
-          wake = resolve;
+        await new Promise((resolve2) => {
+          wake = resolve2;
         });
         continue;
       }
@@ -714,9 +714,9 @@ function inputChannel(options = {}) {
     onSwitch(apply) {
       applySwitch2 = apply;
       if (waitingSwitch) {
-        const { change, resolve } = waitingSwitch;
+        const { change, resolve: resolve2 } = waitingSwitch;
         waitingSwitch = null;
-        void apply(change).then(() => resolve(true), () => resolve(false));
+        void apply(change).then(() => resolve2(true), () => resolve2(false));
       }
     },
     close,
@@ -763,13 +763,211 @@ 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((resolve2) => {
+        waitingSwitch = { change: merged, resolve: resolve2 };
       });
     }
   };
 }
 
+// src/knowledge.ts
+import { tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+var PROPOSE_KNOWLEDGE_TOOL_NAME = "propose_knowledge";
+var UPDATE_KNOWLEDGE_TOOL_NAME = "update_knowledge";
+var READ_KNOWLEDGE_TOOL_NAME = "read_knowledge";
+var MAX_KNOWLEDGE_TITLE = 80;
+var MAX_KNOWLEDGE_TEXT = 600;
+var UPDATE_RULE = `Rely on this knowledge instead of asking people again. When you relied on an entry and found it true, call ${UPDATE_KNOWLEDGE_TOOL_NAME} with stillTrue true. When the code shows an entry is out of date (a file moved, a command or a port changed), fix it yourself at once: ${UPDATE_KNOWLEDGE_TOOL_NAME} with stillTrue false, the full new text and the evidence (the commit, the file or the command output that shows it). The change applies right away and people can revert it. Never ask a person whether an entry is still right, and never move facts of this computer into project knowledge.`;
+var PROPOSE_RULE = `When a person's answer to your question teaches something later runs need (how the team runs the local stand, where something lives, a convention), propose one short note with ${PROPOSE_KNOWLEDGE_TOOL_NAME} and the question number from the answer. Scope computer is for what is true only on this computer (folders, ports, installed tools, local quirks); scope project is for what comes from the repository and works on every computer. Never propose secrets, personal data or decisions about this one task. A person approves every note; keep working while they decide.`;
+function dateOf(iso) {
+  return iso ? `checked ${iso.slice(0, 10)}` : "not checked yet";
+}
+function entryText(entry) {
+  return `[${entry.id}] ${entry.title}: ${entry.text.replace(/\s+/g, " ").trim()} (${dateOf(entry.checkedAt)})`;
+}
+function entryLine(entry) {
+  return `- ${entryText(entry)}`;
+}
+function workplaceText(computer, folder) {
+  if (!computer) {
+    return null;
+  }
+  return `You run on ${computer.name}, the ${computer.platform} computer of ${computer.ownerName}. Your task folder is ${folder}; everything outside it belongs to ${computer.ownerName}.`;
+}
+function hasKnowledge(knowledge) {
+  return Boolean(knowledge && (knowledge.project.length > 0 || knowledge.computer.length > 0 || knowledge.more.length > 0));
+}
+function knowledgeText(knowledge, computer, canPropose) {
+  const rules = canPropose ? [PROPOSE_RULE] : [];
+  if (!hasKnowledge(knowledge)) {
+    return rules.length > 0 ? `Knowledge of this project is empty so far. ${rules.join(" ")}` : null;
+  }
+  const here = computer ? computer.name : "this computer";
+  const sections = [
+    knowledge.project.length > 0 ? `Project knowledge (approved by the team, true on every computer):
+${knowledge.project.map(entryLine).join("\n")}` : null,
+    knowledge.computer.length > 0 ? `Knowledge for ${here} only (true here, not on other computers):
+${knowledge.computer.map(entryLine).join("\n")}` : null,
+    knowledge.more.length > 0 ? `More entries, titles only to keep this short: ${knowledge.more.map((entry) => `[${entry.id}] ${entry.title} (${entry.scope})`).join("; ")}. When a title touches your work, read the entry with ${READ_KNOWLEDGE_TOOL_NAME} and its number.` : null
+  ];
+  return [...sections, UPDATE_RULE, ...rules].filter(Boolean).join("\n\n");
+}
+function knowledgeIds(knowledge) {
+  return knowledge ? [...knowledge.project, ...knowledge.computer, ...knowledge.more].map((entry) => entry.id) : [];
+}
+function failed(text2) {
+  return { content: [{ type: "text", text: text2 }], isError: true };
+}
+function done(text2) {
+  return { content: [{ type: "text", text: text2 }] };
+}
+function unknownEntry(tools, entry) {
+  return failed(`There is no entry ${entry} in this run. Use a number in square brackets from your instructions: ${tools.entryIds.join(", ") || "none"}.`);
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function proposeKnowledgeTool(tools) {
+  return tool(
+    PROPOSE_KNOWLEDGE_TOOL_NAME,
+    "Propose a short note for the TAMsense project knowledge after a person answered your question, so later runs do not ask again. A person on the task approves it: for the whole project, for this computer only, or not at all.",
+    {
+      title: z.string().describe(`a few words, at most ${MAX_KNOWLEDGE_TITLE} characters: "Local stand and database"`),
+      text: z.string().describe(`the fact in one to three plain sentences, at most ${MAX_KNOWLEDGE_TEXT} characters, with exact commands and paths in backticks`),
+      scope: z.enum(["project", "computer"]).describe("computer: true only on this computer (folders, ports, installed tools); project: comes from the repository and works everywhere"),
+      question: z.number().optional().describe('the number of the question whose answer this comes from, as in "(question 31)"')
+    },
+    async (args) => {
+      const title = args.title.trim();
+      const text2 = args.text.trim();
+      if (!title || !text2 || title.length > MAX_KNOWLEDGE_TITLE || text2.length > MAX_KNOWLEDGE_TEXT) {
+        return failed(`Write a title of at most ${MAX_KNOWLEDGE_TITLE} characters and a text of at most ${MAX_KNOWLEDGE_TEXT}.`);
+      }
+      try {
+        await tools.propose({ title, text: text2, scope: args.scope, question: args.question ?? null });
+      } catch (error) {
+        return failed(`The note was not suggested: ${messageOf(error)}`);
+      }
+      return done("Suggested. A person on the task decides whether to save it; keep working.");
+    }
+  );
+}
+function updateKnowledgeTool(tools) {
+  return tool(
+    UPDATE_KNOWLEDGE_TOOL_NAME,
+    "Keep the TAMsense knowledge current. stillTrue true: you relied on the entry and it holds. stillTrue false: the code shows it is out of date; the new text applies at once and people see your evidence.",
+    {
+      entry: z.number().describe("the entry number in square brackets from your instructions"),
+      stillTrue: z.boolean(),
+      text: z.string().optional().describe(`when stillTrue is false: the full new text, at most ${MAX_KNOWLEDGE_TEXT} characters`),
+      evidence: z.string().optional().describe("when stillTrue is false: one line on what shows the old text is wrong, such as a commit, a file or a command output")
+    },
+    async (args) => {
+      if (!tools.entryIds.includes(args.entry)) {
+        return unknownEntry(tools, args.entry);
+      }
+      const text2 = args.text?.trim() ?? "";
+      const evidence = args.evidence?.trim() ?? "";
+      if (!args.stillTrue && (!text2 || !evidence || text2.length > MAX_KNOWLEDGE_TEXT)) {
+        return failed(`An update needs the full new text (at most ${MAX_KNOWLEDGE_TEXT} characters) and the evidence.`);
+      }
+      try {
+        await tools.update(args.entry, { stillTrue: args.stillTrue, text: text2, evidence });
+      } catch (error) {
+        return failed(`The entry was not updated: ${messageOf(error)}`);
+      }
+      return done(args.stillTrue ? "Marked as checked today." : "Updated. People see the old text, your evidence and can revert it.");
+    }
+  );
+}
+function readKnowledgeTool(tools) {
+  return tool(
+    READ_KNOWLEDGE_TOOL_NAME,
+    "Read a TAMsense knowledge entry that your instructions list by title only.",
+    {
+      entry: z.number().describe("the entry number in square brackets from your instructions")
+    },
+    async (args) => {
+      if (!tools.entryIds.includes(args.entry)) {
+        return unknownEntry(tools, args.entry);
+      }
+      try {
+        return done(entryText(await tools.read(args.entry)));
+      } catch (error) {
+        return failed(`The entry was not read: ${messageOf(error)}`);
+      }
+    }
+  );
+}
+
+// src/permissions.ts
+var NOBODY_TO_ASK = "Nobody is at the computer to approve this during a TAMsense run. Do it another way, or explain in your report why it is needed.";
+var CHECK_INTERVAL_MS = 5e3;
+var SITE_SILENCE_MS = 6e4;
+var MAX_ACTION_LENGTH = 4e3;
+var STOPPED_TEXT2 = "The run is stopping, so this was not done.";
+var SITE_SILENT_TEXT = "TAMsense did not answer about this action, so it was not done. Do it another way, or explain in your report why it is needed.";
+var NEVER_SENT = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
+var ACTION_FIELDS = ["command", "file_path", "notebook_path", "url", "query", "path"];
+function actionOf(input) {
+  const field = ACTION_FIELDS.map((key) => input[key]).find((value) => typeof value === "string" && value.trim());
+  return (typeof field === "string" ? field.trim() : JSON.stringify(input)).slice(0, MAX_ACTION_LENGTH);
+}
+function titleOf(input, options) {
+  const described = typeof input.description === "string" ? input.description.trim() : "";
+  return described || options.title?.trim() || options.displayName?.trim() || "";
+}
+function deny(message) {
+  return { behavior: "deny", message };
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(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") {
+    await tools.sleep(CHECK_INTERVAL_MS, signal);
+    if (signal.aborted) {
+      return STOPPED_TEXT2;
+    }
+    if (now() > giveUpAt) {
+      return SITE_SILENT_TEXT;
+    }
+    reply2 = await tools.check(reply2.id).catch(() => reply2);
+  }
+  return reply2;
+}
+function askPermission(tools, lastWords, folder) {
+  return async (toolName, input, options) => {
+    if (NEVER_SENT.has(toolName)) {
+      return deny(NOBODY_TO_ASK);
+    }
+    const body = {
+      tool: toolName,
+      action: actionOf(input),
+      title: titleOf(input, options),
+      reason: lastWords() || options.decisionReason || "",
+      folder,
+      outsideFolder: Boolean(options.blockedPath)
+    };
+    let first;
+    try {
+      first = await tools.send(body);
+    } 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);
+    }
+    return reply2.decision === "allow" ? { behavior: "allow", updatedInput: input } : deny(reply2.message);
+  };
+}
+var denyWhenAsked = async () => deny(NOBODY_TO_ASK);
+
 // src/specText.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -850,6 +1048,206 @@ function specPromptText(spec) {
   ].filter(Boolean).join("\n\n");
 }
 
+// src/workspace.ts
+import { existsSync as existsSync2 } from "fs";
+import { rm as rm2 } from "fs/promises";
+import { join as join2, resolve } from "path";
+
+// src/git.ts
+import { Buffer } from "buffer";
+import { spawn as spawn2 } 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((resolve2, 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) => resolve2({ 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((resolve2) => {
+        release = resolve2;
+      });
+      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 join2(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(join2(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 rm2(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) => resolve(holder) !== resolve(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(join2(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 });
+}
+async function prepareWorkspace(job, token, tools) {
+  const root = tamsenseFolder(tools.home, "work", ...stepFolder(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 = join2(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";
@@ -860,8 +1258,9 @@ var SUBMIT_QUESTIONS_TOOL_NAME = "submit_questions";
 var SUBMIT_SPEC_TOOL_NAME = "submit_spec";
 var ASK_PERSON_TOOL_NAME = "ask_person";
 var MESSAGES_RULE = `You are working on a TAMsense task on the user's own computer. People on the task may send you messages during this run, each starting with "Message from <name>:". Follow them: they take priority over the original task where the two disagree.`;
-var UNATTENDED_RULE = `${MESSAGES_RULE} Nobody answers questions or approves actions during the run, so never stop to wait for a reply: decide yourself, keep working, and explain your decisions in your report.`;
+var UNATTENDED_RULE = `${MESSAGES_RULE} Nobody answers questions during the run, so never stop to wait for a reply: decide yourself, keep working, and explain your decisions in your report.`;
 var ASKING_RULE = `${MESSAGES_RULE} Decide yourself when you reasonably can, keep working, and explain your decisions in your report. When you are stuck, or the decision belongs to a person (intent, design, access, how the team runs something locally), ask one of the people on the task with the ${ASK_PERSON_TOOL_NAME} tool instead of guessing, and say what you tried. Never ask what the code or the project knowledge already answers. Nobody watches your messages, so ask only with the tool.`;
+var APPROVAL_RULE = "Some actions need a person's approval. When Claude Code would ask for one, TAMsense checks the project safety rules: a Never action is refused at once, an Allowed one goes ahead, and anything else goes to a person on the task while your tool call waits up to 15 minutes. Before such an action, write one short line: why you need it and what you will do instead if it is denied. Never get around a refused action with another command that has the same effect.";
 var MACHINE_RULE = "This is the person's own computer, and their other programs may be running on it. Stop only the processes you started yourself, by their process id, and stop them before you finish. Never kill processes by name or pattern (taskkill /IM, pkill, killall, Stop-Process -Name) and never touch programs you did not start.";
 var CODE_RULES = [
   "Make the changes the task asks for, and keep them focused on it.",
@@ -882,8 +1281,11 @@ var NAMING_RULE = 'Name everything you attach (screenshots, replays, videos) by
 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 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.",
@@ -927,6 +1329,9 @@ function contextText(context) {
   return context.trim() ? `Project context from the team (follow it like the project's own rules):
 ${context.trim()}` : null;
 }
+function safetyText(job) {
+  return job.safetyRules?.trim() || null;
+}
 function bulletList(lines) {
   return lines.map((line) => `- ${line}`).join("\n");
 }
@@ -935,7 +1340,7 @@ function repositoryLines(job, workspace) {
   return workspace.repositories.map((repository) => {
     const source = sourceOf.get(repository.fullName);
     const pull = source?.pullRequestUrl ? `, pull request ${source.pullRequestUrl}` : "";
-    return `${repository.folder} (${repository.fullName}), base branch origin/${source?.defaultBranch ?? "main"}${pull}`;
+    return `${repository.folder} (${repository.fullName}) at commit ${repository.baseSha.slice(0, 7)}, base branch origin/${source?.defaultBranch ?? "main"}${pull}`;
   });
 }
 function stepLine(stage) {
@@ -950,11 +1355,14 @@ function peopleText(people) {
     return null;
   }
   return [
-    `People on this task you can ask with ${ASK_PERSON_TOOL_NAME} (id: name, relation, access):`,
+    `People on this task you can ask with ${ASK_PERSON_TOOL_NAME} (id: name, relation, access, then their team roles with what each owns):`,
     bulletList(people.map(personLine)),
-    "Ask the assignee first; a question on a topic goes to the person whose role fits it. Set blocking only when you cannot go on without the answer: the run then pauses and the computer is freed for other tasks. Otherwise give the assumption you continue with."
+    'Ask the assignee first. A question on a topic goes to the person whose team role fits it, and then why names that role and what it owns, for example "Designer, owns empty states". Set blocking only when you cannot go on without the answer: the run then pauses and the computer is freed for other tasks. Otherwise give the assumption you continue with.'
   ].join("\n");
 }
+function canProposeKnowledge(job) {
+  return job.knowledge !== void 0 && (job.people ?? []).length > 0 && job.stage.kind !== "interview" && job.stage.kind !== "spec";
+}
 function handoffText(targets, isCheck) {
   if (targets.length === 0) {
     return null;
@@ -1017,6 +1425,7 @@ ${JSON.stringify(job.spec)}` : null,
   const instructions = [
     SPEC_UNATTENDED_RULE,
     MACHINE_RULE,
+    workplaceText(job.computer, workspace.root),
     stepLine(job.stage),
     job.stage.instructions,
     contextText(job.projectContext),
@@ -1025,6 +1434,8 @@ ${bulletList(repositoryLines(job, workspace))}`,
     READ_ONLY_RULE,
     `How to work:
 ${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 };
@@ -1050,18 +1461,22 @@ ${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 localApp = localAppRule(job, 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 instructions = [
     canAsk ? ASKING_RULE : UNATTENDED_RULE,
     MACHINE_RULE,
+    workplaceText(job.computer, workspace.root),
     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)}`,
+    safetyText(job),
+    knowledgeText(job.knowledge, job.computer, canProposeKnowledge(job)),
+    APPROVAL_RULE,
     peopleText(people),
     handoffText(job.allowedHandoffs, isCheck),
     options.browser && BROWSER_RULE
@@ -1070,98 +1485,98 @@ ${bulletList(rules)}`,
 }
 
 // src/specTools.ts
-import { tool } from "@anthropic-ai/claude-agent-sdk";
-import { z } from "zod";
+import { tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
 var MAX_FIRST_ROUND = 4;
-var questionSchema = z.object({
-  id: z.string().describe('Stable snake_case id, unique in the task, for example "empty_state"'),
-  question: z.string().describe("One plain sentence the owner can answer without reading code"),
-  whyItMatters: z.string().describe("One line: what changes in the result depending on the answer"),
-  options: z.array(z.object({
-    label: z.string().describe('Short, concrete answer (1-6 words), without "(Recommended)": use the recommended flag'),
-    description: z.string().describe("One sentence: what happens if this option is chosen"),
-    recommended: z.boolean().describe("true on the option you recommend (in a multiSelect question, on every option you recommend). Recommended options come first")
+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")
   })).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: z.boolean().describe("true only when the options are additive and several can apply together")
+  multiSelect: z2.boolean().describe("true only when the options are additive and several can apply together")
 });
-var briefSchema = z.object({
-  findings: z.array(z.object({
-    fact: z.string().describe("What the code does today that matters for this task"),
-    where: z.string().describe("Where it is: owner/repo path:line")
+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")
   })).describe("Findings from the code"),
-  dataFacts: z.array(z.string()).describe("Numbers and facts from the events or the business data, each with its source. Empty when the task needs no data"),
-  approach: z.string().describe("The approach you would take, in 2-4 sentences"),
-  codeMap: z.array(z.object({
-    repo: z.string().describe("Repository full name (owner/name)"),
-    file: z.string().describe("Path relative to the repository root"),
-    role: z.string().describe("Why it matters: what to change or reuse there")
+  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")
   })).describe("The files the change will touch or must reuse"),
-  assumptions: z.array(z.object({
-    text: z.string().describe("The default you chose"),
-    reason: z.string().describe("Why it is safe or why it was chosen")
+  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")
   })).describe("Corners settled with a default instead of a question"),
-  pendingDecisions: z.array(z.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
+  pendingDecisions: z2.array(z2.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
 });
-var questionsPayloadSchema = z.object({
+var questionsPayloadSchema = z2.object({
   brief: briefSchema,
-  questions: z.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: 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`)
 });
-var specSchema = z.object({
-  goal: z.string().describe("The problem solved, for whom, and the outcome a user or the business will notice"),
-  context: z.string().describe("Summary: the problem in 1-2 sentences, then the chosen approach in 1-2 sentences"),
-  inScope: z.array(z.string()).describe("What this task delivers, one item each"),
-  outOfScope: z.array(z.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: z.array(z.object({
-    question: z.string(),
-    answer: z.string(),
-    by: z.enum(["owner", "agent"]).describe("owner: answered by a person; agent: your own call")
+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")
   })).describe("Every answered question with by: owner, and your own calls that matter with by: agent"),
-  codeMap: z.array(z.object({
-    repo: z.string().describe("Repository full name (owner/name)"),
-    file: z.string().describe("Path relative to the repository root"),
-    role: z.string().describe("What the coder needs to know about this file"),
-    use: z.enum(["reuse", "change", "keep"]).describe("reuse: build on it; change: it is in changes; keep: do not touch")
+  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")
   })).describe("The files a coder must read before starting"),
-  changes: z.array(z.object({
-    repo: z.string().describe("Repository full name (owner/name) where the change happens"),
-    file: z.string().describe("Path to the file, relative to the repository root"),
-    action: z.enum(["create", "modify", "delete"]),
-    description: z.string().describe("The behaviour the file has after the change and which existing functions or patterns to extend. No code snippets or diffs"),
-    produces: z.array(z.string()).describe("Names with signatures or data shapes this change creates or changes for other changes. Empty when none"),
-    consumes: z.array(z.string()).describe("Names with signatures or data shapes this change uses from earlier changes. Empty when none"),
-    acceptance: z.array(z.string()).describe("Ids of the criteria this change makes true, like AC-1")
+  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")
   })).min(1).describe("File changes in dependency order: each uses only what earlier changes or the code already provide"),
-  acceptance: z.array(z.object({
-    id: z.string().describe("AC-1, AC-2 and so on, in order"),
-    kind: z.enum(["main", "edge", "keep"]).describe("main: the main path; edge: an error, empty or limit case; keep: existing behaviour that must keep working"),
-    text: z.string().describe('"Given <state>, when <action>, then <observable result>", saying where to look. No file paths or function names')
+  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')
   })).min(1).describe("Acceptance criteria: main path first, then edge cases, then what must keep working"),
-  testPlan: z.object({
-    automated: z.array(z.object({
-      repo: z.string(),
-      command: z.string().describe("The exact command to run"),
-      expect: z.string().describe("What passing looks like")
+  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")
     })).describe("At least one command"),
-    newTests: z.array(z.object({
-      seam: z.string().describe("Where the test goes: the highest seam that covers the behaviour (an endpoint, a page, a public function)"),
-      covers: z.array(z.string()).describe("Ids of the criteria it covers")
+    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")
     })),
-    manual: z.array(z.object({
-      page: z.string().describe("The page or screen"),
-      steps: z.string().describe("What a person does and sees")
+    manual: z2.array(z2.object({
+      page: z2.string().describe("The page or screen"),
+      steps: z2.string().describe("What a person does and sees")
     }))
   }),
-  risks: z.array(z.object({
-    risk: z.string(),
-    mitigation: z.string()
+  risks: z2.array(z2.object({
+    risk: z2.string(),
+    mitigation: z2.string()
   })).describe("What could go wrong: migrations, existing data, access, performance, compatibility"),
-  riskLevel: z.enum(["low", "medium", "high"]).describe("How closely a person should review the result"),
-  assumptions: z.array(z.object({
-    text: z.string().describe("The default you chose"),
-    reason: z.string().describe("Why, so the owner can confirm or correct it quickly")
+  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")
   })).describe("Defaults chosen where the task was silent. Empty when nothing was assumed"),
-  openQuestions: z.array(questionSchema).describe("Questions only the owner can settle; the spec cannot be approved until each is answered or dismissed. Empty when none"),
-  split: z.array(z.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: 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")
 });
 function reply(text2, isError = false) {
   return { content: [{ type: "text", text: text2 }], ...isError ? { isError: true } : {} };
@@ -1171,7 +1586,7 @@ function unreachable(error, toolName) {
   return reply(`Could not reach TAMsense to check this: ${message}. Call ${toolName} again in a moment.`, true);
 }
 function questionsTool(review, onSubmit) {
-  return tool(
+  return tool2(
     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,
@@ -1194,7 +1609,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 tool(
+  return tool2(
     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,
@@ -1314,14 +1729,12 @@ function usageLimitWatch() {
 }
 
 // src/claude.ts
-var NOBODY_TO_ASK = "Nobody is at the computer to approve this during a TAMsense run. Do it another way, or explain in your report why it is needed.";
 var NO_RESULT_TEXT = "Claude finished without a result.";
 var SERVER_NAME = "tamsense";
 var LIBRARY_PATH = fileURLToPath(new URL("../library", import.meta.url));
-var denyWhenAsked = async () => ({ behavior: "deny", message: NOBODY_TO_ASK });
 var CAPTION_FIELDS = {
-  title: z2.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: z2.string().describe('one line, at most 160 characters, on why it was made: "Comparing two layouts for the empty orders state"')
+  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"')
 };
 var ATTACH_TOOLS = {
   screenshot: {
@@ -1342,21 +1755,21 @@ var ATTACH_TOOLS = {
 };
 function attachTool(kind, attach) {
   const spec = ATTACH_TOOLS[kind];
-  return tool2(
+  return tool3(
     spec.name,
     spec.description,
-    { path: z2.string().describe(spec.path), ...CAPTION_FIELDS },
+    { path: z3.string().describe(spec.path), ...CAPTION_FIELDS },
     async (args) => ({ content: [{ type: "text", text: await attach({ kind, ...args }) }] })
   );
 }
 function verdictTool(onVerdict) {
-  return tool2(
+  return tool3(
     VERDICT_TOOL_NAME,
     "Hand in the result of this check. Call it exactly once, at the very end.",
     {
-      passed: z2.boolean().describe("true only if nothing must be fixed"),
-      report: z2.string().describe("what you checked and, if it failed, exactly what to fix with file and line"),
-      couldNotRun: z2.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: 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")
     },
     async (args) => {
       onVerdict(args.couldNotRun ? { passed: false, report: args.report, couldNotRun: true } : { passed: args.passed, report: args.report });
@@ -1365,13 +1778,13 @@ function verdictTool(onVerdict) {
   );
 }
 function handoffTool(targets, onHandoff) {
-  return tool2(
+  return tool3(
     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: z2.string().describe("name or id of the step to hand the task to"),
-      outcome: z2.enum(HANDOFF_OUTCOMES).describe("pass: the work is done; problems: something must be fixed; ask: a question for that step"),
-      note: z2.string().describe("for the next agent and the owner: what was done, what to check, what is open")
+      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")
     },
     async (args) => {
       const choice = chooseHandoff(targets, args);
@@ -1384,25 +1797,25 @@ function handoffTool(targets, onHandoff) {
   );
 }
 function askPersonTool(asking, waiting) {
-  return tool2(
+  return tool3(
     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: z2.union([z2.number(), z2.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: z2.string().describe('one line on why this person: "assignee, and the run is on her computer", "Designer, owns empty states"'),
-      question: z2.string().describe("one plain question the person can answer without reading the code"),
-      context: z2.string().optional().describe("one line on what you saw that led to the question"),
-      tried: z2.array(z2.object({
-        did: z2.string().describe("the command or step"),
-        error: z2.string().optional().describe("the exact error line, if there was one"),
-        result: z2.string().describe("what it showed, one line")
+      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")
       })).max(MAX_ASK_TRIES).optional().describe("what you already tried, the most telling first"),
-      options: z2.array(z2.object({
-        label: z2.string().describe("a short answer the person can pick"),
-        detail: z2.string().describe("one line on what happens if it is picked")
+      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")
       })).max(MAX_ASK_OPTIONS).optional().describe("2 to 4 answers you suggest, the one you would pick first"),
-      blocking: z2.boolean().describe("true when you cannot go on without the answer"),
-      assumption: z2.string().optional().describe("when blocking is false: what you continue with until the answer comes")
+      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")
     },
     async (args) => {
       if (waiting.waitingFor !== null) {
@@ -1435,6 +1848,16 @@ function specWorkTools(specWork, submitted) {
     submitted.spec = spec;
   }, () => submitted.helperStarted)];
 }
+function knowledgeTools(knowledge) {
+  if (!knowledge) {
+    return [];
+  }
+  return [
+    ...knowledge.entryIds.length > 0 ? [updateKnowledgeTool(knowledge)] : [],
+    ...knowledge.moreIds.length > 0 ? [readKnowledgeTool(knowledge)] : [],
+    ...knowledge.canPropose ? [proposeKnowledgeTool(knowledge)] : []
+  ];
+}
 function tamsenseServer(request, submitted) {
   const tools = [
     attachTool("screenshot", request.attach),
@@ -1445,6 +1868,7 @@ function tamsenseServer(request, submitted) {
     })] : [],
     ...specWorkTools(request.specWork, submitted),
     ...request.asking ? [askPersonTool(request.asking, submitted)] : [],
+    ...knowledgeTools(request.knowledge),
     ...request.handoffs.length > 0 ? [handoffTool(request.handoffs, (handoff) => {
       submitted.handoff = handoff;
     })] : []
@@ -1483,7 +1907,8 @@ async function attempt(request, context, resume) {
       permissionMode: "auto",
       // краткий пересказ размышлений Claude идёт в журнал задачи, как в Paseo
       thinking: { type: "adaptive", display: "summarized" },
-      canUseTool: denyWhenAsked,
+      // режим auto сам решает, что можно; о чём он спросил бы человека, решают правила проекта или люди задачи
+      canUseTool: request.permissions ? askPermission(request.permissions, () => context.lastWords.text, request.cwd) : denyWhenAsked,
       plugins: [{ type: "local", path: LIBRARY_PATH }],
       mcpServers: { [SERVER_NAME]: tamsense.server },
       allowedTools: tamsense.allowed,
@@ -1512,6 +1937,7 @@ async function attempt(request, context, resume) {
         request.onFeed(draft);
         if (draft.kind === "text" && draft.parent === null) {
           lastText = draft.text;
+          context.lastWords.text = draft.text;
         }
       }
       if (message.type === "result") {
@@ -1538,7 +1964,7 @@ function claudeRunner(startQuery) {
     }, { once: true });
     const submitted = { verdict: null, handoff: null, questions: null, spec: null, helperStarted: false, waitingFor: null };
     const limit = usageLimitWatch();
-    const context = { startQuery, abortController, submitted, limit };
+    const context = { startQuery, abortController, submitted, limit, lastWords: { text: "" } };
     try {
       let result = await attempt(request, context, request.resumeSessionId);
       if (result.resumeFailed) {
@@ -1555,13 +1981,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 mkdir2, readFile as readFile2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname2, join as join3 } from "path";
 var OWNER_ONLY_FILE = 384;
 var OWNER_ONLY_FOLDER = 448;
 function configPath(home = homedir2()) {
-  return join2(home, ".tamsense", "runner.json");
+  return join3(home, ".tamsense", "runner.json");
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1593,7 +2019,7 @@ async function writeConfig(config, path = configPath()) {
 `, { mode: OWNER_ONLY_FILE });
 }
 async function removeConfig(path = configPath()) {
-  await rm2(path, { force: true });
+  await rm3(path, { force: true });
 }
 
 // src/protocol.ts
@@ -1608,6 +2034,12 @@ 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}`;
 }
@@ -1641,14 +2073,14 @@ async function login(tools, request) {
 }
 
 // src/recorderEnv.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
 import { fileURLToPath as fileURLToPath2 } 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, dirname as dirname3, join as join4 } from "path";
 import process2 from "process";
 var RECORDINGS_DIR_ENV = "TAMSENSE_RECORDINGS_DIR";
 var SERVER_ENV = "TAMSENSE_SERVER";
@@ -1729,7 +2161,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(join4(dirname3(entry), "rrweb.umd.min.cjs"), "utf8");
 }
 function pageScript(rrweb) {
   return `(() => {
@@ -1780,8 +2212,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 = join4(dir, `${id}${REPLAY_SUFFIX}`);
+    this.metaFile = join4(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();
@@ -1954,10 +2386,10 @@ if (process2.env[RECORDINGS_DIR_ENV]) {
 var RECORDER_ENV = "TAMSENSE_RECORDER";
 function bundledRecorder() {
   const path = fileURLToPath2(new URL("./recorder.cjs", import.meta.url));
-  return existsSync2(path) ? path : null;
+  return existsSync3(path) ? path : null;
 }
 function recordingsFolder(home, runId) {
-  return join4(home, ".tamsense", "recordings", `run-${runId}`);
+  return join5(home, ".tamsense", "recordings", `run-${runId}`);
 }
 function nodeOptionsWithRecorder(recorder, nodeOptions) {
   return [nodeOptions?.trim(), `--require "${recorder.replaceAll("\\", "/")}"`].filter(Boolean).join(" ");
@@ -1984,7 +2416,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";
@@ -2008,7 +2440,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();
@@ -2028,7 +2460,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";
@@ -2083,8 +2515,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((resolve2, 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);
@@ -2094,7 +2526,7 @@ function relaunch(argv, env) {
     });
     child.on("close", (code) => {
       process3.off("SIGINT", ignoreInterrupt);
-      resolve(code ?? 1);
+      resolve2(code ?? 1);
     });
   });
 }
@@ -2140,37 +2572,11 @@ 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 done = new Promise((resolve) => {
-        release = resolve;
-      });
-      const tail = previous.then(() => done);
-      tails.set(key, tail);
-      await previous;
-      try {
-        return await work2();
-      } finally {
-        release();
-        if (tails.get(key) === tail) {
-          tails.delete(key);
-        }
-      }
-    }
-  };
-}
-
 // 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 { basename as basename2, dirname as dirname4, extname, isAbsolute, join as join6 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { Readable } from "stream";
 import { promisify } from "util";
@@ -2242,12 +2648,12 @@ async function readMeta(file) {
 }
 async function metaFor(kind, file) {
   if (kind === "replay") {
-    return readMeta(join5(dirname4(file), `${sessionIdOf(file)}${META_SUFFIX}`));
+    return readMeta(join6(dirname4(file), `${sessionIdOf(file)}${META_SUFFIX}`));
   }
   const folder = basename2(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(join6(folder, name));
       if (meta?.video === file) {
         return meta;
       }
@@ -2257,33 +2663,33 @@ 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 readFile3(join6(dir, LEDGER_FILE), "utf8")));
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
 async function remember(dir, file) {
-  const done = await ledger(dir);
-  done.add(file);
-  await writeFile3(join5(dir, LEDGER_FILE), JSON.stringify([...done]));
+  const done2 = await ledger(dir);
+  done2.add(file);
+  await writeFile3(join6(dir, LEDGER_FILE), JSON.stringify([...done2]));
 }
 async function nonEmpty(file) {
   return file !== null && ((await stat(file).catch(() => null))?.size ?? 0) > 0;
 }
 async function pendingRecordings(dir) {
-  const done = await ledger(dir);
+  const done2 = await ledger(dir);
   const names = (await readdir(dir).catch(() => [])).sort();
   const pending = [];
   for (const name of names) {
     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}`);
-    if (!done.has(replay) && await nonEmpty(replay)) {
+    const meta = await readMeta(join6(dir, name));
+    const replay = join6(dir, `${name.slice(0, -META_SUFFIX.length)}${REPLAY_SUFFIX}`);
+    if (!done2.has(replay) && await nonEmpty(replay)) {
       pending.push({ kind: "replay", file: replay, meta });
     }
-    if (meta?.video && !done.has(meta.video) && await nonEmpty(meta.video)) {
+    if (meta?.video && !done2.has(meta.video) && await nonEmpty(meta.video)) {
       pending.push({ kind: "video", file: meta.video, meta });
     }
   }
@@ -2421,149 +2827,6 @@ async function readScreenshot(request) {
   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;
-}
-
 // src/worker.ts
 var POLL_INTERVAL_MS = 5e3;
 var RETRY_AFTER_ERROR_MS = 15e3;
@@ -2574,7 +2837,7 @@ var FEED_INTERVAL_MS = 1500;
 var FATAL_STATUSES = /* @__PURE__ */ new Set([401, 403]);
 var STOPPED_HERE = "stopped_here";
 var CLOSED_ON_SITE = "closed_on_site";
-function messageOf(error) {
+function messageOf3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function isFatal(error) {
@@ -2594,7 +2857,7 @@ async function attachScreenshot(api, job, screenshot, attached) {
   try {
     await api.request("POST", runPath(job.runId, "attachments"), body);
   } catch (error) {
-    return `Could not attach the screenshot: ${messageOf(error)}`;
+    return `Could not attach the screenshot: ${messageOf3(error)}`;
   }
   attached.count += 1;
   return "Attached to the task.";
@@ -2604,7 +2867,7 @@ function sessionReporter(api, job, print2) {
   return {
     report: (session) => {
       sending ??= api.request("POST", runPath(job.runId, "session"), session).then(() => {
-      }, (error) => print2(`Could not tell TAMsense which Claude took the task: ${messageOf(error)}`));
+      }, (error) => print2(`Could not tell TAMsense which Claude took the task: ${messageOf3(error)}`));
     },
     sent: async () => {
       await sending;
@@ -2638,7 +2901,7 @@ function inbox(job, tools, record, closedOnSite) {
     } catch (error) {
       input.restoreDelivered(ack);
       if (!failing) {
-        tools.print(`Could not check for new messages on TAMsense, trying again: ${messageOf(error)}`);
+        tools.print(`Could not check for new messages on TAMsense, trying again: ${messageOf3(error)}`);
       }
       failing = true;
       return;
@@ -2661,7 +2924,7 @@ function inbox(job, tools, record, closedOnSite) {
             record({ kind: "tool", text: switchLine(change), tool: "model", ref: null, parent: null, failed: false });
           }
         },
-        (error) => tools.print(`Could not switch the model: ${messageOf(error)}`)
+        (error) => tools.print(`Could not switch the model: ${messageOf3(error)}`)
       );
     }
   }
@@ -2703,6 +2966,35 @@ function askingTools(job, api) {
   }
   return { people, send: (body) => api.request("POST", runPath(job.runId, "questions"), body) };
 }
+function permissionTools(job, tools) {
+  if (job.stage.kind === "interview" || job.stage.kind === "spec") {
+    return null;
+  }
+  return {
+    send: async (body) => {
+      const reply2 = await tools.api.request("POST", runPath(job.runId, "permissions"), body);
+      if (reply2.decision === "wait") {
+        tools.print(`  Waiting for a person on TAMsense to allow: ${body.title || body.action}`);
+      }
+      return reply2;
+    },
+    check: (id) => tools.api.request("GET", permissionPath(job.runId, id)),
+    sleep: tools.sleep
+  };
+}
+function knowledgeTools2(job, api) {
+  if (!job.knowledge) {
+    return null;
+  }
+  return {
+    entryIds: knowledgeIds(job.knowledge),
+    moreIds: job.knowledge.more.map((entry) => entry.id),
+    canPropose: canProposeKnowledge(job),
+    propose: (body) => api.request("POST", runPath(job.runId, "knowledge"), body),
+    update: (entryId, body) => api.request("POST", knowledgePath(job.runId, entryId), body),
+    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";
   tools.print("Preparing the code\u2026");
@@ -2724,6 +3016,8 @@ async function executeJob(job, tools, signal, input, record) {
     wantsVerdict: isCheck,
     specWork: specWorkTools2(job, tools.api),
     asking: askingTools(job, tools.api),
+    permissions: permissionTools(job, tools),
+    knowledge: knowledgeTools2(job, tools.api),
     handoffs: job.allowedHandoffs,
     resumeSessionId: job.resumeSessionId,
     model: job.model,
@@ -2795,7 +3089,7 @@ async function sendRecordings(job, tools) {
   }
 }
 function failureReport(error, signal) {
-  return signal.reason === STOPPED_HERE ? "The run was stopped on the computer." : `The run stopped on the computer: ${messageOf(error)}`;
+  return signal.reason === STOPPED_HERE ? "The run was stopped on the computer." : `The run stopped on the computer: ${messageOf3(error)}`;
 }
 async function runJob(job, tools, stop) {
   tools.print(`Task #${job.taskId}: ${job.title} (${job.stage.name})`);
@@ -2834,12 +3128,12 @@ async function runJob(job, tools, stop) {
     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: ${messageOf(error)}`));
+  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));
   } catch (error) {
-    tools.print(`Could not send the result to TAMsense: ${messageOf(error)}`);
+    tools.print(`Could not send the result to TAMsense: ${messageOf3(error)}`);
   }
 }
 async function reportCapabilities(tools, stop) {
@@ -2858,7 +3152,7 @@ async function reportCapabilities(tools, stop) {
       }
     } catch (error) {
       if (!complained && !stop.aborted) {
-        tools.print(`Could not tell TAMsense which Claude models this computer has: ${messageOf(error)}`);
+        tools.print(`Could not tell TAMsense which Claude models this computer has: ${messageOf3(error)}`);
         complained = true;
       }
     }
@@ -2866,18 +3160,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: ${messageOf(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 {
@@ -2894,7 +3188,7 @@ async function work(tools, stop, parallel = 1) {
           halt.abort();
           throw error;
         }
-        tools.print(`Could not reach TAMsense: ${messageOf(error)}. Trying again soon.`);
+        tools.print(`Could not reach TAMsense: ${messageOf3(error)}. Trying again soon.`);
         await tools.sleep(RETRY_AFTER_ERROR_MS, stopAll);
         continue;
       }