@tamsensedev/runner 0.9.0 → 0.13.0

package/dist/cli.js

@@ -1,12 +1,136 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir3 } from "os";
-import process5 from "process";
+import process7 from "process";
+
+// src/api.ts
+import { setTimeout as wait } from "timers/promises";
+
+// src/connection.ts
+var BUSY_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var REFUSED_STATUSES = /* @__PURE__ */ new Set([429, 503]);
+var NOT_FOUND_CODES = /* @__PURE__ */ new Set(["ENOTFOUND", "EAI_AGAIN"]);
+var NO_CONNECTION_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENETUNREACH", "EHOSTUNREACH", "ENETDOWN", "UND_ERR_CONNECT_TIMEOUT"]);
+var CLOSED_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "EPIPE", "ECONNABORTED", "UND_ERR_SOCKET", "UND_ERR_CLOSED"]);
+var TIMEOUT_CODES = /* @__PURE__ */ new Set(["ETIMEDOUT", "UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT"]);
+var CERTIFICATE_CODE = /CERT|SELF_SIGNED|UNABLE_TO_VERIFY|ERR_TLS/;
+function codeOf(error) {
+  for (let current = error, depth = 0; current && typeof current === "object" && depth < 5; depth += 1) {
+    const fields = current;
+    if (typeof fields.code === "string") {
+      return fields.code;
+    }
+    current = fields.cause ?? (Array.isArray(fields.errors) ? fields.errors[0] : null);
+  }
+  return null;
+}
+function isTimeout(error) {
+  return error instanceof Error && error.name === "TimeoutError";
+}
+function networkFailure(error, server, timeoutMs) {
+  const host = new URL(server).host;
+  const code = codeOf(error);
+  if (isTimeout(error)) {
+    return { kind: "timeout", text: `TAMsense did not answer in ${Math.round(timeoutMs / 1e3)} seconds`, unsent: false, waitMs: null };
+  }
+  if (code && TIMEOUT_CODES.has(code)) {
+    return { kind: "timeout", text: `TAMsense did not answer in time (${code})`, unsent: false, waitMs: null };
+  }
+  if (code && NOT_FOUND_CODES.has(code)) {
+    return { kind: "no_address", text: `Could not find ${host} (${code}). Check the internet connection`, unsent: true, waitMs: null };
+  }
+  if (code && NO_CONNECTION_CODES.has(code)) {
+    return { kind: "no_connection", text: `Could not connect to ${host} (${code})`, unsent: true, waitMs: null };
+  }
+  if (code && CLOSED_CODES.has(code)) {
+    return { kind: "closed", text: `The network closed the connection to TAMsense (${code})`, unsent: false, waitMs: null };
+  }
+  if (code && CERTIFICATE_CODE.test(code)) {
+    return { kind: "certificate", text: `The secure connection to ${host} failed (${code}). A proxy or antivirus may be in the way`, unsent: true, waitMs: null };
+  }
+  return { kind: "other", text: `Could not reach ${server}${code ? ` (${code})` : ""}. Check your internet connection`, unsent: false, waitMs: null };
+}
+function retryAfterMs(header, now) {
+  if (!header) {
+    return null;
+  }
+  const seconds = Number(header);
+  const at = Number.isFinite(seconds) ? now + seconds * 1e3 : Date.parse(header);
+  return Number.isFinite(at) ? Math.max(0, at - now) : null;
+}
+function busyFailure(response, now = Date.now()) {
+  return {
+    kind: "busy",
+    text: `TAMsense is busy (${response.status})`,
+    unsent: REFUSED_STATUSES.has(response.status),
+    waitMs: retryAfterMs(response.headers.get("retry-after"), now)
+  };
+}
+function backoffMs(failures, baseMs, capMs, random = Math.random) {
+  const ceiling = Math.min(capMs, baseMs * 2 ** Math.max(0, failures - 1));
+  return Math.round(ceiling / 2 + random() * ceiling / 2);
+}
+function durationText(ms) {
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) {
+    return `${seconds} s`;
+  }
+  const minutes = Math.round(seconds / 60);
+  return minutes < 60 ? `${minutes} min` : `${Math.floor(minutes / 60)} h ${minutes % 60} min`;
+}
+function connectionWatch(print2, now = Date.now) {
+  let lostAt = null;
+  let failures = 0;
+  let told = /* @__PURE__ */ new Set();
+  let reconnect = new AbortController();
+  return {
+    failed(failure) {
+      lostAt ??= now();
+      failures += 1;
+      if (!told.has(failure.kind)) {
+        told.add(failure.kind);
+        print2(`${failure.text}. Trying again.`);
+      }
+    },
+    reached() {
+      if (lostAt === null) {
+        return;
+      }
+      print2(`Connected to TAMsense again after ${durationText(now() - lostAt)}, ${failures} request(s) failed meanwhile.`);
+      lostAt = null;
+      failures = 0;
+      told = /* @__PURE__ */ new Set();
+      reconnect.abort();
+      reconnect = new AbortController();
+    },
+    nextReconnect: () => reconnect.signal
+  };
+}
 
 // src/api.ts
 var DEFAULT_SERVER = "https://my.tamsense.com";
+var REPEATABLE_TIMEOUT_MS = 3e4;
+var ACTION_TIMEOUT_MS = 2 * 6e4;
+var UPLOAD_TIMEOUT_MS = 15 * 6e4;
+var ATTEMPTS = 3;
+var RETRY_BASE_MS = 1e3;
+var RETRY_CAP_MS = 1e4;
+var REPEATABLE_METHODS = /* @__PURE__ */ new Set(["GET", "PUT", "DELETE"]);
+var ConnectionError = class extends Error {
+  kind;
+  reported;
+  constructor(failure, reported) {
+    super(failure.text);
+    this.name = "ConnectionError";
+    this.kind = failure.kind;
+    this.reported = reported;
+  }
+};
+function alreadyReported(error) {
+  return error instanceof ConnectionError && error.reported;
+}
 var ApiError = class extends Error {
   status;
   code;
@@ -33,32 +157,84 @@ function textOf(value) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 async function errorOf(response) {
-  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}`;
+  const reply4 = await response.json().catch(() => ({}));
+  const code = textOf(reply4.data?.code);
+  const message = textOf(reply4.message) ?? textOf(reply4.statusMessage) ?? `TAMsense answered with status ${response.status}`;
   return new ApiError(response.status, code, message);
 }
-function createApi(server, token = null, fetchImpl = fetch) {
-  async function send(method, path, headers, body) {
-    const all = { accept: "application/json", ...headers };
-    if (token) {
-      all.authorization = `Bearer ${token}`;
-    }
+function isFailure(outcome) {
+  return "kind" in outcome;
+}
+function createApi(server, token = null, options = {}) {
+  const { fetch: fetchImpl = fetch, watch, timeoutMs = REPEATABLE_TIMEOUT_MS, actionTimeoutMs = ACTION_TIMEOUT_MS, sleep: sleep2 = (ms) => wait(ms) } = options;
+  async function once(sending) {
+    const { method, path, headers, body } = sending;
     let response;
     try {
-      response = await fetchImpl(new URL(path, server), { method, headers: all, body, ...body instanceof ReadableStream ? { duplex: "half" } : {} });
+      response = await fetchImpl(new URL(path, server), { method, headers, body, signal: AbortSignal.timeout(sending.timeoutMs), ...body instanceof ReadableStream ? { duplex: "half" } : {} });
     } catch (error) {
-      throw new Error(`Could not reach ${server}. Check your internet connection.`, { cause: error });
+      return networkFailure(error, server, sending.timeoutMs);
+    }
+    if (BUSY_STATUSES.has(response.status)) {
+      await response.body?.cancel().catch(() => {
+      });
+      return busyFailure(response);
     }
+    watch?.reached();
     if (!response.ok) {
       throw await errorOf(response);
     }
-    return await response.json();
+    try {
+      return { reply: await response.json() };
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw error;
+      }
+      return networkFailure(error, server, sending.timeoutMs);
+    }
+  }
+  async function send(sending) {
+    const headers = { accept: "application/json", ...sending.headers };
+    if (token) {
+      headers.authorization = `Bearer ${token}`;
+    }
+    for (let attempt2 = 1; ; attempt2 += 1) {
+      const outcome = await once({ ...sending, headers });
+      if (!isFailure(outcome)) {
+        return outcome.reply;
+      }
+      if (attempt2 >= sending.attempts || !(outcome.unsent || sending.safeToRepeat)) {
+        watch?.failed(outcome);
+        throw new ConnectionError(outcome, Boolean(watch));
+      }
+      await sleep2(outcome.waitMs === null ? backoffMs(attempt2, RETRY_BASE_MS, RETRY_CAP_MS) : Math.min(outcome.waitMs, RETRY_CAP_MS));
+    }
   }
   return {
     server,
-    request: (method, path, body) => send(method, path, body ? { "content-type": "application/json" } : {}, body && JSON.stringify(body)),
-    upload: (method, path, body, contentType) => send(method, path, { "content-type": contentType }, body)
+    request: (method, path, body, requestOptions = {}) => {
+      const safeToRepeat = REPEATABLE_METHODS.has(method) || Boolean(requestOptions.safeToRepeat);
+      return send({
+        method,
+        path,
+        headers: body ? { "content-type": "application/json" } : {},
+        body: body && JSON.stringify(body),
+        attempts: ATTEMPTS,
+        timeoutMs: safeToRepeat ? timeoutMs : actionTimeoutMs,
+        safeToRepeat
+      });
+    },
+    // поток файла не перечитать, поэтому отправка файла не повторяется
+    upload: (method, path, body, contentType) => send({
+      method,
+      path,
+      headers: { "content-type": contentType },
+      body,
+      attempts: 1,
+      timeoutMs: UPLOAD_TIMEOUT_MS,
+      safeToRepeat: false
+    }),
+    ...watch ? { nextReconnect: watch.nextReconnect } : {}
   };
 }
 
@@ -80,7 +256,8 @@ var HELP_TEXT = `Connects this computer to TAMsense so it can work on your tasks
 
 Usage:
   ${LOGIN_COMMAND}    connect this computer
-  ${START_COMMAND}    take your tasks and work on them until you press Ctrl+C
+  ${START_COMMAND}    take your tasks and work on them until you press Ctrl+C;
+      run it from your code folder (or the folder above it) and it finds the code there
   ${BROWSER_COMMAND}  install the headless browser for interface checks now, or show it
   ${BROWSER_COMMAND} remove   delete that browser
   npx @tamsensedev/runner@latest status   show the connection
@@ -187,7 +364,7 @@ function findNpm(nodePath, env, exists) {
   }
   return null;
 }
-var runProcess = (command, args, options) => new Promise((resolve3, reject) => {
+var runProcess = (command, args, options) => new Promise((resolve5, 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 +378,7 @@ var runProcess = (command, args, options) => new Promise((resolve3, reject) => {
     });
   }
   child.on("error", reject);
-  child.on("close", (code) => resolve3({ code: code ?? 1, output: tail.join("\n") }));
+  child.on("close", (code) => resolve5({ code: code ?? 1, output: tail.join("\n") }));
 });
 function failureText(what, result) {
   if (OFFLINE_PATTERN.test(result.output)) {
@@ -314,8 +491,8 @@ async function probeCapabilities(stop) {
   stop?.throwIfAborted();
   let release = () => {
   };
-  const released = new Promise((resolve3) => {
-    release = resolve3;
+  const released = new Promise((resolve5) => {
+    release = resolve5;
   });
   const nothing = {
     [Symbol.asyncIterator]: () => ({
@@ -340,8 +517,8 @@ async function probeCapabilities(stop) {
 }
 
 // src/claude.ts
-import { createSdkMcpServer, query as query2, tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z4 } from "zod";
+import { createSdkMcpServer as createSdkMcpServer2, query as query3, tool as tool5 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z5 } from "zod";
 
 // src/askPerson.ts
 var MAX_ASK_TRIES = 5;
@@ -401,21 +578,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(tool5, input) {
+function activityLine(tool6, input) {
   const fields = typeof input === "object" && input !== null ? input : {};
-  if (tool5 === "Bash" && typeof fields.command === "string") {
+  if (tool6 === "Bash" && typeof fields.command === "string") {
     return `$ ${shorten(fields.command)}`;
   }
-  if (FILE_TOOLS.has(tool5) && typeof fields.file_path === "string") {
-    return `${tool5} ${shorten(fields.file_path)}`;
+  if (FILE_TOOLS.has(tool6) && typeof fields.file_path === "string") {
+    return `${tool6} ${shorten(fields.file_path)}`;
   }
-  if (tool5 === "Skill" && typeof fields.skill === "string") {
+  if (tool6 === "Skill" && typeof fields.skill === "string") {
     return `Skill ${shorten(fields.skill)}`;
   }
-  if (HELPER_TOOLS.has(tool5) && typeof fields.subagent_type === "string") {
+  if (HELPER_TOOLS.has(tool6) && typeof fields.subagent_type === "string") {
     return `Agent ${shorten(fields.subagent_type)}`;
   }
-  return tool5;
+  return tool6;
 }
 function usageOf(modelUsage) {
   const entries = Object.values(modelUsage);
@@ -450,6 +627,11 @@ 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";
+var FOUND_FOLDERS_PATH = "/api/runner/me/folders";
+var FOLDER_CHECKS_PATH = "/api/runner/folders/checks";
+function folderCheckPath(folderId) {
+  return `/api/runner/folders/${folderId}`;
+}
 function runPath(runId, action) {
   return `/api/runner/runs/${runId}/${action}`;
 }
@@ -465,6 +647,9 @@ function permissionPath(runId, permissionId) {
 function recordingUploadPath(runId, upload, part) {
   return `/api/runner/runs/${runId}/recordings/${upload}/${part}`;
 }
+function checkPath(checkId, action) {
+  return `/api/runner/checks/${checkId}/${action}`;
+}
 
 // src/feed.ts
 var MAX_TEXT_LENGTH = 8e3;
@@ -485,29 +670,29 @@ function textField(fields, name) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 function toolDraft(block, parent) {
-  const tool5 = (block.name ?? "tool").replace(MCP_PREFIX, "");
+  const tool6 = (block.name ?? "tool").replace(MCP_PREFIX, "");
   const fields = fieldsOf(block.input);
-  const base = { tool: tool5, ref: block.id ?? null, parent, failed: false };
-  if (tool5 === "Skill" && textField(fields, "skill")) {
+  const base = { tool: tool6, ref: block.id ?? null, parent, failed: false };
+  if (tool6 === "Skill" && textField(fields, "skill")) {
     return { ...base, kind: "skill", text: clip(textField(fields, "skill"), MAX_SUMMARY_LENGTH) };
   }
-  if (HELPER_TOOLS2.has(tool5)) {
+  if (HELPER_TOOLS2.has(tool6)) {
     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 (tool5 === "submit_verdict") {
+  if (tool6 === "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 (tool5 === "hand_off") {
+  if (tool6 === "hand_off") {
     return { ...base, kind: "tool", text: clip(`Hand off to ${textField(fields, "to") ?? "?"}: ${textField(fields, "note") ?? ""}`, 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) };
+  if (tool6 in ATTACH_LABELS) {
+    return { ...base, kind: "tool", text: clip(`${ATTACH_LABELS[tool6]}: ${textField(fields, "title") ?? textField(fields, "path") ?? ""}`, MAX_SUMMARY_LENGTH) };
   }
   const command = textField(fields, "command");
-  const summary = tool5 === "Bash" && command ? `$ ${command}` : activityLine(tool5, block.input);
+  const summary = tool6 === "Bash" && command ? `$ ${command}` : activityLine(tool6, block.input);
   return { ...base, kind: "tool", text: clip(summary, MAX_SUMMARY_LENGTH) };
 }
 function resultText(content) {
@@ -758,8 +943,8 @@ function inputChannel(options = {}) {
       }
       const next = queue.shift();
       if (!next) {
-        await new Promise((resolve3) => {
-          wake = resolve3;
+        await new Promise((resolve5) => {
+          wake = resolve5;
         });
         continue;
       }
@@ -819,9 +1004,9 @@ function inputChannel(options = {}) {
     onSwitch(apply) {
       applySwitch2 = apply;
       if (waitingSwitch) {
-        const { change, resolve: resolve3 } = waitingSwitch;
+        const { change, resolve: resolve5 } = waitingSwitch;
         waitingSwitch = null;
-        void apply(change).then(() => resolve3(true), () => resolve3(false));
+        void apply(change).then(() => resolve5(true), () => resolve5(false));
       }
     },
     onStopHelper(stop) {
@@ -882,8 +1067,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((resolve3) => {
-        waitingSwitch = { change: merged, resolve: resolve3 };
+      return new Promise((resolve5) => {
+        waitingSwitch = { change: merged, resolve: resolve5 };
       });
     }
   };
@@ -1046,8 +1231,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 reply3 = first;
-  while (reply3.decision === "wait") {
+  let reply4 = first;
+  while (reply4.decision === "wait") {
     await tools.sleep(CHECK_INTERVAL_MS, signal);
     if (signal.aborted) {
       return STOPPED_TEXT2;
@@ -1055,9 +1240,9 @@ async function decisionOf(tools, first, signal) {
     if (now() > giveUpAt) {
       return SITE_SILENT_TEXT;
     }
-    reply3 = await tools.check(reply3.id).catch(() => reply3);
+    reply4 = await tools.check(reply4.id).catch(() => reply4);
   }
-  return reply3;
+  return reply4;
 }
 function askPermission(tools, lastWords, folder) {
   return async (toolName, input, options) => {
@@ -1078,345 +1263,227 @@ 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 reply3 = await decisionOf(tools, first, options.signal);
-    if (typeof reply3 === "string") {
-      return deny(reply3);
+    const reply4 = await decisionOf(tools, first, options.signal);
+    if (typeof reply4 === "string") {
+      return deny(reply4);
     }
-    return reply3.decision === "allow" ? { behavior: "allow", updatedInput: input } : deny(reply3.message);
+    return reply4.decision === "allow" ? { behavior: "allow", updatedInput: input } : deny(reply4.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;
-  }
+// src/localWorkspace.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, resolve as resolve3 } from "path";
+
+// src/folders.ts
+import { existsSync as existsSync2, realpathSync, statSync } from "fs";
+import { readdir } from "fs/promises";
+import { basename, isAbsolute, join as join2, relative, resolve } from "path";
+import process3 from "process";
+
+// src/git.ts
+import { Buffer as Buffer2 } from "buffer";
+import { spawn as spawn2 } from "child_process";
+import process2 from "process";
+var GITHUB_ORIGIN = "https://github.com/";
+function githubAuthEnv(token) {
+  const credentials = Buffer2.from(`x-access-token:${token}`).toString("base64");
   return {
-    root,
-    save: (body) => api.request("POST", runPath(job.runId, "results"), body),
-    attach: (body) => api.request("POST", runPath(job.runId, "result-files"), body)
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: `http.${GITHUB_ORIGIN}.extraheader`,
+    GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${credentials}`,
+    GIT_TERMINAL_PROMPT: "0"
   };
 }
-function handOverTools(job, api) {
-  const boards = job.handOverBoards ?? [];
-  if (boards.length === 0 || job.stage.kind !== "code") {
-    return null;
+function personalGitEnv(env = process2.env) {
+  return { GIT_TERMINAL_PROMPT: "0", ...env.GIT_SSH_COMMAND ? {} : { GIT_SSH_COMMAND: "ssh -o BatchMode=yes" } };
+}
+function runGit(args, options) {
+  const env = { ...process2.env, ...options.env, ...options.token ? githubAuthEnv(options.token) : {} };
+  return new Promise((resolve5, reject) => {
+    const child = spawn2("git", args, { cwd: options.cwd, env, stdio: ["ignore", "pipe", "pipe"], ...options.timeoutMs ? { timeout: options.timeoutMs } : {} });
+    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) => resolve5({ 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 { boards, send: (body) => api.request("POST", runPath(job.runId, "hand-over"), body) };
+  return result.stdout;
 }
-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}`;
+
+// src/folders.ts
+var FIRST_REMOTE = "origin";
+var USUAL_BASES = ["main", "master"];
+var CHECKS_INTERVAL_MS = 5e3;
+var WEB_REMOTE = /^[a-z][\w+.-]*:\/\//i;
+var NETWORK_REMOTE = /^(?!file:)[a-z][\w+.-]*:\/\/|^[^/@]+@[^/:]+:/i;
+function problem(text2) {
+  return { ok: false, problem: text2 };
+}
+async function gitText(args, cwd) {
+  const result = await runGit(args, { cwd });
+  return result.code === 0 && result.stdout ? result.stdout : null;
+}
+function expandHome(path, home) {
+  const trimmed = path.trim();
+  return trimmed === "~" || trimmed.startsWith("~/") || trimmed.startsWith("~\\") ? join2(home, trimmed.slice(1)) : trimmed;
+}
+function remoteWithoutSecrets(url) {
+  if (!WEB_REMOTE.test(url)) {
+    return url;
+  }
+  try {
+    const parsed = new URL(url);
+    if (parsed.username || parsed.password) {
+      parsed.username = "";
+      parsed.password = "";
+    }
+    return parsed.toString().replace(/\/$/, "");
+  } catch {
+    return url;
   }
-  taken.add(name.toLowerCase());
-  return name;
 }
-function linksText(links) {
-  return links.map((link) => `- ${link.title}: ${link.url ?? ""}`).join("\n");
+function remoteRepository(remoteUrl) {
+  const parts = remoteUrl && NETWORK_REMOTE.test(remoteUrl) ? remoteUrl.replace(/\/+$/, "").replace(/\.git$/, "").split(/[/:]/).filter(Boolean) : [];
+  return parts.length >= 3 ? `${parts.at(-2)}/${parts.at(-1)}` : null;
 }
-async function writeResults(folder, job, api) {
-  const results = job.results ?? [];
-  await rm2(folder, { recursive: true, force: true });
-  if (results.length === 0) {
-    return [];
+function repositoryName(remoteUrl, folder) {
+  return remoteRepository(remoteUrl) ?? basename(folder);
+}
+async function remoteOf(folder) {
+  const remotes = (await gitText(["remote"], folder))?.split("\n").map((line) => line.trim()).filter(Boolean) ?? [];
+  return remotes.includes(FIRST_REMOTE) ? FIRST_REMOTE : remotes[0] ?? null;
+}
+async function hasRef(folder, ref) {
+  return (await runGit(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], { cwd: folder })).code === 0;
+}
+async function baseBranchOf(folder, remote, current) {
+  const remoteHead = remote ? await gitText(["symbolic-ref", "--quiet", "--short", `refs/remotes/${remote}/HEAD`], folder) : null;
+  if (remoteHead?.startsWith(`${remote}/`)) {
+    return remoteHead.slice(remote.length + 1);
   }
-  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 ?? "");
+  for (const name of USUAL_BASES) {
+    if (await hasRef(folder, `refs/heads/${name}`) || remote && await hasRef(folder, `refs/remotes/${remote}/${name}`)) {
+      return name;
     }
-    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)`);
+  return current;
+}
+function samePath(first, second) {
+  const [a, b] = [realpathSync.native(first), realpathSync.native(second)];
+  return process3.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function isInside(path, folder) {
+  const between = relative(resolve(folder), resolve(path));
+  return between === "" || !between.startsWith("..") && !isAbsolute(between);
+}
+async function inspectFolder(path, home) {
+  const folder = expandHome(path, home);
+  if (!isAbsolute(folder)) {
+    return problem("Enter the full path of the folder, for example /Users/anna/code/shop or C:\\code\\shop.");
   }
-  if (missing.length > 0) {
-    await writeFile2(join2(folder, "notes.md"), `These files could not be downloaded:
-${missing.map((line) => `- ${line}`).join("\n")}
-`);
+  if (!existsSync2(folder) || !statSync(folder).isDirectory()) {
+    return problem(`There is no folder ${folder} on this computer.`);
   }
-  return lines;
+  if (isInside(folder, join2(home, ".tamsense"))) {
+    return problem("This is a TAMsense work folder. Choose your own copy of the repository.");
+  }
+  const top = await gitText(["rev-parse", "--show-toplevel"], folder);
+  if (!top) {
+    return problem(`${folder} is not a git repository. Choose the folder of a cloned repository, or run git init there.`);
+  }
+  if (!samePath(top, folder)) {
+    return problem(`${folder} is inside the repository ${resolve(top)}. Add the top folder of the repository instead.`);
+  }
+  if (!await hasRef(folder, "HEAD")) {
+    return problem("The repository has no commits yet. Make the first commit, then check the folder again.");
+  }
+  const remote = await remoteOf(folder);
+  const remoteUrl = remote ? await gitText(["remote", "get-url", remote], folder) : null;
+  const currentBranch = await gitText(["symbolic-ref", "--quiet", "--short", "HEAD"], folder);
+  const defaultBranch = await baseBranchOf(folder, remote, currentBranch);
+  if (!defaultBranch) {
+    return problem("Could not tell the main branch of the repository. Check out the main branch in this folder, then check it again.");
+  }
+  const safeUrl = remoteUrl && remoteWithoutSecrets(remoteUrl);
+  return { ok: true, repository: repositoryName(safeUrl, folder), currentBranch, defaultBranch, remoteUrl: safeUrl };
 }
-async function prepareFolder(job, root, api) {
-  if (!job.keepWorkspace) {
-    await rm2(root, { recursive: true, force: true });
+function reportLine(path, report) {
+  return report.ok ? `Checked the folder ${path}: ${report.repository}, main branch ${report.defaultBranch}.` : `The folder ${path} cannot be used: ${report.problem}`;
+}
+async function checkFolders(tools, stop) {
+  let complained = false;
+  while (!stop.aborted) {
+    try {
+      const { checks } = await tools.api.request("POST", FOLDER_CHECKS_PATH, void 0, { safeToRepeat: true });
+      for (const check of checks) {
+        const report = await tools.inspect(check.path).catch((error) => problem(error instanceof Error ? error.message : String(error)));
+        await tools.api.request("POST", folderCheckPath(check.id), report);
+        tools.print(reportLine(check.path, report));
+      }
+      complained = false;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 404) {
+        return;
+      }
+      if (!complained && !stop.aborted && !alreadyReported(error)) {
+        tools.print(`Could not check the folders for TAMsense: ${error instanceof Error ? error.message : String(error)}`);
+        complained = true;
+      }
+    }
+    await tools.sleep(CHECKS_INTERVAL_MS, stop);
   }
-  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}.`;
+var SKIPPED_FOLDER = "node_modules";
+var MORE_CODE_TEXT = "To add more code, start the program from your code folder or the folder above it, or add a path in Board settings > Code.";
+async function childRepositories(start) {
+  const entries = await readdir(start, { withFileTypes: true }).catch(() => []);
+  return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== SKIPPED_FOLDER).map((entry) => join2(start, entry.name)).filter((folder) => existsSync2(join2(folder, ".git"))).sort();
+}
+async function findCodeFolders(start, home) {
+  const folder = resolve(start);
+  if (!existsSync2(folder)) {
+    return [];
   }
-  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 top = await gitText(["rev-parse", "--show-toplevel"], folder);
+  const candidates = top && samePath(top, folder) ? [folder] : await childRepositories(folder);
+  const found = [];
+  for (const candidate of candidates) {
+    const report = await inspectFolder(candidate, home);
+    if (report.ok) {
+      const { currentBranch, defaultBranch, remoteUrl } = report;
+      found.push({ path: candidate, name: basename(candidate), repository: remoteRepository(remoteUrl), currentBranch, defaultBranch, remoteUrl });
+    }
   }
-  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") };
+  return found;
 }
-function reply(text2, isError = false) {
-  return { content: [{ type: "text", text: text2 }], ...isError ? { isError: true } : {} };
+function foundCodeLines(start, found) {
+  const lines = found.length > 0 ? found.map((folder) => `Found code: ${folder.name} (${folder.path})`) : [`No code found in ${resolve(start)}.`];
+  return [...lines, MORE_CODE_TEXT];
 }
-async function sent(send) {
+async function reportFoundFolders(tools, start) {
   try {
-    return reply((await send()).text);
+    const found = await findCodeFolders(start, tools.home);
+    foundCodeLines(start, found).forEach((line) => tools.print(line));
+    await tools.api.request("PUT", FOUND_FOLDERS_PATH, { folders: found });
   } 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);
+    if (!(error instanceof ApiError && error.status === 404)) {
+      tools.print(`Could not tell TAMsense about the code on this computer: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
 }
-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);
-}
-function text(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-function texts(value) {
-  return Array.isArray(value) ? value.map(text).filter(Boolean) : [];
-}
-function records(value) {
-  return Array.isArray(value) ? value.filter(isRecord) : [];
-}
-function section(title, lines) {
-  return lines.length > 0 ? `${title}
-${lines.join("\n")}` : null;
-}
-function criterionLine(value) {
-  if (typeof value === "string") {
-    return value.trim() ? `- ${value.trim()}` : null;
-  }
-  if (!isRecord(value) || !text(value.text)) {
-    return null;
-  }
-  const kind = ["main", "edge", "keep"].includes(value.kind) ? `(${value.kind})` : "";
-  const head = [text(value.id), kind].filter(Boolean).join(" ");
-  return `- ${head ? `${head}: ` : ""}${text(value.text)}`;
-}
-function assumptionLine(value) {
-  if (typeof value === "string") {
-    return value.trim() ? `- ${value.trim()}` : null;
-  }
-  if (!isRecord(value) || !text(value.text)) {
-    return null;
-  }
-  return `- ${text(value.text)}${text(value.reason) ? ` (${text(value.reason)})` : ""}`;
-}
-function changeLines(change, index) {
-  const action = ["create", "modify", "delete"].includes(change.action) ? ` (${change.action})` : "";
-  const [produces, consumes, acceptance] = [texts(change.produces), texts(change.consumes), texts(change.acceptance)];
-  return [
-    `${index + 1}. ${text(change.repo) ? `${text(change.repo)} ` : ""}${text(change.file)}${action}: ${text(change.description)}`,
-    ...produces.length > 0 ? [`   Produces: ${produces.join("; ")}`] : [],
-    ...consumes.length > 0 ? [`   Consumes: ${consumes.join("; ")}`] : [],
-    ...acceptance.length > 0 ? [`   Makes true: ${acceptance.join(", ")}`] : []
-  ];
-}
-var CODE_USE_TEXT = { reuse: "reuse", change: "change", keep: "do not touch" };
-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));
-  const riskLevel = RISK_LEVELS.includes(spec.riskLevel) ? spec.riskLevel : null;
-  return [
-    text(spec.goal) && `Goal: ${text(spec.goal)}`,
-    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:", 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) : [])),
-    section("Test plan:", [
-      ...records(plan.automated).filter((item) => text(item.command)).map((item) => `- Run in ${text(item.repo) || "the repository"}: ${text(item.command)}${text(item.expect) ? `. Passing: ${text(item.expect)}` : ""}`),
-      ...records(plan.newTests).filter((item) => text(item.seam)).map((item) => `- New test at ${text(item.seam)}${texts(item.covers).length > 0 ? `, covers ${texts(item.covers).join(", ")}` : ""}`),
-      ...records(plan.manual).filter((item) => text(item.steps)).map((item) => `- By hand${text(item.page) ? ` on ${text(item.page)}` : ""}: ${text(item.steps)}`)
-    ]),
-    risks.length > 0 ? section(`Risks${riskLevel ? ` (risk level ${riskLevel})` : ""}:`, risks.map((item) => `- ${text(item.risk)}${text(item.mitigation) ? `. Mitigation: ${text(item.mitigation)}` : ""}`)) : riskLevel && `Risk level: ${riskLevel}`,
-    section("Assumptions:", present(Array.isArray(spec.assumptions) ? spec.assumptions.map(assumptionLine) : [])),
-    section("Open questions (not answered yet):", records(spec.openQuestions).filter((item) => text(item.question)).map((item) => `- ${text(item.question)}`))
-  ].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() {
@@ -1426,8 +1493,8 @@ function keyedLock() {
       const previous = tails.get(key) ?? Promise.resolve();
       let release = () => {
       };
-      const done2 = new Promise((resolve3) => {
-        release = resolve3;
+      const done2 = new Promise((resolve5) => {
+        release = resolve5;
       });
       const tail = previous.then(() => done2);
       tails.set(key, tail);
@@ -1445,6 +1512,9 @@ function keyedLock() {
 }
 
 // src/workspace.ts
+import { existsSync as existsSync3 } from "fs";
+import { rm as rm2 } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
 var FALLBACK_IDENTITY = { name: "TAMsense", email: "noreply@tamsense.com" };
 var cacheLock = keyedLock();
 function githubRemoteUrl(fullName) {
@@ -1461,122 +1531,756 @@ function folderNames(repositories) {
   }
   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 refreshCache(cache, repository, token, tools) {
+  if (existsSync3(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 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) => 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 || !existsSync3(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/localWorkspace.ts
+var NETWORK_TIMEOUT_MS = 12e4;
+var sourceLock = keyedLock();
+function isLocalJob(job) {
+  return job.workspace === "local";
+}
+function localBranchLine(branch) {
+  const local = branch.local;
+  if (!local) {
+    return `Pushed ${branch.branch} in ${branch.repository}.`;
+  }
+  const where = `Branch ${branch.branch} has ${local.commits} commit(s) in ${local.folder}`;
+  if (local.pushProblem) {
+    return `${where}. It was not pushed: ${local.pushProblem}`;
+  }
+  return local.remoteUrl ? `${where}, pushed to ${local.remoteUrl}.` : `${where}.`;
+}
+function readsOnly(job) {
+  return isReadOnlyCheck(job) || job.stage.kind === "interview" || job.stage.kind === "spec";
+}
+async function isAncestor(folder, older, newer) {
+  return (await runGit(["merge-base", "--is-ancestor", older, newer], { cwd: folder })).code === 0;
+}
+async function fetchRemote(source, remote, print2) {
+  const fetched = await runGit(["fetch", "--prune", remote], { cwd: source, env: personalGitEnv(), timeoutMs: NETWORK_TIMEOUT_MS });
+  if (fetched.code !== 0) {
+    print2(`Could not fetch from ${remote} in ${source}, going on with what the folder has: ${fetched.stderr || `exit code ${fetched.code}`}`);
+  }
+}
+async function baseBranchRef(source, branch, remote) {
+  const own = await hasRef(source, `refs/heads/${branch}`) ? branch : null;
+  const fetched = remote && await hasRef(source, `refs/remotes/${remote}/${branch}`) ? `${remote}/${branch}` : null;
+  if (own && fetched) {
+    return await isAncestor(source, own, fetched) ? fetched : own;
+  }
+  const found = own ?? fetched;
+  if (!found) {
+    throw new Error(`The main branch ${branch} is not in ${source}. Check the folder again in the board settings, on the Code tab.`);
+  }
+  return found;
+}
+async function taskBranchRef(source, branch, remote, base) {
+  if (await hasRef(source, `refs/heads/${branch}`) && Number(await git(["rev-list", "--count", `${base}..${branch}`], { cwd: source })) > 0) {
+    return branch;
+  }
+  return remote && await hasRef(source, `refs/remotes/${remote}/${branch}`) ? `${remote}/${branch}` : null;
+}
+async function startRef(source, job, local) {
+  const base = await baseBranchRef(source, local.baseBranch, local.remote);
+  const task = await taskBranchRef(source, job.branch, local.remote, base);
+  if (task || !isReadOnlyCheck(job)) {
+    return task ?? base;
+  }
+  const where = local.remote ? `${source} or on its remote ${local.remote}` : source;
+  throw new Error(`Branch ${job.branch} is not in ${where}. It was made on another computer: push it to a remote this folder can fetch, or run this check on that computer.`);
+}
+async function releaseBranch2(source, branch, keep, home) {
+  const listed = await runGit(["worktree", "list", "--porcelain"], { cwd: source });
+  const work2 = tamsenseFolder(home, "work");
+  for (const holder of branchHolders(listed.stdout, branch).filter((path) => resolve3(path) !== resolve3(keep))) {
+    if (!isInside(holder, work2)) {
+      throw new Error(`Branch ${branch} is checked out in ${resolve3(holder)}. Switch that folder to another branch, then start the step again.`);
+    }
+    await removeWorktree(source, holder);
+  }
+}
+async function keptBase2(path, job) {
+  if (!job.keepWorkspace || !existsSync4(join4(path, ".git"))) {
+    return null;
+  }
+  const branch = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: path });
+  if (branch.code !== 0 || branch.stdout !== (readsOnly(job) ? "HEAD" : job.branch)) {
+    return null;
+  }
+  return git(["rev-parse", "HEAD"], { cwd: path });
+}
+function sourceOf(repository) {
+  if (!repository.folder) {
+    throw new Error(`TAMsense did not say which folder holds ${repository.fullName} on this computer.`);
+  }
+  return repository.folder;
+}
+async function prepareRepository(job, repository, path, tools) {
+  const source = sourceOf(repository);
+  if ((await runGit(["rev-parse", "--show-toplevel"], { cwd: source }).catch(() => null))?.code !== 0) {
+    throw new Error(`${source} is no longer a git repository on this computer. Check the folder again in the board settings, on the Code tab.`);
+  }
+  const local = { source, remote: await remoteOf(source), baseBranch: repository.defaultBranch };
+  if (local.remote) {
+    await fetchRemote(source, local.remote, tools.print);
+  }
+  const kept = await keptBase2(path, job);
+  if (kept) {
+    return { baseSha: kept, local };
+  }
+  await runGit(["worktree", "prune"], { cwd: source });
+  if (existsSync4(path)) {
+    await removeWorktree(source, path);
+  }
+  const start = await startRef(source, job, local);
+  if (readsOnly(job)) {
+    await git(["worktree", "add", "--detach", path, start], { cwd: source });
+  } else {
+    await releaseBranch2(source, job.branch, path, tools.home);
+    await git(["worktree", "add", "-B", job.branch, path, start], { cwd: source });
+  }
+  return { baseSha: await git(["rev-parse", "HEAD"], { cwd: path }), local };
+}
+async function prepareLocalWorkspace(job, tools) {
+  const root = taskFolder(tools.home, job);
+  const folders = folderNames(job.repositories);
+  const repositories = [];
+  for (const [index, repository] of job.repositories.entries()) {
+    const folder = folders[index] ?? repository.fullName;
+    const path = join4(root, folder);
+    const prepared = await sourceLock.run(resolve3(sourceOf(repository)), () => prepareRepository(job, repository, path, tools));
+    repositories.push({ fullName: repository.fullName, folder, path, baseSha: prepared.baseSha, local: prepared.local });
+  }
+  return { root, repositories };
+}
+async function pushBranch(path, local, branch) {
+  if (!local.remote) {
+    return { remoteUrl: null, pushProblem: null };
+  }
+  if (branch === local.baseBranch) {
+    return { remoteUrl: null, pushProblem: `TAMsense never pushes the main branch ${branch}.` };
+  }
+  const pushed = await runGit(["push", local.remote, `HEAD:refs/heads/${branch}`], { cwd: path, env: personalGitEnv(), timeoutMs: NETWORK_TIMEOUT_MS });
+  if (pushed.code !== 0) {
+    return { remoteUrl: null, pushProblem: pushed.stderr || `exit code ${pushed.code}` };
+  }
+  return { remoteUrl: await git(["remote", "get-url", local.remote], { cwd: path }), pushProblem: null };
+}
+async function commitAndPush(repository, local, job, identity) {
+  const options = { cwd: repository.path, env: identity };
+  await git(["add", "--all"], options);
+  if ((await runGit(["diff", "--cached", "--quiet"], options)).code === 1) {
+    await git(["commit", "--message", `Task #${job.taskId}: ${job.title}`], options);
+  }
+  if (Number(await git(["rev-list", "--count", `${repository.baseSha}..HEAD`], options)) === 0) {
+    return null;
+  }
+  const base = await baseBranchRef(repository.path, local.baseBranch, local.remote);
+  const commits = Number(await git(["rev-list", "--count", `${base}..HEAD`], options));
+  const sent2 = await pushBranch(repository.path, local, job.branch);
+  return { sha: await git(["rev-parse", "HEAD"], options), commits, ...sent2 };
+}
+async function publishLocalWorkspace(workspace, job, identity) {
+  const pushed = [];
+  for (const repository of workspace.repositories) {
+    const local = repository.local;
+    if (!local) {
+      continue;
+    }
+    const branch = await sourceLock.run(resolve3(local.source), async () => {
+      const published = await commitAndPush(repository, local, job, identity);
+      await runGit(["checkout", "--quiet", "--detach"], { cwd: repository.path });
+      return published;
+    });
+    if (branch) {
+      pushed.push({
+        repository: repository.fullName,
+        branch: job.branch,
+        sha: branch.sha,
+        local: { folder: local.source, baseBranch: local.baseBranch, commits: branch.commits, remoteUrl: branch.remoteUrl && remoteWithoutSecrets(branch.remoteUrl), pushProblem: branch.pushProblem }
+      });
+    }
+  }
+  return pushed;
+}
+
+// src/results.ts
+import { mkdir as mkdir2, readFile as readFile2, rm as rm3, stat, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename2, extname, isAbsolute as isAbsolute2, join as join5, resolve as resolve4 } 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 rm3(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(join5(folder, name), Buffer.from(file.data, "base64"));
+      } catch (error) {
+        missing.push(`${result.title}: ${error instanceof Error ? error.message : String(error)}`);
+        continue;
+      }
+    } else {
+      await writeFile2(join5(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(join5(folder, "links.md"), `${linksText(links)}
+`);
+    lines.push(`${RESULTS_FOLDER}/links.md: ${links.length} link(s)`);
+  }
+  if (missing.length > 0) {
+    await writeFile2(join5(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 rm3(root, { recursive: true, force: true });
+  }
+  await mkdir2(root, { recursive: true });
+  return { root, repositories: [], results: await writeResults(join5(root, RESULTS_FOLDER), job, api) };
+}
+async function readResultFile(root, path, title) {
+  const full = isAbsolute2(path) ? path : resolve4(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 = basename2(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/schedules.ts
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir3 } from "fs/promises";
+import { createSdkMcpServer, query as query2, tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z3 } from "zod";
+var PROPOSE_SCHEDULE_TOOL_NAME = "propose_schedule";
+var REPORT_CHECK_TOOL_NAME = "report_check";
+var SCHEDULE_RULE = `Some waits are long: a local stand or a database copy that takes half an hour to come up, a slow build or import, a service that answers only after a while, logs that show a problem only over hours. Do not sleep or poll in a loop for that. Propose a schedule with the ${PROPOSE_SCHEDULE_TOOL_NAME} tool: a short check repeated on a timer by a cheap model that reads the notes of earlier runs and reports one line in the task chat. Give it a clear condition that ends it, the longest interval that still helps, and when to call a person. With wait true this run ends its turn and continues here when the schedule ends. Never use a schedule for work you can finish now, for a check you can do once, or to watch something "just in case". Without autopilot a person starts it first; on autopilot it starts at once within the project limits.`;
+var ALREADY_WAITING_TEXT2 = "This run already waits for something. End your turn now: the conversation continues when it comes.";
+function reply2(text2, isError = false) {
+  return { content: [{ type: "text", text: text2 }], ...isError ? { isError: true } : {} };
+}
+function proposeScheduleTool(tools, waiting) {
+  return tool3(
+    PROPOSE_SCHEDULE_TOOL_NAME,
+    "Repeat a short check on a timer while the task waits for something slow. Each run is a short cheap run that reads the notes of earlier runs and reports one line in the task chat; it ends when its condition comes, its time runs out or it made its runs.",
+    {
+      title: z3.string().describe('a short name, at most 80 characters: "Wait for the local stand"'),
+      instruction: z3.string().describe("what each run does, in plain words, as a note to yourself: what to look at and what counts as new"),
+      everyMinutes: z3.number().int().nullable().describe("repeat every N minutes (60 for every hour); null when dailyAt is set"),
+      dailyAt: z3.string().nullable().describe("repeat every day at this time, HH:MM in the project time zone; null when everyMinutes is set"),
+      days: z3.array(z3.number().int().min(0).max(6)).describe("with dailyAt: days of the week, 0 is Sunday; empty means every day"),
+      until: z3.string().describe('the condition each run checks, for example "the stand answers on localhost:3100"; when it comes, the schedule ends. Empty when it simply runs for its time'),
+      forMinutes: z3.number().int().nullable().describe("how long it runs at most, in minutes; null takes the longest the project allows"),
+      maxRuns: z3.number().int().nullable().describe("the number of runs at most, or null"),
+      where: z3.enum(["computer", "cloud"]).describe("computer: this computer, free, skipped while it sleeps; cloud: any time, for credits"),
+      callWhen: z3.string().describe('when to call a person, in plain words: "a container keeps restarting"'),
+      callOnTimeout: z3.boolean().describe("true: call a person when the condition did not come in time"),
+      keepAfterStep: z3.boolean().describe("true only when it must keep running after the task leaves this step"),
+      wait: z3.boolean().describe("true: this run ends its turn now and continues here when the schedule ends")
+    },
+    async (args) => {
+      if (args.wait && (waiting.waitingFor !== null || waiting.waitingForSchedule !== null)) {
+        return reply2(ALREADY_WAITING_TEXT2, true);
+      }
+      let answer;
+      try {
+        answer = await tools.send({ ...args, title: args.title.trim(), instruction: args.instruction.trim(), until: args.until.trim(), callWhen: args.callWhen.trim(), model: null });
+      } catch (error) {
+        return reply2(`Could not send the schedule: ${error instanceof Error ? error.message : String(error)}. Wait another way or say so in your report.`, true);
+      }
+      if (answer.id === null) {
+        return reply2(answer.text, true);
+      }
+      if (answer.waits) {
+        waiting.waitingForSchedule = answer.id;
+      }
+      return reply2(answer.text);
+    }
+  );
+}
+function scheduleTools(api, path) {
+  return { send: (body) => api.request("POST", path, body) };
+}
+async function checkFolder(home, job) {
+  if (job.taskId !== null) {
+    const step = taskFolder(home, { taskId: job.taskId, stage: { columnId: job.stepColumnId } });
+    if (existsSync5(step)) {
+      return step;
+    }
+  }
+  const own = tamsenseFolder(home, "schedules", `schedule-${job.scheduleId}`);
+  await mkdir3(own, { recursive: true });
+  return own;
+}
+var CHECK_RULES = [
+  "You run one check of a TAMsense schedule on the user's own computer: a short check repeated on a timer while a task waits for something. Nobody answers during the run.",
+  "You only look. Never change, fix, restart, stop or delete anything, never commit, and never send anything to people. Reading commands are fine: listing containers, requesting a local address, reading logs, git log.",
+  "This is the person's own computer. Never touch programs you did not start, and stop the processes you started yourself by their process id before you finish.",
+  "Keep it short: a few commands at most. If you cannot check something, say so in the summary instead of guessing.",
+  `Finish by calling ${REPORT_CHECK_TOOL_NAME} exactly once: summary is one short line for the task chat with the numbers that matter; changed is true only when something differs from the last note; note is the full facts only when something changed; conditionMet is true when the condition of the schedule came; callPerson is true when the schedule says to call a person for what you saw.`,
+  "Write in the language of the task. No em dashes and no en dashes."
+];
+function noteLine(note) {
+  const head = `- ${note.at.slice(0, 16).replace("T", " ")} (${note.outcome}): ${note.summary}`;
+  return note.note ? `${head}
+  ${note.note.replace(/\n/g, "\n  ")}` : head;
+}
+function buildCheckPrompt(job, folder) {
+  const prompt = [
+    `Schedule "${job.title}", run ${job.runNumber}${job.taskId === null ? "" : `, on TAMsense task #${job.taskId}: ${job.taskTitle}`}`,
+    `What to check on each run:
+${job.instruction}`,
+    job.until ? `The schedule ends when: ${job.until}` : "The schedule runs for its time; there is no condition to wait for.",
+    job.callWhen ? `Call a person when: ${job.callWhen}` : "Call a person only when something is clearly wrong.",
+    job.earlier.length > 0 ? `Notes of the earlier runs, the newest last:
+${job.earlier.map(noteLine).join("\n")}` : "This is the first run: there are no earlier notes."
+  ].join("\n\n");
+  const instructions = [
+    CHECK_RULES.join("\n"),
+    workplaceText(job.computer, folder),
+    job.safetyRules.trim() || null
+  ].filter(Boolean).join("\n\n");
+  return { prompt, instructions };
+}
+var SERVER_NAME = "tamsense";
+var MAX_CHECK_TURNS = 30;
+function reportCheckTool(onReport) {
+  return tool3(
+    REPORT_CHECK_TOOL_NAME,
+    "Hand in the result of this check. Call it exactly once, at the very end.",
+    {
+      changed: z3.boolean().describe("true when something changed since the earlier runs"),
+      summary: z3.string().describe("one short line for the task chat: what you saw"),
+      note: z3.string().nullable().describe("when something changed: the full facts, the exact lines and what they mean; null otherwise"),
+      conditionMet: z3.boolean().describe("true when the condition of the schedule came"),
+      callPerson: z3.boolean().describe("true when a person must look now, as the schedule says")
+    },
+    async (args) => {
+      onReport({ changed: args.changed, summary: args.summary.trim(), note: args.note?.trim() || null, conditionMet: args.conditionMet, callPerson: args.callPerson });
+      return reply2("Result received. You can stop now.");
+    }
+  );
+}
+function claudeCheckRunner(startQuery) {
+  return async (request) => {
+    request.signal.throwIfAborted();
+    const abortController = new AbortController();
+    request.signal.addEventListener("abort", () => abortController.abort(), { once: true });
+    let result = null;
+    const report = reportCheckTool((found) => {
+      result = found;
+    });
+    const messages = startQuery({
+      prompt: request.prompt.prompt,
+      options: {
+        cwd: request.cwd,
+        systemPrompt: { type: "preset", preset: "claude_code", append: request.prompt.instructions },
+        settingSources: ["user", "project", "local"],
+        permissionMode: "auto",
+        canUseTool: denyWhenAsked,
+        mcpServers: { [SERVER_NAME]: createSdkMcpServer({ name: SERVER_NAME, version: "1.0.0", tools: [report] }) },
+        allowedTools: [`mcp__${SERVER_NAME}__${REPORT_CHECK_TOOL_NAME}`],
+        maxTurns: MAX_CHECK_TURNS,
+        abortController,
+        env: request.env,
+        ...request.model === null ? {} : { model: request.model }
+      }
+    });
+    let outcome = { completed: false, report: "Claude finished without a result.", model: null, usage: null, result: null };
+    for await (const message of messages) {
+      if (message.type === "result") {
+        const finished = outcomeOf(message, "");
+        outcome = { completed: finished.completed, report: finished.report, model: finished.model, usage: finished.usage, result: null };
+      }
+    }
+    return { ...outcome, result };
+  };
+}
+function checkHeartbeat(api, job, abort) {
+  return async () => {
+    try {
+      const answer = await api.request("POST", checkPath(job.checkId, "heartbeat"), void 0, { safeToRepeat: true });
+      if (!answer.keepGoing) {
+        abort();
+      }
+    } catch {
+    }
+  };
+}
+function checkFinishBody(outcome) {
+  return { outcome: outcome.completed && outcome.result ? "succeeded" : "failed", report: outcome.report, model: outcome.model, usage: outcome.usage, result: outcome.result };
 }
-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 checkLine(body) {
+  if (!body.result) {
+    return `Check failed: ${body.report}`;
+  }
+  if (body.result.conditionMet) {
+    return `Check: ${body.result.summary}. The condition came, the schedule ends.`;
+  }
+  return `Check: ${body.result.summary}`;
 }
-function stepFolder(job) {
-  const task = `task-${job.taskId}`;
-  return typeof job.stage.columnId === "number" ? [task, `step-${job.stage.columnId}`] : [task];
+var runClaudeCheck = claudeCheckRunner(query2);
+
+// src/specText.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isReadOnlyCheck(job) {
-  return job.stage.kind === "review" || job.stage.kind === "test";
+function text(value) {
+  return typeof value === "string" ? value.trim() : "";
 }
-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;
+function texts(value) {
+  return Array.isArray(value) ? value.map(text).filter(Boolean) : [];
 }
-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);
-  }
+function records(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
 }
-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}`;
+function section(title, lines) {
+  return lines.length > 0 ? `${title}
+${lines.join("\n")}` : null;
 }
-async function keptBase(cache, path, job, repository) {
-  if (!job.keepWorkspace || !existsSync2(join3(path, ".git"))) {
+function criterionLine(value) {
+  if (typeof value === "string") {
+    return value.trim() ? `- ${value.trim()}` : null;
+  }
+  if (!isRecord(value) || !text(value.text)) {
     return null;
   }
-  const branch = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: path });
-  if (branch.code !== 0 || branch.stdout !== (isReadOnlyCheck(job) ? "HEAD" : job.branch)) {
+  const kind = ["main", "edge", "keep"].includes(value.kind) ? `(${value.kind})` : "";
+  const head = [text(value.id), kind].filter(Boolean).join(" ");
+  return `- ${head ? `${head}: ` : ""}${text(value.text)}`;
+}
+function assumptionLine(value) {
+  if (typeof value === "string") {
+    return value.trim() ? `- ${value.trim()}` : null;
+  }
+  if (!isRecord(value) || !text(value.text)) {
     return null;
   }
-  return git(["rev-parse", await baseRef(cache, job, repository)], { cwd: cache });
+  return `- ${text(value.text)}${text(value.reason) ? ` (${text(value.reason)})` : ""}`;
 }
-function taskFolder(home, job) {
-  return tamsenseFolder(home, "work", ...stepFolder(job));
+function changeLines(change, index) {
+  const action = ["create", "modify", "delete"].includes(change.action) ? ` (${change.action})` : "";
+  const [produces, consumes, acceptance] = [texts(change.produces), texts(change.consumes), texts(change.acceptance)];
+  return [
+    `${index + 1}. ${text(change.repo) ? `${text(change.repo)} ` : ""}${text(change.file)}${action}: ${text(change.description)}`,
+    ...produces.length > 0 ? [`   Produces: ${produces.join("; ")}`] : [],
+    ...consumes.length > 0 ? [`   Consumes: ${consumes.join("; ")}`] : [],
+    ...acceptance.length > 0 ? [`   Makes true: ${acceptance.join(", ")}`] : []
+  ];
 }
-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 };
+var CODE_USE_TEXT = { reuse: "reuse", change: "change", keep: "do not touch" };
+var RISK_LEVELS = ["low", "medium", "high"];
+function present(lines) {
+  return lines.filter((line) => line !== null);
 }
-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
-  };
+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"})`);
 }
-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 });
-    }
+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;
   }
-  return pushed;
+  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));
+  const riskLevel = RISK_LEVELS.includes(spec.riskLevel) ? spec.riskLevel : null;
+  return [
+    text(spec.goal) && `Goal: ${text(spec.goal)}`,
+    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:", 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) : [])),
+    section("Test plan:", [
+      ...records(plan.automated).filter((item) => text(item.command)).map((item) => `- Run in ${text(item.repo) || "the repository"}: ${text(item.command)}${text(item.expect) ? `. Passing: ${text(item.expect)}` : ""}`),
+      ...records(plan.newTests).filter((item) => text(item.seam)).map((item) => `- New test at ${text(item.seam)}${texts(item.covers).length > 0 ? `, covers ${texts(item.covers).join(", ")}` : ""}`),
+      ...records(plan.manual).filter((item) => text(item.steps)).map((item) => `- By hand${text(item.page) ? ` on ${text(item.page)}` : ""}: ${text(item.steps)}`)
+    ]),
+    risks.length > 0 ? section(`Risks${riskLevel ? ` (risk level ${riskLevel})` : ""}:`, risks.map((item) => `- ${text(item.risk)}${text(item.mitigation) ? `. Mitigation: ${text(item.mitigation)}` : ""}`)) : riskLevel && `Risk level: ${riskLevel}`,
+    section("Assumptions:", present(Array.isArray(spec.assumptions) ? spec.assumptions.map(assumptionLine) : [])),
+    section("Open questions (not answered yet):", records(spec.openQuestions).filter((item) => text(item.question)).map((item) => `- ${text(item.question)}`))
+  ].filter(Boolean).join("\n\n");
 }
 
 // src/prompt.ts
@@ -1599,6 +2303,8 @@ var CODE_RULES = [
   "Check your work with the project's own tools: run the tests, type checks and linters that exist, and fix what you broke.",
   "Commit your work in every repository you changed, on the current branch. Do not push, do not switch or create branches, and do not rewrite history: TAMsense pushes the branch and opens the pull request."
 ];
+var LOCAL_COMMIT_RULE = "Commit your work in every repository you changed, on the current branch. Do not push, do not switch or create branches, and do not rewrite history: TAMsense pushes the branch when the folder has a remote, and the person merges it.";
+var LOCAL_FOLDERS_RULE = "Each repository here is a git worktree of the person's own folder on this computer. Work only here: never open, change or check out branches in the person's original folder.";
 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 = [
@@ -1606,7 +2312,7 @@ var READ_ONLY_CODE_RULES = [
   "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 = [
+var CHECK_RULES2 = [
   "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.",
   "Judge against the task, the spec and its acceptance criteria, checking each criterion by its id (AC-1 and so on) when the spec has ids. Be specific: every problem gets a file, a line and what to do about it.",
@@ -1614,7 +2320,7 @@ var CHECK_RULES = [
 ];
 var SCREENSHOT_RULE = `If you render screens (screenshots of the interface), attach the ones that show the result with the ${SCREENSHOT_TOOL_NAME} tool. People see them on the task without opening the code.`;
 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 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, { notes }), where notes say in your own words what you tested in that browser and what happened: what you opened, what you clicked or typed, what you expected, and whether it passed or failed (at most 600 characters). People watching the replay read them first. 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.";
@@ -1708,13 +2414,17 @@ function bulletList(lines) {
   return lines.map((line) => `- ${line}`).join("\n");
 }
 function repositoryLines(job, workspace) {
-  const sourceOf = new Map(job.repositories.map((repository) => [repository.fullName, repository]));
+  const sourceOf2 = new Map(job.repositories.map((repository) => [repository.fullName, repository]));
   return workspace.repositories.map((repository) => {
-    const source = sourceOf.get(repository.fullName);
+    const source = sourceOf2.get(repository.fullName);
     const pull = source?.pullRequestUrl ? `, pull request ${source.pullRequestUrl}` : "";
-    return `${repository.folder} (${repository.fullName}) at commit ${repository.baseSha.slice(0, 7)}, base branch origin/${source?.defaultBranch ?? "main"}${pull}`;
+    const base = repository.local ? repository.local.baseBranch : `origin/${source?.defaultBranch ?? "main"}`;
+    return `${repository.folder} (${repository.fullName}) at commit ${repository.baseSha.slice(0, 7)}, base branch ${base}${pull}`;
   });
 }
+function codeRules(job) {
+  return isLocalJob(job) ? [...CODE_RULES.slice(0, -1), LOCAL_COMMIT_RULE] : CODE_RULES;
+}
 function stepLine(stage) {
   return `This step of the board is "${stage.name}"${stage.helper ? `, and you work as the ${stage.helper}` : ""}.`;
 }
@@ -1873,6 +2583,7 @@ ${JSON.stringify(job.spec)}` : null,
     contextText(job.projectContext),
     `The repositories for this task are checked out in the current folder, one subfolder each:
 ${bulletList(repositoryLines(job, workspace))}`,
+    isLocalJob(job) && LOCAL_FOLDERS_RULE,
     READ_ONLY_RULE,
     `How to work:
 ${bulletList(work2.round === null ? SPEC_RULES : questionRules(work2))}`,
@@ -1899,6 +2610,7 @@ function buildFolderPrompt(job, workspace, options) {
     job.handoffNote && `Note from the previous step: ${job.handoffNote}`,
     job.review && `Notes to address:
 ${job.review}`,
+    job.scheduleNote,
     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];
@@ -1918,6 +2630,7 @@ ${bulletList(rules)}`,
     peopleText(people),
     isCheck ? null : handOverText(job.handOverBoards),
     handoffText(job.allowedHandoffs, isCheck),
+    job.canSchedule && SCHEDULE_RULE,
     options.browser && BROWSER_RULE
   ].filter(Boolean).join("\n\n");
   return { prompt, instructions };
@@ -1944,11 +2657,12 @@ function buildTaskPrompt(job, workspace, options = {}) {
     job.handoffNote && `Note from the previous step: ${job.handoffNote}`,
     job.review && `Review comments to address:
 ${job.review}`,
+    job.scheduleNote,
     teamMessagesText(job.messages)
   ].filter(Boolean).join("\n\n");
   const evidence = [SCREENSHOT_RULE, ...options.recorder ? [RECORDING_RULE] : [], NAMING_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 rules = isCheck ? [...CHECK_RULES2, DEPENDENCIES_RULE, localApp, ...evidence] : readOnly ? [...READ_ONLY_CODE_RULES, DEPENDENCIES_RULE, localApp, ...evidence, READ_ONLY_REPORT_RULE] : [...codeRules(job), ...job.review ? [REWORK_RULE] : [], DEPENDENCIES_RULE, localApp, ...evidence, CODE_REPORT_RULE];
   const instructions = [
     canAsk ? ASKING_RULE : UNATTENDED_RULE,
     MACHINE_RULE,
@@ -1958,6 +2672,7 @@ ${job.review}`,
     contextText(job.projectContext),
     `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))}`,
+    isLocalJob(job) && LOCAL_FOLDERS_RULE,
     `How to work:
 ${bulletList(rules)}`,
     safetyText(job),
@@ -1965,141 +2680,142 @@ ${bulletList(rules)}`,
     APPROVAL_RULE,
     peopleText(people),
     handoffText(job.allowedHandoffs, isCheck),
+    job.canSchedule && SCHEDULE_RULE,
     options.browser && BROWSER_RULE
   ].filter(Boolean).join("\n\n");
   return { prompt, instructions };
 }
 
 // src/specTools.ts
-import { tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z3 } from "zod";
+import { tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z4 } from "zod";
 var MAX_FIRST_ROUND = 4;
-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")
+var questionSchema = z4.object({
+  id: z4.string().describe('Stable snake_case id, unique in the task, for example "empty_state"'),
+  question: z4.string().describe("One plain sentence the owner can answer without reading code"),
+  whyItMatters: z4.string().describe("One line: what changes in the result depending on the answer"),
+  options: z4.array(z4.object({
+    label: z4.string().describe('Short, concrete answer (1-6 words), without "(Recommended)": use the recommended flag'),
+    description: z4.string().describe("One sentence: what happens if this option is chosen"),
+    recommended: z4.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: z3.boolean().describe("true only when the options are additive and several can apply together")
+  multiSelect: z4.boolean().describe("true only when the options are additive and several can apply together")
 });
-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")
+var briefSchema = z4.object({
+  findings: z4.array(z4.object({
+    fact: z4.string().describe("What the code does today that matters for this task"),
+    where: z4.string().describe("Where it is: owner/repo path:line")
   })).describe("Findings from the code"),
-  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")
+  dataFacts: z4.array(z4.string()).describe("Numbers and facts from the events or the business data, each with its source. Empty when the task needs no data"),
+  approach: z4.string().describe("The approach you would take, in 2-4 sentences"),
+  codeMap: z4.array(z4.object({
+    repo: z4.string().describe("Repository full name (owner/name)"),
+    file: z4.string().describe("Path relative to the repository root"),
+    role: z4.string().describe("Why it matters: what to change or reuse there")
   })).describe("The files the change will touch or must reuse"),
-  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")
+  assumptions: z4.array(z4.object({
+    text: z4.string().describe("The default you chose"),
+    reason: z4.string().describe("Why it is safe or why it was chosen")
   })).describe("Corners settled with a default instead of a question"),
-  pendingDecisions: z3.array(z3.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
+  pendingDecisions: z4.array(z4.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
 });
-var questionsPayloadSchema = z3.object({
+var questionsPayloadSchema = z4.object({
   brief: briefSchema,
-  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`)
+  questions: z4.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 = 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")
+var specSchema = z4.object({
+  goal: z4.string().describe("The problem solved, for whom, and the outcome a user or the business will notice"),
+  context: z4.string().describe("Summary: the problem in 1-2 sentences, then the chosen approach in 1-2 sentences"),
+  inScope: z4.array(z4.string()).describe("What this task delivers, one item each"),
+  outOfScope: z4.array(z4.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: z4.array(z4.object({
+    question: z4.string(),
+    answer: z4.string(),
+    by: z4.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: 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")
+  codeMap: z4.array(z4.object({
+    repo: z4.string().describe("Repository full name (owner/name)"),
+    file: z4.string().describe("Path relative to the repository root"),
+    role: z4.string().describe("What the coder needs to know about this file"),
+    use: z4.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: 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")
+  changes: z4.array(z4.object({
+    repo: z4.string().describe("Repository full name (owner/name) where the change happens"),
+    file: z4.string().describe("Path to the file, relative to the repository root"),
+    action: z4.enum(["create", "modify", "delete"]),
+    description: z4.string().describe("The behaviour the file has after the change and which existing functions or patterns to extend. No code snippets or diffs"),
+    produces: z4.array(z4.string()).describe("Names with signatures or data shapes this change creates or changes for other changes. Empty when none"),
+    consumes: z4.array(z4.string()).describe("Names with signatures or data shapes this change uses from earlier changes. Empty when none"),
+    acceptance: z4.array(z4.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: 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')
+  acceptance: z4.array(z4.object({
+    id: z4.string().describe("AC-1, AC-2 and so on, in order"),
+    kind: z4.enum(["main", "edge", "keep"]).describe("main: the main path; edge: an error, empty or limit case; keep: existing behaviour that must keep working"),
+    text: z4.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: 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")
+  testPlan: z4.object({
+    automated: z4.array(z4.object({
+      repo: z4.string(),
+      command: z4.string().describe("The exact command to run"),
+      expect: z4.string().describe("What passing looks like")
     })).describe("At least one command"),
-    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")
+    newTests: z4.array(z4.object({
+      seam: z4.string().describe("Where the test goes: the highest seam that covers the behaviour (an endpoint, a page, a public function)"),
+      covers: z4.array(z4.string()).describe("Ids of the criteria it covers")
     })),
-    manual: z3.array(z3.object({
-      page: z3.string().describe("The page or screen"),
-      steps: z3.string().describe("What a person does and sees")
+    manual: z4.array(z4.object({
+      page: z4.string().describe("The page or screen"),
+      steps: z4.string().describe("What a person does and sees")
     }))
   }),
-  risks: z3.array(z3.object({
-    risk: z3.string(),
-    mitigation: z3.string()
+  risks: z4.array(z4.object({
+    risk: z4.string(),
+    mitigation: z4.string()
   })).describe("What could go wrong: migrations, existing data, access, performance, compatibility"),
-  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")
+  riskLevel: z4.enum(["low", "medium", "high"]).describe("How closely a person should review the result"),
+  assumptions: z4.array(z4.object({
+    text: z4.string().describe("The default you chose"),
+    reason: z4.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 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")
+  openQuestions: z4.array(questionSchema).describe("Questions only the owner can settle; the spec cannot be approved until each is answered or dismissed. Empty when none"),
+  split: z4.array(z4.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")
 });
-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")
+var resultBriefSchema = z4.object({
+  format: z4.literal("brief").describe('Always "brief"'),
+  goal: z4.string().describe("What the work is for, for whom, and the outcome people will notice"),
+  context: z4.string().describe("Summary: the situation in 1-2 sentences, then how the work will be done in 1-2 sentences"),
+  contains: z4.array(z4.string()).min(1).describe("What the result must contain, one item each: the parts, facts and attachments a reader expects"),
+  acceptance: z4.array(z4.object({
+    id: z4.string().describe("AC-1, AC-2 and so on, in order"),
+    text: z4.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")
+  constraints: z4.array(z4.string()).describe("Rules the result must keep: length, tone, language, deadlines, what must not be promised. Empty when none"),
+  outOfScope: z4.array(z4.string()).describe("What this work does not do: nearby things someone might be tempted to add. Empty when nothing is tempting"),
+  sources: z4.array(z4.object({
+    source: z4.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: z4.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")
+  approver: z4.string().describe("Who approves the result, as the task or the board names them"),
+  decisions: z4.array(z4.object({
+    question: z4.string(),
+    answer: z4.string(),
+    by: z4.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")
+  assumptions: z4.array(z4.object({
+    text: z4.string().describe("The default you chose"),
+    reason: z4.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")
+  openQuestions: z4.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) {
+function reply3(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 reply2(`Could not reach TAMsense to check this: ${message}. Call ${toolName} again in a moment.`, true);
+  return reply3(`Could not reach TAMsense to check this: ${message}. Call ${toolName} again in a moment.`, true);
 }
 function questionsTool(review, onSubmit) {
-  return tool3(
+  return tool4(
     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,
@@ -2111,10 +2827,10 @@ function questionsTool(review, onSubmit) {
         return unreachable(error, SUBMIT_QUESTIONS_TOOL_NAME);
       }
       if (!verdict.accepted) {
-        return reply2(verdict.feedback, true);
+        return reply3(verdict.feedback, true);
       }
       onSubmit(args);
-      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.");
+      return reply3(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.");
     }
   );
 }
@@ -2122,7 +2838,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 tool3(
+  return tool4(
     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,
@@ -2135,20 +2851,20 @@ function specTool(review, onSubmit, builderCheckRan) {
       }
       if (!verdict.accepted) {
         repairs += 1;
-        return reply2(verdict.feedback, true);
+        return reply3(verdict.feedback, true);
       }
       if (!builderCheckRan() && !reminded) {
         reminded = true;
-        return reply2(BUILDER_CHECK_FIRST, true);
+        return reply3(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.");
+      return reply3(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(
+  return tool4(
     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,
@@ -2161,10 +2877,10 @@ function briefTool(review, onSubmit) {
       }
       if (!verdict.accepted) {
         repairs += 1;
-        return reply2(verdict.feedback, true);
+        return reply3(verdict.feedback, true);
       }
       onSubmit({ spec: args, problems: verdict.problems });
-      return reply2(verdict.problems.length > 0 ? `Brief saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Brief saved.");
+      return reply3(verdict.problems.length > 0 ? `Brief saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Brief saved.");
     }
   );
 }
@@ -2265,10 +2981,13 @@ function usageLimitWatch() {
 
 // src/claude.ts
 var NO_RESULT_TEXT = "Claude finished without a result.";
-var SERVER_NAME = "tamsense";
+var SERVER_NAME2 = "tamsense";
 var CAPTION_FIELDS = {
-  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"')
+  title: z5.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: z5.string().describe('one line, at most 160 characters, on why it was made: "Comparing two layouts for the empty orders state"')
+};
+var NOTES_FIELD = {
+  notes: z5.string().optional().describe('what you tested in it and what happened, at most 600 characters: what you opened, what you clicked or typed, what you expected, and whether it passed or failed. "Opened the disposed requests on the warehouse page, filtered by December, expected 3 rows: got 3, passed. Clicked Export: the file was empty, failed."')
 };
 var ATTACH_TOOLS = {
   screenshot: {
@@ -2278,32 +2997,32 @@ var ATTACH_TOOLS = {
   },
   replay: {
     name: REPLAY_TOOL_NAME,
-    description: "Attach a browser replay (the .rrweb.ndjson file the TAMsense recorder wrote) to the task now, with your own title and purpose. Every recording is attached at the end of the run anyway; use this to attach one earlier or to name it better. Close the browser context first so the file is complete.",
+    description: "Attach a browser replay (the .rrweb.ndjson file the TAMsense recorder wrote) to the task now, with your own title, purpose and notes on what you tested and what happened. Every recording is attached at the end of the run anyway; use this to attach one earlier or to name it better. Close the browser context first so the file is complete.",
     path: "absolute path of the .rrweb.ndjson replay file"
   },
   video: {
     name: VIDEO_TOOL_NAME,
-    description: "Attach a browser video (.webm or .mp4, up to 200 MB) to the task now, with your own title and purpose. Videos recorded with video: true are attached at the end of the run anyway. Close the browser context first so the file is complete.",
+    description: "Attach a browser video (.webm or .mp4, up to 200 MB) to the task now, with your own title, purpose and notes on what you tested and what happened. Videos recorded with video: true are attached at the end of the run anyway. Close the browser context first so the file is complete.",
     path: "absolute path of the video file"
   }
 };
 function attachTool(kind, attach) {
   const spec = ATTACH_TOOLS[kind];
-  return tool4(
+  return tool5(
     spec.name,
     spec.description,
-    { path: z4.string().describe(spec.path), ...CAPTION_FIELDS },
+    { path: z5.string().describe(spec.path), ...CAPTION_FIELDS, ...kind === "screenshot" ? {} : NOTES_FIELD },
     async (args) => ({ content: [{ type: "text", text: await attach({ kind, ...args }) }] })
   );
 }
 function verdictTool(onVerdict) {
-  return tool4(
+  return tool5(
     VERDICT_TOOL_NAME,
     "Hand in the result of this check. Call it exactly once, at the very end.",
     {
-      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")
+      passed: z5.boolean().describe("true only if nothing must be fixed"),
+      report: z5.string().describe("what you checked and, if it failed, exactly what to fix with file and line"),
+      couldNotRun: z5.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 });
@@ -2312,13 +3031,13 @@ function verdictTool(onVerdict) {
   );
 }
 function handoffTool(targets, onHandoff) {
-  return tool4(
+  return tool5(
     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: 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")
+      to: z5.string().describe("name or id of the step to hand the task to"),
+      outcome: z5.enum(HANDOFF_OUTCOMES).describe("pass: the work is done; problems: something must be fixed; ask: a question for that step"),
+      note: z5.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);
@@ -2331,25 +3050,25 @@ function handoffTool(targets, onHandoff) {
   );
 }
 function askPersonTool(asking, waiting) {
-  return tool4(
+  return tool5(
     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: 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")
+      to: z5.union([z5.number(), z5.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: z5.string().describe('one line on why this person: "assignee, and the run is on her computer", "Designer, owns empty states"'),
+      question: z5.string().describe("one plain question the person can answer without reading the code"),
+      context: z5.string().optional().describe("one line on what you saw that led to the question"),
+      tried: z5.array(z5.object({
+        did: z5.string().describe("the command or step"),
+        error: z5.string().optional().describe("the exact error line, if there was one"),
+        result: z5.string().describe("what it showed, one line")
       })).max(MAX_ASK_TRIES).optional().describe("what you already tried, the most telling first"),
-      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")
+      options: z5.array(z5.object({
+        label: z5.string().describe("a short answer the person can pick"),
+        detail: z5.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: 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")
+      blocking: z5.boolean().describe("true when you cannot go on without the answer"),
+      assumption: z5.string().optional().describe("when blocking is false: what you continue with until the answer comes")
     },
     async (args) => {
       if (waiting.waitingFor !== null) {
@@ -2359,16 +3078,16 @@ function askPersonTool(asking, waiting) {
       if ("error" in choice) {
         return { content: [{ type: "text", text: choice.error }], isError: true };
       }
-      let reply3;
+      let reply4;
       try {
-        reply3 = await asking.send(choice.body);
+        reply4 = 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 = reply3.id;
+        waiting.waitingFor = reply4.id;
       }
-      return { content: [{ type: "text", text: askedText(reply3.name, choice.body) }] };
+      return { content: [{ type: "text", text: askedText(reply4.name, choice.body) }] };
     }
   );
 }
@@ -2412,11 +3131,12 @@ function tamsenseServer(request, submitted) {
       submitted.handoff = handoff;
     })] : [],
     ...request.results ? resultToolset(request.results) : [],
-    ...request.handOver ? [handOverTool(request.handOver)] : []
+    ...request.handOver ? [handOverTool(request.handOver)] : [],
+    ...request.schedules ? [proposeScheduleTool(request.schedules, submitted)] : []
   ];
   return {
-    server: createSdkMcpServer({ name: SERVER_NAME, version: "1.0.0", tools }),
-    allowed: tools.map((item) => `mcp__${SERVER_NAME}__${item.name}`)
+    server: createSdkMcpServer2({ name: SERVER_NAME2, version: "1.0.0", tools }),
+    allowed: tools.map((item) => `mcp__${SERVER_NAME2}__${item.name}`)
   };
 }
 function modelOptions(request) {
@@ -2452,7 +3172,7 @@ async function attempt(request, context, resume) {
       // режим auto сам решает, что можно; о чём он спросил бы человека, решают правила проекта или люди задачи
       canUseTool: request.permissions ? askPermission(request.permissions, () => context.lastWords.text, request.cwd) : denyWhenAsked,
       plugins: [{ type: "local", path: request.library }],
-      mcpServers: { [SERVER_NAME]: tamsense.server },
+      mcpServers: { [SERVER_NAME2]: tamsense.server },
       allowedTools: tamsense.allowed,
       abortController: context.abortController,
       env: request.env,
@@ -2505,7 +3225,7 @@ function claudeRunner(startQuery) {
       request.input.close();
       abortController.abort();
     }, { once: true });
-    const submitted = { verdict: null, handoff: null, questions: null, spec: null, helperStarted: false, waitingFor: null };
+    const submitted = { verdict: null, handoff: null, questions: null, spec: null, helperStarted: false, waitingFor: null, waitingForSchedule: null };
     const limit = usageLimitWatch();
     const context = { startQuery, abortController, submitted, limit, lastWords: { text: "" } };
     try {
@@ -2515,22 +3235,22 @@ function claudeRunner(startQuery) {
       }
       const pausedUntil = limit.pausedUntil(result.outcome.completed);
       const outcome = pausedUntil ? { ...result.outcome, completed: false, report: USAGE_LIMIT_REPORT } : result.outcome;
-      return { ...outcome, verdict: submitted.verdict, handoff: submitted.handoff, questions: submitted.questions, spec: submitted.spec, sessionId: result.sessionId, pausedUntil, waitingFor: submitted.waitingFor };
+      return { ...outcome, verdict: submitted.verdict, handoff: submitted.handoff, questions: submitted.questions, spec: submitted.spec, sessionId: result.sessionId, pausedUntil, waitingFor: submitted.waitingFor, waitingForSchedule: submitted.waitingForSchedule };
     } finally {
       request.input.close();
     }
   };
 }
-var runClaude = claudeRunner(query2);
+var runClaude = claudeRunner(query3);
 
 // src/config.ts
-import { mkdir as mkdir3, readFile as readFile3, rm as rm4, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile3, rm as rm4, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 var OWNER_ONLY_FILE = 384;
 var OWNER_ONLY_FOLDER = 448;
 function configPath(home = homedir2()) {
-  return join4(home, ".tamsense", "runner.json");
+  return join6(home, ".tamsense", "runner.json");
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2557,7 +3277,7 @@ async function readConfig(path = configPath()) {
   }
 }
 async function writeConfig(config, path = configPath()) {
-  await mkdir3(dirname2(path), { recursive: true, mode: OWNER_ONLY_FOLDER });
+  await mkdir4(dirname2(path), { recursive: true, mode: OWNER_ONLY_FOLDER });
   await writeFile3(path, `${JSON.stringify(config, null, 4)}
 `, { mode: OWNER_ONLY_FILE });
 }
@@ -2579,14 +3299,14 @@ async function login(tools, request) {
   tools.openBrowser(pageUrl);
   while (tools.now() < expiresAt) {
     await tools.sleep(pairing.intervalSeconds * MS_PER_SECOND);
-    const reply3 = await tools.api.request("POST", PAIRING_TOKEN_PATH, { deviceCode: pairing.deviceCode });
-    if (reply3.status === "connected") {
-      return { token: reply3.token, device: reply3.device };
+    const reply4 = await tools.api.request("POST", PAIRING_TOKEN_PATH, { deviceCode: pairing.deviceCode });
+    if (reply4.status === "connected") {
+      return { token: reply4.token, device: reply4.device };
     }
-    if (reply3.status === "denied") {
+    if (reply4.status === "denied") {
       throw new Error(DENIED_TEXT);
     }
-    if (reply3.status === "expired") {
+    if (reply4.status === "expired") {
       break;
     }
   }
@@ -2594,15 +3314,15 @@ async function login(tools, request) {
 }
 
 // src/recorderEnv.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join8 } from "path";
 import { fileURLToPath } from "url";
 
 // src/recorder.ts
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import Module, { createRequire } from "module";
-import { basename as basename2, dirname as dirname3, join as join5 } from "path";
-import process2 from "process";
+import { basename as basename3, dirname as dirname3, join as join7 } from "path";
+import process4 from "process";
 var RECORDINGS_DIR_ENV = "TAMSENSE_RECORDINGS_DIR";
 var SERVER_ENV = "TAMSENSE_SERVER";
 var DEFAULT_TITLE_ENV = "TAMSENSE_RECORDING_TITLE";
@@ -2612,6 +3332,7 @@ var REPLAY_SUFFIX = ".rrweb.ndjson";
 var META_SUFFIX = ".json";
 var MAX_TITLE_LENGTH = 60;
 var MAX_PURPOSE_LENGTH = 160;
+var MAX_NOTES_LENGTH = 600;
 var DEFAULT_TRACKER_ORIGINS = ["https://my.tamsense.com"];
 var READ_METHODS = ["GET", "HEAD", "OPTIONS"];
 var BINDING = "__tamsenseRecord";
@@ -2619,21 +3340,24 @@ var STATE_KEY = /* @__PURE__ */ Symbol.for("tamsense.recorder");
 var FLUSH_MS = 100;
 var MAX_SESSION_BYTES = 300 * 1024 * 1024;
 var GAP_CHECK_MS = 1500;
+var RRWEB_INCREMENTAL = 3;
 var RRWEB_META = 4;
+var RRWEB_SOURCE_MOUSE_INTERACTION = 2;
+var RRWEB_SOURCE_INPUT = 5;
 function state() {
   const holder = globalThis;
   holder[STATE_KEY] ??= { contexts: /* @__PURE__ */ new WeakMap(), pages: /* @__PURE__ */ new WeakMap(), instrumented: /* @__PURE__ */ new WeakSet(), script: null, hooked: false };
   return holder[STATE_KEY];
 }
 function recordingsDir() {
-  const dir = process2.env[RECORDINGS_DIR_ENV];
+  const dir = process4.env[RECORDINGS_DIR_ENV];
   if (!dir) {
     throw new Error(`${RECORDINGS_DIR_ENV} is not set: recordings work only inside a TAMsense run`);
   }
   return dir;
 }
 function warn(text2) {
-  process2.stderr.write(`[tamsense recorder] ${text2}
+  process4.stderr.write(`[tamsense recorder] ${text2}
 `);
 }
 function isTrackerIngest(url, tamsenseOrigins) {
@@ -2649,7 +3373,7 @@ function isLocalHost(hostname2) {
 function isExternalWrite(method, url) {
   return !READ_METHODS.includes(method.toUpperCase()) && !isLocalHost(url.hostname);
 }
-function trackerOrigins(env = process2.env) {
+function trackerOrigins(env = process4.env) {
   const origins = new Set(DEFAULT_TRACKER_ORIGINS);
   try {
     if (env[SERVER_ENV]) {
@@ -2670,11 +3394,18 @@ function checkCaption(caption) {
   }
   return { title, purpose };
 }
+function checkNotes(notes) {
+  const text2 = typeof notes === "string" ? notes.trim() : "";
+  if (text2.length > MAX_NOTES_LENGTH) {
+    throw new Error(`Keep the notes within ${MAX_NOTES_LENGTH} characters: what you opened, clicked and expected, and whether it passed.`);
+  }
+  return text2;
+}
 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 ${basename2(script2)}` : "";
+function automaticCaption(env = process4.env, script2 = process4.argv[1]) {
+  const from = script2 ? `, opened by ${basename3(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)
@@ -2682,7 +3413,7 @@ function automaticCaption(env = process2.env, script2 = process2.argv[1]) {
 }
 function rrwebSource() {
   const entry = createRequire(import.meta.url).resolve("rrweb");
-  return readFileSync(join5(dirname3(entry), "rrweb.umd.min.cjs"), "utf8");
+  return readFileSync(join7(dirname3(entry), "rrweb.umd.min.cjs"), "utf8");
 }
 function pageScript(rrweb) {
   return `(() => {
@@ -2700,11 +3431,22 @@ const send = (extra) => {
     buffer = [];
     return window.${BINDING}(JSON.stringify({ events, ...extra })).catch(() => {});
 };
+const urgent = (event) => event.type === ${RRWEB_INCREMENTAL} && (event.data.source === ${RRWEB_SOURCE_MOUSE_INTERACTION} || event.data.source === ${RRWEB_SOURCE_INPUT});
+const placeAtTarget = (interaction) => {
+    if (interaction.x !== 0 || interaction.y !== 0) return;
+    const node = rrweb.record.mirror.getNode(interaction.id);
+    if (!node || typeof node.getBoundingClientRect !== 'function') return;
+    const box = node.getBoundingClientRect();
+    interaction.x = Math.round(box.left + box.width / 2);
+    interaction.y = Math.round(box.top + box.height / 2);
+};
 rrweb.record({
     emit(event) {
         buffer.push(event);
-        if (!timer) timer = setTimeout(send, ${FLUSH_MS});
+        if (urgent(event)) send();
+        else if (!timer) timer = setTimeout(send, ${FLUSH_MS});
     },
+    hooks: { mouseInteraction: placeAtTarget },
     maskInputOptions: { password: true },
 });
 const crossOrigin = (frame) => { try { return new URL(frame.src, location.href).origin !== location.origin; } catch { return false; } };
@@ -2717,6 +3459,7 @@ const checkGaps = () => {
 };
 window.__tamsenseFlush = () => send();
 window.__tamsenseMark = (label) => { rrweb.record.addCustomEvent('${MARK_TAG}', { label }); return send(); };
+addEventListener('beforeunload', () => { send(); });
 addEventListener('pagehide', () => { send(); });
 addEventListener('load', () => setTimeout(checkGaps, ${GAP_CHECK_MS}));
 })();`;
@@ -2733,9 +3476,9 @@ var Session = class {
   bytes = 0;
   constructor(dir, recording, url) {
     const id = `${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
-    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 };
+    this.file = join7(dir, `${id}${REPLAY_SUFFIX}`);
+    this.metaFile = join7(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, notes: "" };
     writeFileSync(this.file, "");
     this.save();
   }
@@ -2779,8 +3522,8 @@ var Session = class {
     }
   }
   summary() {
-    const { title, purpose, video, marks, gaps, blockedTrackerRequests, blockedExternalWrites } = this.meta;
-    return { title, purpose, replay: this.file, video, marks: marks.length, gaps, blockedTrackerRequests, blockedExternalWrites };
+    const { title, purpose, notes, video, marks, gaps, blockedTrackerRequests, blockedExternalWrites } = this.meta;
+    return { title, purpose, notes, replay: this.file, video, marks: marks.length, gaps, blockedTrackerRequests, blockedExternalWrites };
   }
 };
 function countBlocked(route, counter) {
@@ -2899,7 +3642,7 @@ function installAutoRecording() {
     return exports;
   };
 }
-if (process2.env[RECORDINGS_DIR_ENV]) {
+if (process4.env[RECORDINGS_DIR_ENV]) {
   installAutoRecording();
 }
 
@@ -2907,10 +3650,10 @@ if (process2.env[RECORDINGS_DIR_ENV]) {
 var RECORDER_ENV = "TAMSENSE_RECORDER";
 function bundledRecorder() {
   const path = fileURLToPath(new URL("./recorder.cjs", import.meta.url));
-  return existsSync3(path) ? path : null;
+  return existsSync6(path) ? path : null;
 }
 function recordingsFolder(home, runId) {
-  return join6(home, ".tamsense", "recordings", `run-${runId}`);
+  return join8(home, ".tamsense", "recordings", `run-${runId}`);
 }
 function nodeOptionsWithRecorder(recorder, nodeOptions) {
   return [nodeOptions?.trim(), `--require "${recorder.replaceAll("\\", "/")}"`].filter(Boolean).join(" ");
@@ -2940,7 +3683,7 @@ function describeDevice(identity) {
 import { spawn as spawn3 } from "child_process";
 import { hostname } from "os";
 import { delimiter as delimiter2 } from "path";
-import { setTimeout as wait } from "timers/promises";
+import { setTimeout as wait2 } from "timers/promises";
 var PLATFORM_LABELS = {
   win32: "Windows",
   darwin: "macOS",
@@ -2976,14 +3719,14 @@ function withNodeOnPath(env, nodeDir, separator = delimiter2) {
   return { ...env, [key]: [...entries, nodeDir].join(separator) };
 }
 async function sleep(ms, signal) {
-  await wait(ms, void 0, { signal }).catch(() => {
+  await wait2(ms, void 0, { signal }).catch(() => {
   });
 }
 
 // src/update.ts
 import { spawn as spawn4 } from "child_process";
 import { readFileSync as readFileSync2 } from "fs";
-import process3 from "process";
+import process5 from "process";
 var PACKAGE_NAME = "@tamsensedev/runner";
 var RELAUNCHED_ENV = "TAMSENSE_RELAUNCHED";
 var NO_UPDATE_ENV = "TAMSENSE_NO_UPDATE";
@@ -3035,19 +3778,19 @@ function relaunchArgs(argv) {
   return ["--yes", `${PACKAGE_NAME}@latest`, ...argv];
 }
 function relaunch(argv, env) {
-  const isWindows = process3.platform === "win32";
-  return new Promise((resolve3, reject) => {
+  const isWindows = process5.platform === "win32";
+  return new Promise((resolve5, 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);
+    process5.on("SIGINT", ignoreInterrupt);
     child.on("error", (error) => {
-      process3.off("SIGINT", ignoreInterrupt);
+      process5.off("SIGINT", ignoreInterrupt);
       reject(error);
     });
     child.on("close", (code) => {
-      process3.off("SIGINT", ignoreInterrupt);
-      resolve3(code ?? 1);
+      process5.off("SIGINT", ignoreInterrupt);
+      resolve5(code ?? 1);
     });
   });
 }
@@ -3055,7 +3798,7 @@ function relaunch(argv, env) {
 // src/worker.ts
 import { rm as rm6 } from "fs/promises";
 import { dirname as dirname5 } from "path";
-import process4 from "process";
+import process6 from "process";
 
 // src/feedQueue.ts
 var MAX_BATCH = 200;
@@ -3064,6 +3807,7 @@ function feedQueue(send) {
   let seq = 0;
   let waiting = [];
   let sending = Promise.resolve();
+  let queued = false;
   async function drain() {
     while (waiting.length > 0) {
       const batch = waiting.slice(0, MAX_BATCH);
@@ -3087,16 +3831,22 @@ function feedQueue(send) {
       return entry;
     },
     flush() {
-      sending = sending.then(drain);
+      if (!queued) {
+        queued = true;
+        sending = sending.then(() => {
+          queued = false;
+          return drain();
+        });
+      }
       return sending;
     }
   };
 }
 
 // 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 { existsSync as existsSync7 } from "fs";
+import { cp, mkdir as mkdir5, rm as rm5 } from "fs/promises";
+import { join as join9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var LIBRARY_PATH = fileURLToPath2(new URL("../library", import.meta.url));
 var SKILL_NAME = /^[a-z0-9-]+$/;
@@ -3109,18 +3859,18 @@ function allowedSkills(stage) {
   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}`);
+  return join9(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 });
+  await mkdir5(join9(folder, "skills"), { recursive: true });
+  await cp(join9(source, ".claude-plugin"), join9(folder, ".claude-plugin"), { recursive: true });
+  await cp(join9(source, "agents"), join9(folder, "agents"), { recursive: true });
+  for (const skill of skills.filter((name) => SKILL_NAME.test(name) && existsSync7(join9(source, "skills", name)))) {
+    await cp(join9(source, "skills", skill), join9(folder, "skills", skill), { recursive: true });
   }
   return folder;
 }
@@ -3128,8 +3878,8 @@ async function prepareLibrary(folder, skills, source = LIBRARY_PATH) {
 // src/recordings.ts
 import { randomUUID } from "crypto";
 import { createReadStream } from "fs";
-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 { readdir as readdir2, readFile as readFile4, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename4, dirname as dirname4, extname as extname2, isAbsolute as isAbsolute3, join as join10 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { Readable } from "stream";
 import { promisify } from "util";
@@ -3186,11 +3936,19 @@ async function* replayChunks(lines, scan, targetBytes = CHUNK_TARGET_BYTES) {
 `;
   }
 }
+function recordingNotes(meta) {
+  const notes = meta?.notes?.trim();
+  if (notes) {
+    return notes;
+  }
+  const marks = meta?.marks ?? [];
+  return marks.length > 0 ? clip2(`Steps marked: ${marks.map((mark) => mark.label).join("; ")}.`, MAX_NOTES_LENGTH) : "";
+}
 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 basename3(file).replace(REPLAY_SUFFIX, "");
+  return basename4(file).replace(REPLAY_SUFFIX, "");
 }
 async function readMeta(file) {
   try {
@@ -3201,12 +3959,12 @@ async function readMeta(file) {
 }
 async function metaFor(kind, file) {
   if (kind === "replay") {
-    return readMeta(join8(dirname4(file), `${sessionIdOf(file)}${META_SUFFIX}`));
+    return readMeta(join10(dirname4(file), `${sessionIdOf(file)}${META_SUFFIX}`));
   }
-  const folder = basename3(dirname4(file)) === "video" ? dirname4(dirname4(file)) : dirname4(file);
-  for (const name of await readdir(folder).catch(() => [])) {
+  const folder = basename4(dirname4(file)) === "video" ? dirname4(dirname4(file)) : dirname4(file);
+  for (const name of await readdir2(folder).catch(() => [])) {
     if (name.endsWith(META_SUFFIX) && name !== LEDGER_FILE) {
-      const meta = await readMeta(join8(folder, name));
+      const meta = await readMeta(join10(folder, name));
       if (meta?.video === file) {
         return meta;
       }
@@ -3216,7 +3974,7 @@ async function metaFor(kind, file) {
 }
 async function ledger(dir) {
   try {
-    return new Set(JSON.parse(await readFile4(join8(dir, LEDGER_FILE), "utf8")));
+    return new Set(JSON.parse(await readFile4(join10(dir, LEDGER_FILE), "utf8")));
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -3224,21 +3982,21 @@ async function ledger(dir) {
 async function remember(dir, file) {
   const done2 = await ledger(dir);
   done2.add(file);
-  await writeFile4(join8(dir, LEDGER_FILE), JSON.stringify([...done2]));
+  await writeFile4(join10(dir, LEDGER_FILE), JSON.stringify([...done2]));
 }
 async function nonEmpty(file) {
   return file !== null && ((await stat2(file).catch(() => null))?.size ?? 0) > 0;
 }
 async function pendingRecordings(dir) {
   const done2 = await ledger(dir);
-  const names = (await readdir(dir).catch(() => [])).sort();
+  const names = (await readdir2(dir).catch(() => [])).sort();
   const pending = [];
   for (const name of names) {
     if (!name.endsWith(META_SUFFIX) || name === LEDGER_FILE) {
       continue;
     }
-    const meta = await readMeta(join8(dir, name));
-    const replay = join8(dir, `${name.slice(0, -META_SUFFIX.length)}${REPLAY_SUFFIX}`);
+    const meta = await readMeta(join10(dir, name));
+    const replay = join10(dir, `${name.slice(0, -META_SUFFIX.length)}${REPLAY_SUFFIX}`);
     if (!done2.has(replay) && await nonEmpty(replay)) {
       pending.push({ kind: "replay", file: replay, meta });
     }
@@ -3248,7 +4006,7 @@ async function pendingRecordings(dir) {
   }
   return pending;
 }
-async function uploadReplay(upload, file, caption) {
+async function uploadReplay(upload, file, label) {
   const id = randomUUID();
   const scan = { startTs: Number.POSITIVE_INFINITY, snapshot: false, marks: [] };
   const lines = createInterface2({ input: createReadStream(file, "utf8"), crlfDelay: Infinity });
@@ -3258,9 +4016,9 @@ 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: basename3(file), ...caption, contentType: "application/x-ndjson", durationMs: null, marks: marksFrom(scan.marks, scan.startTs) });
+  return finish(upload, { kind: "replay", upload: id, name: basename4(file), ...label, contentType: "application/x-ndjson", durationMs: null, marks: marksFrom(scan.marks, scan.startTs) });
 }
-async function uploadVideo(upload, file, caption, meta) {
+async function uploadVideo(upload, file, label, meta) {
   const contentType = VIDEO_TYPES_BY_EXTENSION[extname2(file).toLowerCase()];
   const info = await stat2(file);
   if (info.size > MAX_VIDEO_BYTES) {
@@ -3273,13 +4031,13 @@ 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: basename3(file), ...caption, contentType, durationMs, marks });
+  return finish(upload, { kind: "video", upload: id, name: basename4(file), ...label, 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 (!isAbsolute2(request.path)) {
+  if (!isAbsolute3(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) : extname2(request.path).toLowerCase() in VIDEO_TYPES_BY_EXTENSION;
@@ -3290,15 +4048,18 @@ async function attachRecording(api, runId, recordingsDir2, request) {
     return `There is no recording at ${request.path}. Close the browser context first (closeRecorded) so the file is complete.`;
   }
   let caption;
+  let notes;
   try {
     caption = checkCaption(request);
+    notes = checkNotes(request.notes);
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
   }
   try {
     const meta = await metaFor(request.kind, request.path);
+    const label = { ...caption, notes: notes || recordingNotes(meta) };
     const upload = { api, runId };
-    await (request.kind === "replay" ? uploadReplay(upload, request.path, caption) : uploadVideo(upload, request.path, caption, meta));
+    await (request.kind === "replay" ? uploadReplay(upload, request.path, label) : uploadVideo(upload, request.path, label, meta));
     await remember(recordingsDir2, request.path);
   } catch (error) {
     return `Could not attach the ${request.kind}: ${error instanceof Error ? error.message : String(error)}`;
@@ -3330,8 +4091,9 @@ async function uploadPendingRecordings(api, runId, dir) {
       title: numbered(`${recording.kind}:${title}`, title, used),
       purpose: recording.meta?.purpose || "Recorded automatically while the agent used a browser"
     });
+    const label = { ...caption, notes: recordingNotes(recording.meta) };
     try {
-      await (recording.kind === "replay" ? uploadReplay(upload, recording.file, caption) : uploadVideo(upload, recording.file, caption, recording.meta));
+      await (recording.kind === "replay" ? uploadReplay(upload, recording.file, label) : uploadVideo(upload, recording.file, label, recording.meta));
       await remember(dir, recording.file);
       report.uploaded += 1;
     } catch (error) {
@@ -3348,7 +4110,7 @@ async function uploadPendingRecordings(api, runId, dir) {
 
 // src/screenshot.ts
 import { readFile as readFile5, stat as stat3 } from "fs/promises";
-import { basename as basename4, extname as extname3, isAbsolute as isAbsolute3 } from "path";
+import { basename as basename5, extname as extname3, isAbsolute as isAbsolute4 } from "path";
 var TYPES_BY_EXTENSION2 = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -3356,7 +4118,7 @@ var TYPES_BY_EXTENSION2 = {
   ".webp": "image/webp"
 };
 async function readScreenshot(request) {
-  if (!isAbsolute3(request.path)) {
+  if (!isAbsolute4(request.path)) {
     return "Give the absolute path of the image file.";
   }
   const contentType = TYPES_BY_EXTENSION2[extname3(request.path).toLowerCase()];
@@ -3377,17 +4139,21 @@ async function readScreenshot(request) {
     return "The image is larger than 5 MB. Take a smaller screenshot (viewport instead of full page, or JPEG).";
   }
   const data = (await readFile5(request.path)).toString("base64");
-  return { name: basename4(request.path), ...caption, contentType, data };
+  return { name: basename5(request.path), ...caption, contentType, data };
 }
 
 // src/worker.ts
 var POLL_INTERVAL_MS = 5e3;
-var RETRY_AFTER_ERROR_MS = 15e3;
+var MAX_RETRY_WAIT_MS = 6e4;
+var POLL_DEADLINE_MS = 3 * 6e4;
 var INBOX_INTERVAL_MS = 2e3;
 var MAX_MESSAGE_LINE = 200;
 var CAPABILITIES_INTERVAL_MS = 30 * 6e4;
 var FEED_INTERVAL_MS = 1500;
 var FATAL_STATUSES = /* @__PURE__ */ new Set([401, 403]);
+var MAX_CHECKS = 2;
+var CHECK_HEARTBEAT_MS = 3e4;
+var CHECK_DEADLINE_MS = 10 * 6e4;
 var STOPPED_HERE = "stopped_here";
 var CLOSED_ON_SITE = "closed_on_site";
 function messageOf3(error) {
@@ -3419,7 +4185,7 @@ function sessionReporter(api, job, print2) {
   let sending = null;
   return {
     report: (session) => {
-      sending ??= api.request("POST", runPath(job.runId, "session"), session).then(() => {
+      sending ??= api.request("POST", runPath(job.runId, "session"), session, { safeToRepeat: true }).then(() => {
       }, (error) => print2(`Could not tell TAMsense which Claude took the task: ${messageOf3(error)}`));
     },
     sent: async () => {
@@ -3462,35 +4228,35 @@ function inbox(job, tools, record, closedOnSite) {
   async function check() {
     const ack = input.takeDelivered();
     const body = { ack };
-    let reply3;
+    let reply4;
     try {
-      reply3 = await tools.api.request("POST", runPath(job.runId, "inbox"), body);
+      reply4 = await tools.api.request("POST", runPath(job.runId, "inbox"), body, { safeToRepeat: true });
     } catch (error) {
       input.restoreDelivered(ack);
-      if (!failing) {
+      if (!failing && !alreadyReported(error)) {
         tools.print(`Could not check for new messages on TAMsense, trying again: ${messageOf3(error)}`);
       }
       failing = true;
       return;
     }
     failing = false;
-    if (!reply3.keepGoing) {
+    if (!reply4.keepGoing) {
       closedOnSite();
       return;
     }
-    for (const message of reply3.messages) {
+    for (const message of reply4.messages) {
       if (input.push(message)) {
         tools.print(`  ${messageLine(message)}`);
       }
     }
-    for (const stop of reply3.helperStops ?? []) {
+    for (const stop of reply4.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 };
+    if (reply4.model !== null || reply4.effort !== null) {
+      const change = { model: reply4.model, effort: reply4.effort };
       void input.switchModel(change).then(
         (applied) => {
           if (applied) {
@@ -3545,11 +4311,11 @@ function permissionTools(job, tools) {
   }
   return {
     send: async (body) => {
-      const reply3 = await tools.api.request("POST", runPath(job.runId, "permissions"), body);
-      if (reply3.decision === "wait") {
+      const reply4 = await tools.api.request("POST", runPath(job.runId, "permissions"), body);
+      if (reply4.decision === "wait") {
         tools.print(`  Waiting for a person on TAMsense to allow: ${body.title || body.action}`);
       }
-      return reply3;
+      return reply4;
     },
     check: (id) => tools.api.request("GET", permissionPath(job.runId, id)),
     sleep: tools.sleep
@@ -3577,10 +4343,18 @@ async function prepare(job, tools) {
     const { results, ...workspace2 } = await prepareFolder(job, taskFolder(tools.home, job), tools.api);
     return { workspace: workspace2, results, identity: {} };
   }
+  if (isLocalJob(job)) {
+    tools.print("Preparing the code from the folders on this computer\u2026");
+    const workspace2 = await prepareLocalWorkspace(job, tools);
+    return { workspace: workspace2, results: null, identity: await commitIdentityEnv(job.repositories[0]?.folder ?? tools.home) };
+  }
   tools.print("Preparing the code\u2026");
   const workspace = await prepareWorkspace(job, await gitToken(tools.api, job), tools);
   return { workspace, results: null, identity: await commitIdentityEnv(tools.home) };
 }
+async function publish(workspace, job, api, identity) {
+  return isLocalJob(job) ? await publishLocalWorkspace(workspace, job, identity) : await publishWorkspace(workspace, job, await gitToken(api, job), identity);
+}
 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);
@@ -3594,7 +4368,7 @@ async function executeJob(job, tools, signal, input, record) {
   const attached = { count: 0 };
   const session = sessionReporter(tools.api, job, tools.print);
   const recordings = recordingsFolder(tools.home, job.runId);
-  const baseEnv = withNodeOnPath(process4.env, dirname5(process4.execPath));
+  const baseEnv = withNodeOnPath(process6.env, dirname5(process6.execPath));
   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,
@@ -3616,13 +4390,15 @@ async function executeJob(job, tools, signal, input, record) {
     onSession: session.report,
     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)
+    handOver: handOverTools(job, tools.api),
+    schedules: job.canSchedule ? scheduleTools(tools.api, runPath(job.runId, "schedules")) : null
   });
   await session.sent();
   signal.throwIfAborted();
   const waitingFor = outcome.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) : [];
+  const waitingForSchedule = outcome.waitingForSchedule ?? null;
+  const shouldPublish = job.stage.kind === "code" && !isFolderJob(job) && !isReadOnlyCode(job.stage) && outcome.completed && waitingFor === null && waitingForSchedule === null;
+  const pushed = shouldPublish ? await publish(workspace, job, tools.api, identity) : [];
   return {
     outcome: outcome.completed ? "succeeded" : "failed",
     report: outcome.report,
@@ -3635,20 +4411,24 @@ async function executeJob(job, tools, signal, input, record) {
     pausedUntil: outcome.pausedUntil ?? null,
     questions: outcome.questions ?? null,
     spec: outcome.spec ?? null,
-    waitingFor
+    waitingFor,
+    waitingForSchedule
   };
 }
 function clockOf(iso) {
   const time = new Date(iso);
   return `${String(time.getHours()).padStart(2, "0")}:${String(time.getMinutes()).padStart(2, "0")}`;
 }
-function resultLine(finish2, folder = false) {
+function resultLine(finish2, workspace = "repositories") {
   if (finish2.pausedUntil) {
     return `Paused: ${USAGE_LIMIT_REPORT}, resumes at ${clockOf(finish2.pausedUntil)}`;
   }
   if (finish2.waitingFor !== null) {
     return "Waiting for an answer on TAMsense. This computer is free for other tasks; the run continues here after the answer.";
   }
+  if (finish2.waitingForSchedule) {
+    return "Waiting for a schedule on TAMsense. This computer is free for other tasks; the run continues here when the schedule ends.";
+  }
   if (finish2.verdict?.couldNotRun) {
     return `Check could not run: ${finish2.verdict.report}`;
   }
@@ -3664,7 +4444,13 @@ function resultLine(finish2, folder = false) {
   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.`;
+  if (workspace === "folder") {
+    return "Done. The result is on the task on TAMsense.";
+  }
+  if (workspace === "local") {
+    return finish2.pushed.length > 0 ? `Done. ${finish2.pushed.map(localBranchLine).join(" ")}` : "Done. Nothing new to commit.";
+  }
+  return `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);
@@ -3694,7 +4480,7 @@ async function runJob(job, tools, stop) {
     stopRun();
   }
   stop.addEventListener("abort", stopRun, { once: true });
-  const feed = feedQueue((entries) => tools.api.request("POST", runPath(job.runId, "feed"), { entries }));
+  const feed = feedQueue((entries) => tools.api.request("POST", runPath(job.runId, "feed"), { entries }, { safeToRepeat: true }));
   const feeding = setInterval(() => void feed.flush(), FEED_INTERVAL_MS);
   const record = journal(feed, tools.print);
   const messages = inbox(job, tools, record, () => run2.abort(CLOSED_ON_SITE));
@@ -3727,11 +4513,49 @@ async function runJob(job, tools, stop) {
   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, isFolderJob(job)));
+    tools.print(resultLine(finish2, job.workspace));
   } catch (error) {
     tools.print(`Could not send the result to TAMsense: ${messageOf3(error)}`);
   }
 }
+var CHECK_TOO_LONG = "check_too_long";
+function checkFailure(error, signal) {
+  return signal.reason === CHECK_TOO_LONG ? `The check took longer than ${CHECK_DEADLINE_MS / 6e4} minutes.` : failureReport(error, signal);
+}
+async function runCheckJob(check, runCheck, tools, stop) {
+  tools.print(`Schedule check: ${check.title}${check.taskId === null ? "" : ` (task #${check.taskId})`}`);
+  const run2 = new AbortController();
+  const stopRun = () => run2.abort(STOPPED_HERE);
+  if (stop.aborted) {
+    stopRun();
+  }
+  stop.addEventListener("abort", stopRun, { once: true });
+  const deadline = setTimeout(() => run2.abort(CHECK_TOO_LONG), CHECK_DEADLINE_MS);
+  const beat = checkHeartbeat(tools.api, check, () => run2.abort(CLOSED_ON_SITE));
+  const beating = setInterval(() => void beat(), CHECK_HEARTBEAT_MS);
+  let body;
+  try {
+    const folder = await checkFolder(tools.home, check);
+    const env = withNodeOnPath(process6.env, dirname5(process6.execPath));
+    body = checkFinishBody(await runCheck({ cwd: folder, prompt: buildCheckPrompt(check, folder), model: check.model, env, signal: run2.signal }));
+  } catch (error) {
+    body = { outcome: "failed", report: checkFailure(error, run2.signal), model: null, usage: null, result: null };
+  } finally {
+    clearTimeout(deadline);
+    clearInterval(beating);
+    stop.removeEventListener("abort", stopRun);
+  }
+  if (run2.signal.reason === CLOSED_ON_SITE) {
+    tools.print("TAMsense closed this check while it was in progress. The result was not sent.");
+    return;
+  }
+  try {
+    await tools.api.request("POST", checkPath(check.checkId, "finish"), body);
+    tools.print(checkLine(body));
+  } catch (error) {
+    tools.print(`Could not send the check result to TAMsense: ${messageOf3(error)}`);
+  }
+}
 async function reportCapabilities(tools, stop) {
   if (!tools.capabilities) {
     return;
@@ -3747,7 +4571,7 @@ async function reportCapabilities(tools, stop) {
         printed = true;
       }
     } catch (error) {
-      if (!complained && !stop.aborted) {
+      if (!complained && !stop.aborted && !alreadyReported(error)) {
         tools.print(`Could not tell TAMsense which Claude models this computer has: ${messageOf3(error)}`);
         complained = true;
       }
@@ -3755,6 +4579,24 @@ async function reportCapabilities(tools, stop) {
     await tools.sleep(CAPABILITIES_INTERVAL_MS, stop);
   }
 }
+async function withDeadline(work2, ms, sleep2) {
+  const settled = new AbortController();
+  const deadline = new Promise((_, reject) => {
+    void sleep2(ms, settled.signal).then(() => {
+      if (!settled.signal.aborted) {
+        reject(new Error(`TAMsense did not answer for ${Math.round(ms / 6e4)} minutes`));
+      }
+    });
+  });
+  try {
+    return await Promise.race([work2, deadline]);
+  } finally {
+    settled.abort();
+  }
+}
+function untilReconnect(api, stop) {
+  return api.nextReconnect ? AbortSignal.any([stop, api.nextReconnect()]) : stop;
+}
 function jobTools(job, tools, parallel) {
   return parallel > 1 ? { ...tools, print: (line) => tools.print(`[#${job.taskId} ${job.stage.name}] ${line}`) } : tools;
 }
@@ -3763,39 +4605,60 @@ async function work(tools, stop, parallel = 1) {
   const halt = new AbortController();
   const stopAll = AbortSignal.any([stop, halt.signal]);
   const running = /* @__PURE__ */ new Set();
+  const checks = /* @__PURE__ */ new Set();
   const folderLock = keyedLock();
+  const scheduleLock = keyedLock();
+  const runCheck = tools.version ? tools.runCheck : void 0;
   const reporting = reportCapabilities(tools, stopAll);
+  const checking = tools.inspectFolder ? checkFolders({ ...tools, inspect: tools.inspectFolder }, stopAll) : Promise.resolve();
+  if (tools.startFolder) {
+    await reportFoundFolders(tools, tools.startFolder);
+  }
   const start = (job) => {
     const runTools = jobTools(job, tools, parallel);
     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);
   };
+  const startCheck = (check, runner) => {
+    const task = scheduleLock.run(`schedule-${check.scheduleId}`, () => runCheckJob(check, runner, tools, stopAll)).catch((error) => tools.print(`The check stopped: ${messageOf3(error)}`)).finally(() => checks.delete(task));
+    checks.add(task);
+  };
+  let failures = 0;
   try {
     while (!stopAll.aborted) {
-      if (running.size >= parallel) {
-        await Promise.race(running);
+      const jobsFull = running.size >= parallel;
+      const checksFull = !runCheck || checks.size >= MAX_CHECKS;
+      if (jobsFull && checksFull) {
+        await Promise.race([...running, ...checks]);
         continue;
       }
-      let reply3;
+      const body = runCheck && tools.version ? { version: tools.version, jobs: !jobsFull, checks: !checksFull } : void 0;
+      let reply4;
       try {
-        reply3 = await tools.api.request("POST", NEXT_RUN_PATH);
+        reply4 = await withDeadline(tools.api.request("POST", NEXT_RUN_PATH, body, { safeToRepeat: true }), POLL_DEADLINE_MS, tools.sleep);
       } catch (error) {
         if (isFatal(error)) {
           halt.abort();
           throw error;
         }
-        tools.print(`Could not reach TAMsense: ${messageOf3(error)}. Trying again soon.`);
-        await tools.sleep(RETRY_AFTER_ERROR_MS, stopAll);
+        failures += 1;
+        if (failures === 1 && !alreadyReported(error)) {
+          tools.print(`Could not ask TAMsense for tasks: ${messageOf3(error)}. Trying again.`);
+        }
+        await tools.sleep(backoffMs(failures, POLL_INTERVAL_MS, MAX_RETRY_WAIT_MS), untilReconnect(tools.api, stopAll));
         continue;
       }
-      if (reply3.job) {
-        start(reply3.job);
+      failures = 0;
+      if (reply4.check && runCheck) {
+        startCheck(reply4.check, runCheck);
+      } else if (reply4.job) {
+        start(reply4.job);
       } else {
         await tools.sleep(POLL_INTERVAL_MS, stopAll);
       }
     }
   } finally {
-    await Promise.allSettled([...running, reporting]);
+    await Promise.allSettled([...running, ...checks, reporting, checking]);
   }
 }
 
@@ -3806,11 +4669,11 @@ var NO_TASKS_ACCESS_TEXT = "Your account no longer has access to Tasks. Ask the
 var ACCESS_PROBLEMS = { 401: DISCONNECTED_TEXT, 403: NO_TASKS_ACCESS_TEXT };
 var INTERRUPTED_EXIT_CODE = 130;
 function print(line) {
-  process5.stdout.write(`${line}
+  process7.stdout.write(`${line}
 `);
 }
 function serverFor(flag, saved) {
-  return serverOrigin(flag ?? process5.env.TAMSENSE_URL ?? saved?.server ?? DEFAULT_SERVER);
+  return serverOrigin(flag ?? process7.env.TAMSENSE_URL ?? saved?.server ?? DEFAULT_SERVER);
 }
 function accessProblem(error) {
   return error instanceof ApiError ? ACCESS_PROBLEMS[error.status] ?? null : null;
@@ -3832,19 +4695,19 @@ async function runLogin(server, deviceName) {
     { name, platform: platformLabel() }
   );
   await writeConfig({ server: api.server, token: result.token, deviceId: result.device.id, deviceName: result.device.name });
-  print(`Connected: ${result.device.name}. To take your tasks, run ${START_COMMAND}`);
+  print(`Connected: ${result.device.name}. To take your tasks, go to your code folder and run ${START_COMMAND}`);
 }
 function stopOnInterrupt() {
   const stop = new AbortController();
-  process5.once("SIGINT", () => {
+  process7.once("SIGINT", () => {
     print("Stopping\u2026 Press Ctrl+C again to quit at once.");
     stop.abort();
-    process5.once("SIGINT", () => process5.exit(INTERRUPTED_EXIT_CODE));
+    process7.once("SIGINT", () => process7.exit(INTERRUPTED_EXIT_CODE));
   });
   return stop.signal;
 }
 function installTools(home) {
-  return { home, nodePath: process5.execPath, env: process5.env, print, run: runProcess, exists: existsSync5 };
+  return { home, nodePath: process7.execPath, env: process7.env, print, run: runProcess, exists: existsSync8 };
 }
 async function browserForStart(home, install) {
   const installed = await installedBrowser(home);
@@ -3854,13 +4717,13 @@ async function browserForStart(home, install) {
   return ensureBrowser({ print, install: () => installBrowser(installTools(home)) });
 }
 async function startedNewVersion() {
-  const update = await updateToRun(process5.env, currentVersion(), () => latestVersion());
+  const update = await updateToRun(process7.env, currentVersion(), () => latestVersion());
   if (!update) {
     return false;
   }
   print(`TAMsense runner ${update.latest} is out, this is ${update.current}. Starting the new version...`);
   try {
-    process5.exitCode = await relaunch(process5.argv.slice(2), process5.env);
+    process7.exitCode = await relaunch(process7.argv.slice(2), process7.env);
     return true;
   } catch {
     print("Could not start the new version. Going on with this one.");
@@ -3876,16 +4739,16 @@ async function runStart(parallel, installsBrowser) {
     print(NOT_CONNECTED_TEXT);
     return;
   }
-  const api = createApi(saved.server, saved.token);
-  const identity = await api.request("GET", IDENTITY_PATH);
-  const problem = teamKeyProblem(identity.device.team, process5.env);
-  if (problem) {
-    throw new Error(problem);
+  const identity = await createApi(saved.server, saved.token).request("GET", IDENTITY_PATH);
+  const problem2 = teamKeyProblem(identity.device.team, process7.env);
+  if (problem2) {
+    throw new Error(problem2);
   }
   print(`${identity.device.name} is connected to ${saved.server} as ${describeDevice(identity)}.`);
   const home = homedir3();
   const browser = await browserForStart(home, installsBrowser);
-  await work({ api, runAgent: runClaude, capabilities: probeCapabilities, print, sleep, home, remoteUrl: githubRemoteUrl, browser, recorder: bundledRecorder() }, stopOnInterrupt(), parallel);
+  const api = createApi(saved.server, saved.token, { watch: connectionWatch(print) });
+  await work({ api, runAgent: runClaude, runCheck: runClaudeCheck, version: currentVersion() ?? void 0, capabilities: probeCapabilities, print, sleep, home, remoteUrl: githubRemoteUrl, browser, recorder: bundledRecorder(), inspectFolder: (path) => inspectFolder(path, home), startFolder: process7.cwd() }, stopOnInterrupt(), parallel);
 }
 async function runBrowser(remove) {
   const home = homedir3();
@@ -3937,10 +4800,10 @@ async function run(command) {
   }
 }
 try {
-  await run(parseCommand(process5.argv.slice(2), process5.env));
+  await run(parseCommand(process7.argv.slice(2), process7.env));
 } catch (error) {
-  process5.stderr.write(`${accessProblem(error) ?? (error instanceof Error ? error.message : String(error))}
+  process7.stderr.write(`${accessProblem(error) ?? (error instanceof Error ? error.message : String(error))}
 `);
-  process5.exitCode = 1;
+  process7.exitCode = 1;
 }
 //# sourceMappingURL=cli.js.map