@tamsensedev/runner 0.13.0 → 0.19.0

package/dist/cli.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { existsSync as existsSync8 } from "fs";
-import { homedir as homedir3 } from "os";
-import process7 from "process";
+import { homedir as homedir2 } from "os";
+import process8 from "process";
 
 // src/api.ts
 import { setTimeout as wait } from "timers/promises";
@@ -157,9 +157,9 @@ function textOf(value) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 async function errorOf(response) {
-  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}`;
+  const reply5 = await response.json().catch(() => ({}));
+  const code = textOf(reply5.data?.code);
+  const message = textOf(reply5.message) ?? textOf(reply5.statusMessage) ?? `TAMsense answered with status ${response.status}`;
   return new ApiError(response.status, code, message);
 }
 function isFailure(outcome) {
@@ -252,6 +252,7 @@ var START_COMMAND = "npx @tamsensedev/runner@latest start";
 var BROWSER_COMMAND = "npx @tamsensedev/runner@latest browser";
 var DEFAULT_PARALLEL = 2;
 var MAX_PARALLEL = 4;
+var PROFILE_NAME = /^[a-z0-9][\w-]{0,31}$/i;
 var HELP_TEXT = `Connects this computer to TAMsense so it can work on your tasks.
 
 Usage:
@@ -263,6 +264,12 @@ Usage:
   npx @tamsensedev/runner@latest status   show the connection
   npx @tamsensedev/runner@latest logout   disconnect this computer
 
+Profiles, for several projects or accounts on one computer:
+  -p, --profile <name>   use a separate connection with its own folders, for example:
+      ${LOGIN_COMMAND} -p client-a
+      ${START_COMMAND} -p client-a
+      Works with login, start, status and logout. Without it, the main connection is used.
+
 Login options:
   --name <name>    how this computer is called in TAMsense (default: its network name)
   --server <url>   TAMsense address (default: ${DEFAULT_SERVER})
@@ -270,6 +277,18 @@ Login options:
 Start options:
   --parallel <n>   how many tasks to work on at once, 1 to ${MAX_PARALLEL} (default: ${DEFAULT_PARALLEL}, or TAMSENSE_PARALLEL)
   --no-browser     do not install the headless browser for interface checks (start installs it when it is missing)`;
+function profileFor(flag) {
+  if (flag === void 0) {
+    return null;
+  }
+  if (!PROFILE_NAME.test(flag)) {
+    throw new Error(`The profile name may have letters, digits, - and _, up to 32 characters, got "${flag}".`);
+  }
+  return flag.toLowerCase();
+}
+function withProfile(command, profile) {
+  return profile === null ? command : `${command} -p ${profile}`;
+}
 function parallelFor(flag, env) {
   const [source, value] = flag !== void 0 ? ["--parallel", flag] : ["TAMSENSE_PARALLEL", env?.trim() || void 0];
   if (value === void 0) {
@@ -287,6 +306,8 @@ function parseCommand(argv, env = {}) {
     allowPositionals: true,
     strict: true,
     options: {
+      "profile": { type: "string", short: "p" },
+      "p": { type: "string" },
       "server": { type: "string" },
       "name": { type: "string" },
       "parallel": { type: "string" },
@@ -304,14 +325,15 @@ function parseCommand(argv, env = {}) {
   if (positionals.length !== 1) {
     return { name: "help" };
   }
+  const profile = profileFor(values.profile ?? values.p);
   if (name === "login") {
-    return { name: "login", server: values.server ?? null, deviceName: values.name ?? null };
+    return { name: "login", profile, server: values.server ?? null, deviceName: values.name ?? null };
   }
   if (name === "start") {
-    return { name: "start", parallel: parallelFor(values.parallel, env.TAMSENSE_PARALLEL), browser: !values["no-browser"] };
+    return { name: "start", profile, parallel: parallelFor(values.parallel, env.TAMSENSE_PARALLEL), browser: !values["no-browser"] };
   }
   if (name === "status" || name === "logout") {
-    return { name };
+    return { name, profile };
   }
   return { name: "help" };
 }
@@ -517,8 +539,8 @@ async function probeCapabilities(stop) {
 }
 
 // src/claude.ts
-import { createSdkMcpServer as createSdkMcpServer2, query as query3, tool as tool5 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z5 } from "zod";
+import { createSdkMcpServer as createSdkMcpServer2, query as query3, tool as tool7 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z7 } from "zod";
 
 // src/askPerson.ts
 var MAX_ASK_TRIES = 5;
@@ -578,21 +600,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(tool6, input) {
+function activityLine(tool8, input) {
   const fields = typeof input === "object" && input !== null ? input : {};
-  if (tool6 === "Bash" && typeof fields.command === "string") {
+  if (tool8 === "Bash" && typeof fields.command === "string") {
     return `$ ${shorten(fields.command)}`;
   }
-  if (FILE_TOOLS.has(tool6) && typeof fields.file_path === "string") {
-    return `${tool6} ${shorten(fields.file_path)}`;
+  if (FILE_TOOLS.has(tool8) && typeof fields.file_path === "string") {
+    return `${tool8} ${shorten(fields.file_path)}`;
   }
-  if (tool6 === "Skill" && typeof fields.skill === "string") {
+  if (tool8 === "Skill" && typeof fields.skill === "string") {
     return `Skill ${shorten(fields.skill)}`;
   }
-  if (HELPER_TOOLS.has(tool6) && typeof fields.subagent_type === "string") {
+  if (HELPER_TOOLS.has(tool8) && typeof fields.subagent_type === "string") {
     return `Agent ${shorten(fields.subagent_type)}`;
   }
-  return tool6;
+  return tool8;
 }
 function usageOf(modelUsage) {
   const entries = Object.values(modelUsage);
@@ -650,6 +672,12 @@ function recordingUploadPath(runId, upload, part) {
 function checkPath(checkId, action) {
   return `/api/runner/checks/${checkId}/${action}`;
 }
+function routinePath(checkId, action) {
+  return `/api/runner/checks/${checkId}/${action}`;
+}
+function sensePath(senseId, action) {
+  return `/api/runner/sense/${senseId}/${action}`;
+}
 
 // src/feed.ts
 var MAX_TEXT_LENGTH = 8e3;
@@ -670,31 +698,52 @@ function textField(fields, name) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 function toolDraft(block, parent) {
-  const tool6 = (block.name ?? "tool").replace(MCP_PREFIX, "");
+  const tool8 = (block.name ?? "tool").replace(MCP_PREFIX, "");
   const fields = fieldsOf(block.input);
-  const base = { tool: tool6, ref: block.id ?? null, parent, failed: false };
-  if (tool6 === "Skill" && textField(fields, "skill")) {
+  const base = { tool: tool8, ref: block.id ?? null, parent, failed: false };
+  if (tool8 === "Skill" && textField(fields, "skill")) {
     return { ...base, kind: "skill", text: clip(textField(fields, "skill"), MAX_SUMMARY_LENGTH) };
   }
-  if (HELPER_TOOLS2.has(tool6)) {
+  if (HELPER_TOOLS2.has(tool8)) {
     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 (tool6 === "submit_verdict") {
+  if (tool8 === "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 (tool6 === "hand_off") {
+  if (tool8 === "hand_off") {
     return { ...base, kind: "tool", text: clip(`Hand off to ${textField(fields, "to") ?? "?"}: ${textField(fields, "note") ?? ""}`, 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) };
+  if (tool8 in ATTACH_LABELS) {
+    return { ...base, kind: "tool", text: clip(`${ATTACH_LABELS[tool8]}: ${textField(fields, "title") ?? textField(fields, "path") ?? ""}`, MAX_SUMMARY_LENGTH) };
   }
   const command = textField(fields, "command");
-  const summary = tool6 === "Bash" && command ? `$ ${command}` : activityLine(tool6, block.input);
+  const summary = tool8 === "Bash" && command ? `$ ${command}` : activityLine(tool8, block.input);
   return { ...base, kind: "tool", text: clip(summary, MAX_SUMMARY_LENGTH) };
 }
+function sourceCalls(tools = []) {
+  return { tools: new Set(tools.map((tool8) => tool8.name)), refs: /* @__PURE__ */ new Set() };
+}
+function sourceCallDraft(block, draft) {
+  return { ...draft, text: clip(`${draft.tool} ${JSON.stringify(block.input ?? {})}`, MAX_TEXT_LENGTH) };
+}
+function fromSource(calls, block) {
+  return block.tool_use_id !== void 0 && calls.refs.has(block.tool_use_id);
+}
+function sourceSummary(text2) {
+  let reply5;
+  try {
+    reply5 = fieldsOf(JSON.parse(text2));
+  } catch {
+    return JSON.stringify({ ok: false });
+  }
+  if (reply5.ok === false) {
+    return JSON.stringify(reply5.refused === true ? { ok: false, refused: true, error: reply5.error } : { ok: false });
+  }
+  return JSON.stringify(typeof reply5.rowCount === "number" ? { ok: true, rowCount: reply5.rowCount } : { ok: true });
+}
 function resultText(content) {
   if (typeof content === "string") {
     return content;
@@ -708,7 +757,7 @@ function helperEndDraft(ref, parent, end, text2) {
   const stopped = end === "stopped";
   return { kind: "result", text: stopped ? "" : clip(text2, MAX_RESULT_LENGTH), tool: stopped ? HELPER_STOPPED : null, ref, parent, failed: end === "failed" };
 }
-function feedOf(message) {
+function feedOf(message, calls = sourceCalls()) {
   if (message.type !== "assistant" && message.type !== "user") {
     return [];
   }
@@ -724,9 +773,15 @@ function feedOf(message) {
     } else if (message.type === "assistant" && block.type === "text" && block.text?.trim()) {
       drafts.push({ kind: "text", text: clip(block.text, MAX_TEXT_LENGTH), tool: null, ref: null, parent, failed: false });
     } else if (message.type === "assistant" && block.type === "tool_use") {
-      drafts.push(toolDraft(block, parent));
+      const draft = toolDraft(block, parent);
+      const isSource = draft.tool !== null && calls.tools.has(draft.tool);
+      if (isSource && block.id) {
+        calls.refs.add(block.id);
+      }
+      drafts.push(isSource ? sourceCallDraft(block, draft) : draft);
     } else if (message.type === "user" && block.type === "tool_result") {
-      drafts.push({ kind: "result", text: clip(resultText(block.content), MAX_RESULT_LENGTH), tool: null, ref: block.tool_use_id ?? null, parent, failed: block.is_error === true });
+      const text2 = resultText(block.content);
+      drafts.push({ kind: "result", text: clip(fromSource(calls, block) ? sourceSummary(text2) : text2, MAX_RESULT_LENGTH), tool: null, ref: block.tool_use_id ?? null, parent, failed: block.is_error === true });
     }
   }
   return drafts;
@@ -1231,8 +1286,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 reply4 = first;
-  while (reply4.decision === "wait") {
+  let reply5 = first;
+  while (reply5.decision === "wait") {
     await tools.sleep(CHECK_INTERVAL_MS, signal);
     if (signal.aborted) {
       return STOPPED_TEXT2;
@@ -1240,9 +1295,9 @@ async function decisionOf(tools, first, signal) {
     if (now() > giveUpAt) {
       return SITE_SILENT_TEXT;
     }
-    reply4 = await tools.check(reply4.id).catch(() => reply4);
+    reply5 = await tools.check(reply5.id).catch(() => reply5);
   }
-  return reply4;
+  return reply5;
 }
 function askPermission(tools, lastWords, folder) {
   return async (toolName, input, options) => {
@@ -1263,11 +1318,11 @@ 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 reply4 = await decisionOf(tools, first, options.signal);
-    if (typeof reply4 === "string") {
-      return deny(reply4);
+    const reply5 = await decisionOf(tools, first, options.signal);
+    if (typeof reply5 === "string") {
+      return deny(reply5);
     }
-    return reply4.decision === "allow" ? { behavior: "allow", updatedInput: input } : deny(reply4.message);
+    return reply5.decision === "allow" ? { behavior: "allow", updatedInput: input } : deny(reply5.message);
   };
 }
 var denyWhenAsked = async () => deny(NOBODY_TO_ASK);
@@ -1447,7 +1502,7 @@ async function checkFolders(tools, stop) {
   }
 }
 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.";
+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 Settings, under your computer on the Account tab.";
 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();
@@ -1515,13 +1570,14 @@ function keyedLock() {
 import { existsSync as existsSync3 } from "fs";
 import { rm as rm2 } from "fs/promises";
 import { join as join3, resolve as resolve2 } from "path";
+var RESULTS_FOLDER = "results";
 var FALLBACK_IDENTITY = { name: "TAMsense", email: "noreply@tamsense.com" };
 var cacheLock = keyedLock();
 function githubRemoteUrl(fullName) {
   return `https://github.com/${fullName}.git`;
 }
-function tamsenseFolder(home, ...parts) {
-  return join3(home, ".tamsense", ...parts);
+function tamsenseFolder(dataFolder, ...parts) {
+  return join3(dataFolder, ...parts);
 }
 function folderNames(repositories) {
   const shortName = (fullName) => fullName.split("/").pop() ?? fullName;
@@ -1529,7 +1585,10 @@ function folderNames(repositories) {
   for (const repository of repositories) {
     counts.set(shortName(repository.fullName), (counts.get(shortName(repository.fullName)) ?? 0) + 1);
   }
-  return repositories.map((repository) => counts.get(shortName(repository.fullName)) === 1 ? shortName(repository.fullName) : repository.fullName.replace("/", "__"));
+  return repositories.map((repository) => {
+    const name = shortName(repository.fullName);
+    return counts.get(name) === 1 && name !== RESULTS_FOLDER ? name : repository.fullName.replace("/", "__");
+  });
 }
 async function refreshCache(cache, repository, token, tools) {
   if (existsSync3(join3(cache, ".git"))) {
@@ -1582,15 +1641,15 @@ async function keptBase(cache, path, job, repository) {
   }
   return git(["rev-parse", await baseRef(cache, job, repository)], { cwd: cache });
 }
-function taskFolder(home, job) {
-  return tamsenseFolder(home, "work", ...stepFolder(job));
+function taskFolder(dataFolder, job) {
+  return tamsenseFolder(dataFolder, "work", ...stepFolder(job));
 }
 async function prepareWorkspace(job, token, tools) {
-  const root = taskFolder(tools.home, job);
+  const root = taskFolder(tools.dataFolder, 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 cache = tamsenseFolder(tools.dataFolder, "repos", repository.fullName.replace("/", "__"));
     const folder = folders[index] ?? repository.fullName;
     const path = join3(root, folder);
     const baseSha = await cacheLock.run(repository.fullName, async () => {
@@ -1686,7 +1745,7 @@ async function baseBranchRef(source, branch, remote) {
   }
   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.`);
+    throw new Error(`The main branch ${branch} is not in ${source}. Check the folder again in Settings, under your computer on the Account tab.`);
   }
   return found;
 }
@@ -1699,15 +1758,15 @@ async function taskBranchRef(source, branch, remote, base) {
 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)) {
+  if (task || !isReadOnlyCheck(job) || job.severalBranches) {
     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) {
+async function releaseBranch2(source, branch, keep, dataFolder) {
   const listed = await runGit(["worktree", "list", "--porcelain"], { cwd: source });
-  const work2 = tamsenseFolder(home, "work");
+  const work2 = tamsenseFolder(dataFolder, "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.`);
@@ -1734,7 +1793,7 @@ function sourceOf(repository) {
 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.`);
+    throw new Error(`${source} is no longer a git repository on this computer. Check the folder again in Settings, under your computer on the Account tab.`);
   }
   const local = { source, remote: await remoteOf(source), baseBranch: repository.defaultBranch };
   if (local.remote) {
@@ -1752,13 +1811,13 @@ async function prepareRepository(job, repository, path, tools) {
   if (readsOnly(job)) {
     await git(["worktree", "add", "--detach", path, start], { cwd: source });
   } else {
-    await releaseBranch2(source, job.branch, path, tools.home);
+    await releaseBranch2(source, job.branch, path, tools.dataFolder);
     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 root = taskFolder(tools.dataFolder, job);
   const folders = folderNames(job.repositories);
   const repositories = [];
   for (const [index, repository] of job.repositories.entries()) {
@@ -1793,8 +1852,8 @@ async function commitAndPush(repository, local, job, identity) {
   }
   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 };
+  const sent3 = await pushBranch(repository.path, local, job.branch);
+  return { sha: await git(["rev-parse", "HEAD"], options), commits, ...sent3 };
 }
 async function publishLocalWorkspace(workspace, job, identity) {
   const pushed = [];
@@ -1830,7 +1889,6 @@ 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",
@@ -1997,11 +2055,11 @@ function resultToolset(tools) {
 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.`,
+    `Create a linked task on a board of the project, this board included: when part of the work belongs to another board, or when the work goes on as a new task here, such as the next wave after this one. Boards you may create tasks on: ${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"),
+      title: z2.string().describe("title of the new task, one plain sentence"),
+      note: z2.string().describe("what you found and what the new task 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))
@@ -2011,65 +2069,214 @@ function handOverTool(tools) {
 // 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 { createSdkMcpServer, query as query2, tool as tool5 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z5 } from "zod";
+
+// src/routines.ts
+import { tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
 import { z as z3 } from "zod";
+var FINISH_ROUTINE_TOOL_NAME = "finish_routine";
+var RULES = [
+  "You run one run of a TAMsense routine on the user's own computer: a job that repeats on a schedule. Nobody answers during the run: decide yourself.",
+  "This is the person's own computer, and their other programs may be running on it. Stop only the processes you started yourself, by their process id, and stop them before you finish. Never kill processes by name or pattern and never touch programs you did not start.",
+  "One problem is one report_problem call. Use the same key for the same problem on every run, and pass the number of an open task of this routine as sameAs when it is the same problem.",
+  `Finish by calling ${FINISH_ROUTINE_TOOL_NAME} exactly once, after every problem is reported.`,
+  "Write in the language of the job. No em dashes and no en dashes."
+];
+function reply2(text2) {
+  return { content: [{ type: "text", text: text2 }] };
+}
+var KEY_FIELD = z3.string().describe('a short stable name of this problem, the same on every run, like "buyout-4812-card-declined"');
+async function sent2(tools, body) {
+  try {
+    return reply2((await tools.call(body)).text);
+  } catch (error) {
+    return { ...reply2(`Could not reach TAMsense: ${error instanceof Error ? error.message : String(error)}. Say so in your summary.`), isError: true };
+  }
+}
+function routineToolset(tools, onFinish) {
+  const problem2 = tool3("report_problem", "Hand one problem you do not fix to people: a task on the board of the routine, an addition to the open task of the same problem, or a line in the report.", {
+    title: z3.string().describe("one plain sentence: what is wrong"),
+    detail: z3.string().describe("the facts people need to act; never personal data of clients"),
+    key: KEY_FIELD,
+    sameAs: z3.number().int().nullable().describe("the number of an open task of this routine about the same problem, or null")
+  }, async (args) => await sent2(tools, { tool: "problem", input: args }));
+  const ask = tool3("ask_person", "Ask the person of this routine what to do with one thing you cannot decide. Do not wait for the answer: the next run reads it.", {
+    question: z3.string(),
+    context: z3.string().describe("the facts they need to answer without opening anything"),
+    key: KEY_FIELD,
+    options: z3.array(z3.string()).max(4).describe("up to four answers you suggest")
+  }, async (args) => await sent2(tools, { tool: "ask", input: args }));
+  const fixed = tool3("report_fixed", "Write down one fix you made in this run: what you changed and why.", {
+    title: z3.string().describe('what you did, like "Cancelled buyout #4815 on Wildberries"'),
+    detail: z3.string().describe("why, with the facts"),
+    key: KEY_FIELD
+  }, async (args) => await sent2(tools, { tool: "fixed", input: args }));
+  const report = tool3("save_report", "Save the report of this run on TAMsense: a Markdown document or a CSV table with a header row.", {
+    kind: z3.enum(["document", "table"]),
+    title: z3.string(),
+    content: z3.string().describe("the full Markdown text, or the full CSV")
+  }, async (args) => await sent2(tools, { tool: "report", input: args }));
+  const finish2 = tool3(FINISH_ROUTINE_TOOL_NAME, "Finish this run. Call it exactly once, at the very end.", {
+    summary: z3.string().describe("one line with the numbers that matter"),
+    fine: z3.number().int().min(0).describe("how many things you checked and found in order"),
+    fineNote: z3.string().describe("what those are, in a few words")
+  }, async (args) => {
+    await sent2(tools, { tool: "fine", input: { count: args.fine, note: args.fineNote } });
+    onFinish({ changed: false, summary: args.summary.trim(), note: null, conditionMet: false, callPerson: false });
+    return reply2("Run finished. You can stop now.");
+  });
+  return [problem2, ...tools.asks ? [ask] : [], ...tools.canFix ? [fixed] : [], report, finish2];
+}
+function noteLine(note) {
+  return `- ${note.at.slice(0, 16).replace("T", " ")}: ${note.summary}`;
+}
+function buildRoutinePrompt(job, folder) {
+  const earlier = job.earlier.length > 0 ? `Earlier runs, the newest last:
+${job.earlier.map(noteLine).join("\n")}` : null;
+  return {
+    prompt: [job.instruction, earlier].filter(Boolean).join("\n\n"),
+    instructions: [RULES.join("\n"), workplaceText(job.computer, folder), job.sourcesText, job.safetyRules.trim() || null].filter(Boolean).join("\n\n")
+  };
+}
+function routineRunTools(job, api, print2, sleep2) {
+  const routine = job.routine;
+  if (!routine) {
+    return null;
+  }
+  const permissions = routine.canFix && !routine.dry ? {
+    send: async (body) => {
+      const answer = await api.request("POST", routinePath(job.checkId, "permissions"), body);
+      if (answer.decision === "wait") {
+        print2(`  Waiting for a person on TAMsense to allow: ${body.title || body.action}`);
+      }
+      return answer;
+    },
+    check: (id) => api.request("GET", routinePath(job.checkId, `permissions/${id}`)),
+    sleep: sleep2
+  } : null;
+  return {
+    call: (body) => api.request("POST", routinePath(job.checkId, "routine"), body),
+    permissions,
+    asks: routine.asks,
+    canFix: routine.canFix
+  };
+}
+
+// src/sources.ts
+import { tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z4 } from "zod";
+function sourceTools(tools, api, path) {
+  return tools && tools.length > 0 ? { tools, call: (body) => api.request("POST", path, body) } : null;
+}
+function fieldSchema(field) {
+  const value = field.type === "integer" ? z4.number().int().positive() : z4.string();
+  return (field.required ? value : value.optional()).describe(field.description);
+}
+function inputShape(fields) {
+  return Object.fromEntries(fields.map((field) => [field.name, fieldSchema(field)]));
+}
+function replyOf(answer) {
+  return { content: [{ type: "text", text: JSON.stringify(answer) }], ...answer.ok ? {} : { isError: true } };
+}
+function sourceToolset(sources) {
+  if (!sources) {
+    return [];
+  }
+  return sources.tools.map((info) => tool4(
+    info.name,
+    info.description,
+    inputShape(info.fields),
+    async (input) => {
+      try {
+        return replyOf(await sources.call({ tool: info.name, input }));
+      } catch (error) {
+        return replyOf({ ok: false, error: `Could not read project data: ${error instanceof Error ? error.message : String(error)}` });
+      }
+    }
+  ));
+}
+
+// src/schedules.ts
 var PROPOSE_SCHEDULE_TOOL_NAME = "propose_schedule";
 var REPORT_CHECK_TOOL_NAME = "report_check";
+var WAKE_TOOL_NAME = "wake_up_later";
 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) {
+function reply3(text2, isError = false) {
   return { content: [{ type: "text", text: text2 }], ...isError ? { isError: true } : {} };
 }
 function proposeScheduleTool(tools, waiting) {
-  return tool3(
+  return tool5(
     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")
+      title: z5.string().describe('a short name, at most 80 characters: "Wait for the local stand"'),
+      instruction: z5.string().describe("what each run does, in plain words, as a note to yourself: what to look at and what counts as new"),
+      everyMinutes: z5.number().int().nullable().describe("repeat every N minutes (60 for every hour); null when dailyAt is set"),
+      dailyAt: z5.string().nullable().describe("repeat every day at this time, HH:MM in the project time zone; null when everyMinutes is set"),
+      days: z5.array(z5.number().int().min(0).max(6)).describe("with dailyAt: days of the week, 0 is Sunday; empty means every day"),
+      until: z5.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: z5.number().int().nullable().describe("how long it runs at most, in minutes; null takes the longest the project allows"),
+      maxRuns: z5.number().int().nullable().describe("the number of runs at most, or null"),
+      where: z5.enum(["computer", "cloud"]).describe("computer: this computer, free, skipped while it sleeps; cloud: any time, for credits"),
+      callWhen: z5.string().describe('when to call a person, in plain words: "a container keeps restarting"'),
+      callOnTimeout: z5.boolean().describe("true: call a person when the condition did not come in time"),
+      keepAfterStep: z5.boolean().describe("true only when it must keep running after the task leaves this step"),
+      wait: z5.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);
+        return reply3(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);
+        return reply3(`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);
+        return reply3(answer.text, true);
       }
       if (answer.waits) {
         waiting.waitingForSchedule = answer.id;
       }
-      return reply2(answer.text);
+      return reply3(answer.text);
     }
   );
 }
-function scheduleTools(api, path) {
-  return { send: (body) => api.request("POST", path, body) };
+function scheduleTools(api, path, wakePath) {
+  return {
+    send: (body) => api.request("POST", path, body),
+    wake: (body) => api.request("POST", wakePath, body)
+  };
+}
+function wakeUpLaterTool(tools) {
+  return tool5(
+    WAKE_TOOL_NAME,
+    "Put the task to sleep and wake it up later, once: for example 7 days after a mailing to collect its results, or 3 days after a follow-up. Nothing runs and nothing is charged while it sleeps. On waking the task moves to the step you name, along a rule of the board (a rule that only a person moves waits for that person), or this step starts again when you name none. A person moving the task meanwhile cancels the wake-up. Finish your run right after you set it.",
+    {
+      inHours: z5.number().min(0.1).max(2160).describe("how many hours from now, for example 168 for 7 days"),
+      step: z5.string().describe("the name of the step to wake up on, empty to start this step again"),
+      note: z5.string().describe("what to do on waking, in plain words")
+    },
+    async (args) => {
+      try {
+        return reply3((await tools.wake({ inHours: args.inHours, step: args.step.trim(), note: args.note.trim() })).text);
+      } catch (error) {
+        return reply3(`Could not set the wake-up: ${error instanceof Error ? error.message : String(error)}. Say in your report when the task should continue.`, true);
+      }
+    }
+  );
 }
-async function checkFolder(home, job) {
+async function checkFolder(dataFolder, job) {
   if (job.taskId !== null) {
-    const step = taskFolder(home, { taskId: job.taskId, stage: { columnId: job.stepColumnId } });
+    const step = taskFolder(dataFolder, { taskId: job.taskId, stage: { columnId: job.stepColumnId } });
     if (existsSync5(step)) {
       return step;
     }
   }
-  const own = tamsenseFolder(home, "schedules", `schedule-${job.scheduleId}`);
+  const own = tamsenseFolder(dataFolder, "schedules", `schedule-${job.scheduleId}`);
   await mkdir3(own, { recursive: true });
   return own;
 }
@@ -2081,7 +2288,7 @@ var CHECK_RULES = [
   `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) {
+function noteLine2(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;
@@ -2094,43 +2301,56 @@ ${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."
+${job.earlier.map(noteLine2).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.sourcesText,
     job.safetyRules.trim() || null
   ].filter(Boolean).join("\n\n");
   return { prompt, instructions };
 }
 var SERVER_NAME = "tamsense";
 var MAX_CHECK_TURNS = 30;
+var MAX_ROUTINE_TURNS = 120;
 function reportCheckTool(onReport) {
-  return tool3(
+  return tool5(
     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")
+      changed: z5.boolean().describe("true when something changed since the earlier runs"),
+      summary: z5.string().describe("one short line for the task chat: what you saw"),
+      note: z5.string().nullable().describe("when something changed: the full facts, the exact lines and what they mean; null otherwise"),
+      conditionMet: z5.boolean().describe("true when the condition of the schedule came"),
+      callPerson: z5.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.");
+      return reply3("Result received. You can stop now.");
     }
   );
 }
+function textOf2(message) {
+  if (message.type !== "assistant") {
+    return null;
+  }
+  const text2 = message.message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n").trim();
+  return text2 || null;
+}
 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 found = (input) => {
+      result = input;
+    };
+    const own = request.routine ? routineToolset(request.routine, found) : [reportCheckTool(found)];
+    const tools = [...own, ...sourceToolset(request.sources)];
+    const lastWords = { text: "" };
+    const permissions = request.routine?.permissions ?? null;
     const messages = startQuery({
       prompt: request.prompt.prompt,
       options: {
@@ -2138,10 +2358,10 @@ function claudeCheckRunner(startQuery) {
         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,
+        canUseTool: permissions ? askPermission(permissions, () => lastWords.text, request.cwd) : denyWhenAsked,
+        mcpServers: { [SERVER_NAME]: createSdkMcpServer({ name: SERVER_NAME, version: "1.0.0", tools }) },
+        allowedTools: tools.map((item) => `mcp__${SERVER_NAME}__${item.name}`),
+        maxTurns: request.routine ? MAX_ROUTINE_TURNS : MAX_CHECK_TURNS,
         abortController,
         env: request.env,
         ...request.model === null ? {} : { model: request.model }
@@ -2149,6 +2369,7 @@ function claudeCheckRunner(startQuery) {
     });
     let outcome = { completed: false, report: "Claude finished without a result.", model: null, usage: null, result: null };
     for await (const message of messages) {
+      lastWords.text = textOf2(message) ?? lastWords.text;
       if (message.type === "result") {
         const finished = outcomeOf(message, "");
         outcome = { completed: finished.completed, report: finished.report, model: finished.model, usage: finished.usage, result: null };
@@ -2322,7 +2543,7 @@ var SCREENSHOT_RULE = `If you render screens (screenshots of the interface), att
 var NAMING_RULE = 'Name everything you attach (screenshots, replays, videos) by what it shows and why it was made: a short title such as "Design option 1", "Feature testing" or "Feature testing, attempt 2", and a one-line purpose such as "Comparing two layouts for the empty orders state". Number design variants, name test runs by their goal and attempt, and never use generic names like "screenshot1".';
 var RECORDING_RULE = `Every browser you open with Playwright from Node is recorded for the task as a replay people can watch, requests from the tested site to the TAMsense tracker are blocked, so your runs never reach analytics, and requests other than GET, HEAD and OPTIONS to addresses outside this computer are aborted. In every browser script, load the recorder from the TAMSENSE_RECORDER environment variable (require(process.env.TAMSENSE_RECORDER), or createRequire(import.meta.url)(process.env.TAMSENSE_RECORDER) in an .mjs script), open each context with await recorder.newRecordedContext(browser, { title, purpose, context: { viewport } }), call await recorder.mark(page, 'what just happened') at every meaningful step, and end with await recorder.closeRecorded(context, { 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 FOLDER_RULE = "This run has no repositories. The current folder belongs to this task: work in it and keep your throwaway files here.";
 var RESULT_HOME_RULE = "The result lives only on the TAMsense task: never save it in outside services such as Google Drive or a shared folder. Use connected services only to read. Sending anything to real people, such as an email or a message, is an action that needs approval like any other.";
 var FOLDER_DO_RULES = [
   `Save what you make on the task with the TAMsense tools: ${SAVE_DOCUMENT_TOOL_NAME} for text in Markdown, ${SAVE_TABLE_TOOL_NAME} for rows of data as CSV, ${ATTACH_FILE_TOOL_NAME} for files you made in this folder, ${ADD_LINK_TOOL_NAME} for pages the result relies on. Keep one title per document and save every change as a new version of it.`,
@@ -2382,7 +2603,7 @@ var SPEC_RULES = [
 var SPEC_WORK_MISSING = "TAMsense sent a spec step without its round and brief.";
 var BRIEF_UNATTENDED_RULE = `You are preparing a TAMsense task on the user's own computer. Nobody answers you during this run: the owner answers your questions and reviews the brief on the task page after it. So never stop to wait for a reply and never ask in your messages: hand in what this stage asks for with the TAMsense tool, then finish. People on the task may send you messages during this run, each starting with "Message from <name>:". Follow them.`;
 var BRIEF_RESEARCH_RULE = "Research before asking: read what the task, the project knowledge, the files in this folder and the connected services give you. Finding facts is your job; the decisions about intent are the owner's.";
-var RESEARCH_BRIEF_RULE = "Write the research brief as you go: findings (what the sources say that matters, each with where: the source), dataFacts (numbers and facts, each with its source; empty when none), approach (2 to 4 sentences), codeMap (always empty: this board has no code), assumptions (each corner you settled with a default, with the reason) and pendingDecisions (decisions that depend on an answer to this round; empty when none).";
+var RESEARCH_BRIEF_RULE = "Write the research brief as you go: findings (what the sources say that matters, each with where: the source), dataFacts (numbers and facts, each with its source; empty when none), approach (2 to 4 sentences), codeMap (always empty: this task has no repositories), assumptions (each corner you settled with a default, with the reason) and pendingDecisions (decisions that depend on an answer to this round; empty when none).";
 var RESULT_BRIEF_RULES = [
   'Write the brief of the result: goal, context (the summary), contains (what the result must contain), acceptance (criteria with ids AC-1, AC-2 and so on in order, each one observable property a checker confirms by reading the result), constraints, outOfScope, sources (where the facts come from: knowledge, linked items, files of the task, connected services that are read only), approver (who approves the result), decisions, assumptions and openQuestions. Set format to "brief". Never write a code map, files to touch or repositories.',
   'Start from the research brief and the conversation below. Apply the answers: an answer the owner gave is a decision with by: owner; an answer marked "Recommended option applied, not answered" is an assumption with the reason "not answered, the recommended option applies".',
@@ -2450,12 +2671,17 @@ function folderText(root, results) {
   return lines.length > 0 ? `The task folder is ${root}. The results of the task so far, latest versions:
 ${bulletList(lines)}` : `The task folder is ${root}. The task has no result yet.`;
 }
+function taskResultsText(results) {
+  const lines = results ?? [];
+  return lines.length > 0 ? `The task already has these documents and results, latest versions, in the ${RESULTS_FOLDER} folder next to the repositories. Read what concerns this step before you start:
+${bulletList(lines)}` : null;
+}
 function handOverText(boards) {
   const names = (boards ?? []).map((board) => board.name);
   if (names.length === 0) {
     return null;
   }
-  return `When part of the work belongs to another board, hand it over with the ${HAND_OVER_TOOL_NAME} tool: ${names.join(", ")}. Write a plain title and a note on what you found and what that board should do; never put names, emails or other personal data of clients in the note. With wait true this task waits on its step until the linked task is done, then it goes on and you get its result note.`;
+  return `When part of the work belongs to another board, or the work goes on as a new task, such as the next wave, create a linked task with the ${HAND_OVER_TOOL_NAME} tool on: ${names.join(", ")}. Write a plain title and a note on what you found and what the new task should do; never put names, emails or other personal data of clients in the note. With wait true this task waits on its step until the linked task is done, then it goes on and you get its result note.`;
 }
 function handoffText(targets, isCheck) {
   if (targets.length === 0) {
@@ -2531,7 +2757,7 @@ function briefGoal(job, work2) {
   }
   return work2.round > 1 ? `Follow-up questions for TAMsense task #${job.taskId}: ${job.title}` : `Prepare TAMsense task #${job.taskId} for its brief: ${job.title}`;
 }
-function buildBriefPrompt(job, work2, workspace) {
+function buildBriefPrompt(job, work2, workspace, options) {
   const prompt = [
     briefGoal(job, work2),
     job.description,
@@ -2550,8 +2776,9 @@ ${JSON.stringify(job.spec)}` : null,
     workplaceText(job.computer, workspace.root),
     stepLine(job.stage),
     job.stage.instructions,
+    job.sourcesText,
     contextText(job.projectContext),
-    FOLDER_RULE,
+    `${FOLDER_RULE} ${folderText(workspace.root, options.results)}`,
     RESULT_HOME_RULE,
     `How to work:
 ${bulletList(work2.round === null ? RESULT_BRIEF_RULES : briefQuestionRules(work2))}`,
@@ -2561,7 +2788,7 @@ ${bulletList(work2.round === null ? RESULT_BRIEF_RULES : briefQuestionRules(work
   ].filter(Boolean).join("\n\n");
   return { prompt, instructions };
 }
-function buildSpecPrompt(job, work2, workspace) {
+function buildSpecPrompt(job, work2, workspace, options) {
   const prompt = [
     specGoal(job, work2),
     job.description,
@@ -2580,10 +2807,12 @@ ${JSON.stringify(job.spec)}` : null,
     workplaceText(job.computer, workspace.root),
     stepLine(job.stage),
     job.stage.instructions,
+    job.sourcesText,
     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,
+    taskResultsText(options.results),
     READ_ONLY_RULE,
     `How to work:
 ${bulletList(work2.round === null ? SPEC_RULES : questionRules(work2))}`,
@@ -2620,6 +2849,7 @@ ${job.review}`,
     workplaceText(job.computer, workspace.root),
     stepLine(job.stage),
     job.stage.instructions,
+    job.sourcesText,
     contextText(job.projectContext),
     `${FOLDER_RULE} ${folderText(workspace.root, options.results)}`,
     `How to work:
@@ -2641,7 +2871,7 @@ function buildTaskPrompt(job, workspace, options = {}) {
     if (!job.specWork) {
       throw new Error(SPEC_WORK_MISSING);
     }
-    return isFolderJob(job) ? buildBriefPrompt(job, job.specWork, workspace) : buildSpecPrompt(job, job.specWork, workspace);
+    return isFolderJob(job) ? buildBriefPrompt(job, job.specWork, workspace, options) : buildSpecPrompt(job, job.specWork, workspace, options);
   }
   if (isFolderJob(job)) {
     return buildFolderPrompt(job, workspace, options);
@@ -2669,10 +2899,12 @@ ${job.review}`,
     workplaceText(job.computer, workspace.root),
     stepLine(job.stage),
     job.stage.instructions,
+    job.sourcesText,
     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,
+    taskResultsText(options.results),
     `How to work:
 ${bulletList(rules)}`,
     safetyText(job),
@@ -2687,135 +2919,135 @@ ${bulletList(rules)}`,
 }
 
 // src/specTools.ts
-import { tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z4 } from "zod";
+import { tool as tool6 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z6 } from "zod";
 var MAX_FIRST_ROUND = 4;
-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")
+var questionSchema = z6.object({
+  id: z6.string().describe('Stable snake_case id, unique in the task, for example "empty_state"'),
+  question: z6.string().describe("One plain sentence the owner can answer without reading code"),
+  whyItMatters: z6.string().describe("One line: what changes in the result depending on the answer"),
+  options: z6.array(z6.object({
+    label: z6.string().describe('Short, concrete answer (1-6 words), without "(Recommended)": use the recommended flag'),
+    description: z6.string().describe("One sentence: what happens if this option is chosen"),
+    recommended: z6.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: z4.boolean().describe("true only when the options are additive and several can apply together")
+  multiSelect: z6.boolean().describe("true only when the options are additive and several can apply together")
 });
-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")
+var briefSchema = z6.object({
+  findings: z6.array(z6.object({
+    fact: z6.string().describe("What the code does today that matters for this task"),
+    where: z6.string().describe("Where it is: owner/repo path:line")
   })).describe("Findings from the code"),
-  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")
+  dataFacts: z6.array(z6.string()).describe("Numbers and facts from the events or the business data, each with its source. Empty when the task needs no data"),
+  approach: z6.string().describe("The approach you would take, in 2-4 sentences"),
+  codeMap: z6.array(z6.object({
+    repo: z6.string().describe("Repository full name (owner/name)"),
+    file: z6.string().describe("Path relative to the repository root"),
+    role: z6.string().describe("Why it matters: what to change or reuse there")
   })).describe("The files the change will touch or must reuse"),
-  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")
+  assumptions: z6.array(z6.object({
+    text: z6.string().describe("The default you chose"),
+    reason: z6.string().describe("Why it is safe or why it was chosen")
   })).describe("Corners settled with a default instead of a question"),
-  pendingDecisions: z4.array(z4.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
+  pendingDecisions: z6.array(z6.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
 });
-var questionsPayloadSchema = z4.object({
+var questionsPayloadSchema = z6.object({
   brief: briefSchema,
-  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`)
+  questions: z6.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 = 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")
+var specSchema = z6.object({
+  goal: z6.string().describe("The problem solved, for whom, and the outcome a user or the business will notice"),
+  context: z6.string().describe("Summary: the problem in 1-2 sentences, then the chosen approach in 1-2 sentences"),
+  inScope: z6.array(z6.string()).describe("What this task delivers, one item each"),
+  outOfScope: z6.array(z6.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: z6.array(z6.object({
+    question: z6.string(),
+    answer: z6.string(),
+    by: z6.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: 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")
+  codeMap: z6.array(z6.object({
+    repo: z6.string().describe("Repository full name (owner/name)"),
+    file: z6.string().describe("Path relative to the repository root"),
+    role: z6.string().describe("What the coder needs to know about this file"),
+    use: z6.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: 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")
+  changes: z6.array(z6.object({
+    repo: z6.string().describe("Repository full name (owner/name) where the change happens"),
+    file: z6.string().describe("Path to the file, relative to the repository root"),
+    action: z6.enum(["create", "modify", "delete"]),
+    description: z6.string().describe("The behaviour the file has after the change and which existing functions or patterns to extend. No code snippets or diffs"),
+    produces: z6.array(z6.string()).describe("Names with signatures or data shapes this change creates or changes for other changes. Empty when none"),
+    consumes: z6.array(z6.string()).describe("Names with signatures or data shapes this change uses from earlier changes. Empty when none"),
+    acceptance: z6.array(z6.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: 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')
+  acceptance: z6.array(z6.object({
+    id: z6.string().describe("AC-1, AC-2 and so on, in order"),
+    kind: z6.enum(["main", "edge", "keep"]).describe("main: the main path; edge: an error, empty or limit case; keep: existing behaviour that must keep working"),
+    text: z6.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: 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")
+  testPlan: z6.object({
+    automated: z6.array(z6.object({
+      repo: z6.string(),
+      command: z6.string().describe("The exact command to run"),
+      expect: z6.string().describe("What passing looks like")
     })).describe("At least one command"),
-    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")
+    newTests: z6.array(z6.object({
+      seam: z6.string().describe("Where the test goes: the highest seam that covers the behaviour (an endpoint, a page, a public function)"),
+      covers: z6.array(z6.string()).describe("Ids of the criteria it covers")
     })),
-    manual: z4.array(z4.object({
-      page: z4.string().describe("The page or screen"),
-      steps: z4.string().describe("What a person does and sees")
+    manual: z6.array(z6.object({
+      page: z6.string().describe("The page or screen"),
+      steps: z6.string().describe("What a person does and sees")
     }))
   }),
-  risks: z4.array(z4.object({
-    risk: z4.string(),
-    mitigation: z4.string()
+  risks: z6.array(z6.object({
+    risk: z6.string(),
+    mitigation: z6.string()
   })).describe("What could go wrong: migrations, existing data, access, performance, compatibility"),
-  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")
+  riskLevel: z6.enum(["low", "medium", "high"]).describe("How closely a person should review the result"),
+  assumptions: z6.array(z6.object({
+    text: z6.string().describe("The default you chose"),
+    reason: z6.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: 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")
+  openQuestions: z6.array(questionSchema).describe("Questions only the owner can settle; the spec cannot be approved until each is answered or dismissed. Empty when none"),
+  split: z6.array(z6.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 = 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")
+var resultBriefSchema = z6.object({
+  format: z6.literal("brief").describe('Always "brief"'),
+  goal: z6.string().describe("What the work is for, for whom, and the outcome people will notice"),
+  context: z6.string().describe("Summary: the situation in 1-2 sentences, then how the work will be done in 1-2 sentences"),
+  contains: z6.array(z6.string()).min(1).describe("What the result must contain, one item each: the parts, facts and attachments a reader expects"),
+  acceptance: z6.array(z6.object({
+    id: z6.string().describe("AC-1, AC-2 and so on, in order"),
+    text: z6.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: 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")
+  constraints: z6.array(z6.string()).describe("Rules the result must keep: length, tone, language, deadlines, what must not be promised. Empty when none"),
+  outOfScope: z6.array(z6.string()).describe("What this work does not do: nearby things someone might be tempted to add. Empty when nothing is tempting"),
+  sources: z6.array(z6.object({
+    source: z6.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: z6.string().describe("What to take from it")
   })).describe("Sources the work must use. Empty when the task itself is enough"),
-  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")
+  approver: z6.string().describe("Who approves the result, as the task or the board names them"),
+  decisions: z6.array(z6.object({
+    question: z6.string(),
+    answer: z6.string(),
+    by: z6.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: 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")
+  assumptions: z6.array(z6.object({
+    text: z6.string().describe("The default you chose"),
+    reason: z6.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: z4.array(questionSchema).describe("Questions only the owner can settle; the brief cannot be approved until each is answered or dismissed. Empty when none")
+  openQuestions: z6.array(questionSchema).describe("Questions only the owner can settle; the brief cannot be approved until each is answered or dismissed. Empty when none")
 });
-function reply3(text2, isError = false) {
+function reply4(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 reply3(`Could not reach TAMsense to check this: ${message}. Call ${toolName} again in a moment.`, true);
+  return reply4(`Could not reach TAMsense to check this: ${message}. Call ${toolName} again in a moment.`, true);
 }
 function questionsTool(review, onSubmit) {
-  return tool4(
+  return tool6(
     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,
@@ -2827,10 +3059,10 @@ function questionsTool(review, onSubmit) {
         return unreachable(error, SUBMIT_QUESTIONS_TOOL_NAME);
       }
       if (!verdict.accepted) {
-        return reply3(verdict.feedback, true);
+        return reply4(verdict.feedback, true);
       }
       onSubmit(args);
-      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.");
+      return reply4(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.");
     }
   );
 }
@@ -2838,7 +3070,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 tool4(
+  return tool6(
     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,
@@ -2851,20 +3083,20 @@ function specTool(review, onSubmit, builderCheckRan) {
       }
       if (!verdict.accepted) {
         repairs += 1;
-        return reply3(verdict.feedback, true);
+        return reply4(verdict.feedback, true);
       }
       if (!builderCheckRan() && !reminded) {
         reminded = true;
-        return reply3(BUILDER_CHECK_FIRST, true);
+        return reply4(BUILDER_CHECK_FIRST, true);
       }
       onSubmit({ spec: args, problems: verdict.problems });
-      return reply3(verdict.problems.length > 0 ? `Spec saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Spec saved.");
+      return reply4(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 tool4(
+  return tool6(
     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,
@@ -2877,10 +3109,10 @@ function briefTool(review, onSubmit) {
       }
       if (!verdict.accepted) {
         repairs += 1;
-        return reply3(verdict.feedback, true);
+        return reply4(verdict.feedback, true);
       }
       onSubmit({ spec: args, problems: verdict.problems });
-      return reply3(verdict.problems.length > 0 ? `Brief saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Brief saved.");
+      return reply4(verdict.problems.length > 0 ? `Brief saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Brief saved.");
     }
   );
 }
@@ -2983,11 +3215,11 @@ function usageLimitWatch() {
 var NO_RESULT_TEXT = "Claude finished without a result.";
 var SERVER_NAME2 = "tamsense";
 var CAPTION_FIELDS = {
-  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"')
+  title: z7.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: z7.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."')
+  notes: z7.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: {
@@ -3008,21 +3240,21 @@ var ATTACH_TOOLS = {
 };
 function attachTool(kind, attach) {
   const spec = ATTACH_TOOLS[kind];
-  return tool5(
+  return tool7(
     spec.name,
     spec.description,
-    { path: z5.string().describe(spec.path), ...CAPTION_FIELDS, ...kind === "screenshot" ? {} : NOTES_FIELD },
+    { path: z7.string().describe(spec.path), ...CAPTION_FIELDS, ...kind === "screenshot" ? {} : NOTES_FIELD },
     async (args) => ({ content: [{ type: "text", text: await attach({ kind, ...args }) }] })
   );
 }
 function verdictTool(onVerdict) {
-  return tool5(
+  return tool7(
     VERDICT_TOOL_NAME,
     "Hand in the result of this check. Call it exactly once, at the very end.",
     {
-      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")
+      passed: z7.boolean().describe("true only if nothing must be fixed"),
+      report: z7.string().describe("what you checked and, if it failed, exactly what to fix with file and line"),
+      couldNotRun: z7.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 });
@@ -3031,13 +3263,13 @@ function verdictTool(onVerdict) {
   );
 }
 function handoffTool(targets, onHandoff) {
-  return tool5(
+  return tool7(
     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: 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")
+      to: z7.string().describe("name or id of the step to hand the task to"),
+      outcome: z7.enum(HANDOFF_OUTCOMES).describe("pass: the work is done; problems: something must be fixed; ask: a question for that step"),
+      note: z7.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);
@@ -3050,25 +3282,25 @@ function handoffTool(targets, onHandoff) {
   );
 }
 function askPersonTool(asking, waiting) {
-  return tool5(
+  return tool7(
     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: 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")
+      to: z7.union([z7.number(), z7.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: z7.string().describe('one line on why this person: "assignee, and the run is on her computer", "Designer, owns empty states"'),
+      question: z7.string().describe("one plain question the person can answer without reading the code"),
+      context: z7.string().optional().describe("one line on what you saw that led to the question"),
+      tried: z7.array(z7.object({
+        did: z7.string().describe("the command or step"),
+        error: z7.string().optional().describe("the exact error line, if there was one"),
+        result: z7.string().describe("what it showed, one line")
       })).max(MAX_ASK_TRIES).optional().describe("what you already tried, the most telling first"),
-      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")
+      options: z7.array(z7.object({
+        label: z7.string().describe("a short answer the person can pick"),
+        detail: z7.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: 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")
+      blocking: z7.boolean().describe("true when you cannot go on without the answer"),
+      assumption: z7.string().optional().describe("when blocking is false: what you continue with until the answer comes")
     },
     async (args) => {
       if (waiting.waitingFor !== null) {
@@ -3078,16 +3310,16 @@ function askPersonTool(asking, waiting) {
       if ("error" in choice) {
         return { content: [{ type: "text", text: choice.error }], isError: true };
       }
-      let reply4;
+      let reply5;
       try {
-        reply4 = await asking.send(choice.body);
+        reply5 = 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 = reply4.id;
+        waiting.waitingFor = reply5.id;
       }
-      return { content: [{ type: "text", text: askedText(reply4.name, choice.body) }] };
+      return { content: [{ type: "text", text: askedText(reply5.name, choice.body) }] };
     }
   );
 }
@@ -3132,7 +3364,8 @@ function tamsenseServer(request, submitted) {
     })] : [],
     ...request.results ? resultToolset(request.results) : [],
     ...request.handOver ? [handOverTool(request.handOver)] : [],
-    ...request.schedules ? [proposeScheduleTool(request.schedules, submitted)] : []
+    ...request.schedules ? [proposeScheduleTool(request.schedules, submitted), wakeUpLaterTool(request.schedules)] : [],
+    ...sourceToolset(request.sources)
   ];
   return {
     server: createSdkMcpServer2({ name: SERVER_NAME2, version: "1.0.0", tools }),
@@ -3159,6 +3392,7 @@ async function attempt(request, context, resume) {
   let outcome = { completed: false, report: NO_RESULT_TEXT, model: null, usage: null, verdict: null };
   const tamsense = tamsenseServer(request, context.submitted);
   const shown = hiddenStepsFilter();
+  const calls = sourceCalls(request.sources?.tools);
   const helpers = helperTasks();
   const messages = context.startQuery({
     prompt: request.input.start(request.prompt.prompt),
@@ -3193,7 +3427,7 @@ async function attempt(request, context, resume) {
         messages.close();
         return { outcome, sessionId, resumeFailed: true };
       }
-      for (const draft of [...helpers.observe(message), ...feedOf(message).filter(shown).flatMap(helpers.adjust)]) {
+      for (const draft of [...helpers.observe(message), ...feedOf(message, calls).filter(shown).flatMap(helpers.adjust)]) {
         if (draft.kind === "agent" && draft.parent === null) {
           context.submitted.helperStarted = true;
         }
@@ -3245,12 +3479,16 @@ var runClaude = claudeRunner(query3);
 
 // src/config.ts
 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 join6 } from "path";
 var OWNER_ONLY_FILE = 384;
 var OWNER_ONLY_FOLDER = 448;
-function configPath(home = homedir2()) {
-  return join6(home, ".tamsense", "runner.json");
+var PROFILES_FOLDER = "profiles";
+function dataFolderFor(home, profile) {
+  const shared = join6(home, ".tamsense");
+  return profile === null ? shared : join6(shared, PROFILES_FOLDER, profile);
+}
+function configPath(dataFolder) {
+  return join6(dataFolder, "runner.json");
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3266,7 +3504,7 @@ function parseConfig(value) {
 function isMissingFile(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
-async function readConfig(path = configPath()) {
+async function readConfig(path) {
   try {
     return parseConfig(JSON.parse(await readFile3(path, "utf8")));
   } catch (error) {
@@ -3276,18 +3514,18 @@ async function readConfig(path = configPath()) {
     throw error;
   }
 }
-async function writeConfig(config, path = configPath()) {
+async function writeConfig(config, path) {
   await mkdir4(dirname2(path), { recursive: true, mode: OWNER_ONLY_FOLDER });
   await writeFile3(path, `${JSON.stringify(config, null, 4)}
 `, { mode: OWNER_ONLY_FILE });
 }
-async function removeConfig(path = configPath()) {
+async function removeConfig(path) {
   await rm4(path, { force: true });
 }
 
 // src/login.ts
 var MS_PER_SECOND = 1e3;
-var EXPIRED_TEXT = `The code expired before it was confirmed. Run ${LOGIN_COMMAND} again.`;
+var EXPIRED_TEXT = "The code expired before it was confirmed. Run the same command again.";
 var DENIED_TEXT = "The connection was cancelled in the browser. This computer was not connected.";
 async function login(tools, request) {
   const pairing = await tools.api.request("POST", PAIRINGS_PATH, request);
@@ -3299,14 +3537,14 @@ async function login(tools, request) {
   tools.openBrowser(pageUrl);
   while (tools.now() < expiresAt) {
     await tools.sleep(pairing.intervalSeconds * MS_PER_SECOND);
-    const reply4 = await tools.api.request("POST", PAIRING_TOKEN_PATH, { deviceCode: pairing.deviceCode });
-    if (reply4.status === "connected") {
-      return { token: reply4.token, device: reply4.device };
+    const reply5 = await tools.api.request("POST", PAIRING_TOKEN_PATH, { deviceCode: pairing.deviceCode });
+    if (reply5.status === "connected") {
+      return { token: reply5.token, device: reply5.device };
     }
-    if (reply4.status === "denied") {
+    if (reply5.status === "denied") {
       throw new Error(DENIED_TEXT);
     }
-    if (reply4.status === "expired") {
+    if (reply5.status === "expired") {
       break;
     }
   }
@@ -3652,8 +3890,8 @@ function bundledRecorder() {
   const path = fileURLToPath(new URL("./recorder.cjs", import.meta.url));
   return existsSync6(path) ? path : null;
 }
-function recordingsFolder(home, runId) {
-  return join8(home, ".tamsense", "recordings", `run-${runId}`);
+function recordingsFolder(dataFolder, runId) {
+  return join8(dataFolder, "recordings", `run-${runId}`);
 }
 function nodeOptionsWithRecorder(recorder, nodeOptions) {
   return [nodeOptions?.trim(), `--require "${recorder.replaceAll("\\", "/")}"`].filter(Boolean).join(" ");
@@ -3679,6 +3917,13 @@ function describeDevice(identity) {
   return identity.device.team ? `a team computer of ${identity.projectName}` : `the personal computer of ${identity.email ?? "its owner"}`;
 }
 
+// src/sense.ts
+import { mkdtemp, rm as rm5 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname4, join as join9 } from "path";
+import process5 from "process";
+import { createSdkMcpServer as createSdkMcpServer3, query as query4 } from "@anthropic-ai/claude-agent-sdk";
+
 // src/system.ts
 import { spawn as spawn3 } from "child_process";
 import { hostname } from "os";
@@ -3693,8 +3938,9 @@ var MAX_NAME_LENGTH2 = 80;
 function platformLabel(platform = process.platform) {
   return PLATFORM_LABELS[platform] ?? platform;
 }
-function defaultDeviceName() {
-  return hostname().slice(0, MAX_NAME_LENGTH2) || "My computer";
+function defaultDeviceName(profile = null) {
+  const name = hostname() || "My computer";
+  return (profile === null ? name : `${name} (${profile})`).slice(0, MAX_NAME_LENGTH2);
 }
 function browserCommand(url, platform) {
   if (platform === "win32") {
@@ -3723,10 +3969,104 @@ async function sleep(ms, signal) {
   });
 }
 
+// src/sense.ts
+var SERVER_NAME3 = "tamsense";
+var MAX_SENSE_TURNS = 3;
+var HEARTBEAT_MS = 5e3;
+var STOPPED_HERE = "stopped_here";
+var CLOSED_ON_SITE = "closed_on_site";
+var TOO_LONG = "too_long";
+var FAILED = { outcome: "failed", text: "", model: null, usage: null };
+function claudeSenseRunner(startQuery) {
+  return async (request) => {
+    request.signal.throwIfAborted();
+    const abortController = new AbortController();
+    request.signal.addEventListener("abort", () => abortController.abort(), { once: true });
+    const tools = sourceToolset(request.sources);
+    const limit = usageLimitWatch();
+    const messages = startQuery({
+      prompt: request.prompt,
+      options: {
+        cwd: request.cwd,
+        systemPrompt: request.system,
+        tools: [],
+        settingSources: [],
+        persistSession: false,
+        strictMcpConfig: true,
+        mcpServers: tools.length > 0 ? { [SERVER_NAME3]: createSdkMcpServer3({ name: SERVER_NAME3, version: "1.0.0", tools }) } : {},
+        allowedTools: tools.map((item) => `mcp__${SERVER_NAME3}__${item.name}`),
+        permissionMode: "auto",
+        canUseTool: denyWhenAsked,
+        maxTurns: MAX_SENSE_TURNS,
+        outputFormat: { type: "json_schema", schema: request.schema },
+        abortController,
+        env: request.env,
+        ...request.model === null ? {} : { model: request.model }
+      }
+    });
+    let finish2 = FAILED;
+    for await (const message of messages) {
+      limit.observe(message);
+      if (message.type === "result") {
+        const measured = outcomeOf(message, "");
+        const text2 = message.subtype !== "success" ? "" : message.structured_output === void 0 ? message.result : JSON.stringify(message.structured_output);
+        finish2 = { outcome: measured.completed && text2 ? "succeeded" : "failed", text: text2, model: measured.model, usage: measured.usage };
+      }
+    }
+    return limit.pausedUntil(finish2.outcome === "succeeded") ? { ...finish2, outcome: "usage_limit" } : finish2;
+  };
+}
+function senseHeartbeat(api, job, abort) {
+  return async () => {
+    try {
+      const answer = await api.request("POST", sensePath(job.senseId, "heartbeat"), void 0, { safeToRepeat: true });
+      if (!answer.keepGoing) {
+        abort();
+      }
+    } catch {
+    }
+  };
+}
+async function runSenseJob(job, runSense, tools, stop) {
+  const cwd = await mkdtemp(join9(tmpdir(), "tamsense-sense-"));
+  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(TOO_LONG), job.deadlineMs);
+  const beat = senseHeartbeat(tools.api, job, () => run2.abort(CLOSED_ON_SITE));
+  const beating = setInterval(() => void beat(), HEARTBEAT_MS);
+  let body;
+  try {
+    const env = withNodeOnPath(process5.env, dirname4(process5.execPath));
+    body = await runSense({ system: job.system, prompt: job.prompt, schema: job.schema, model: job.model, cwd, env, signal: run2.signal, sources: sourceTools(job.tools, tools.api, sensePath(job.senseId, "sources")) });
+  } catch {
+    body = FAILED;
+  } finally {
+    clearTimeout(deadline);
+    clearInterval(beating);
+    stop.removeEventListener("abort", stopRun);
+    await rm5(cwd, { recursive: true, force: true });
+  }
+  if (run2.signal.reason === CLOSED_ON_SITE) {
+    return;
+  }
+  try {
+    await tools.api.request("POST", sensePath(job.senseId, "finish"), run2.signal.aborted ? FAILED : body);
+    if (body.outcome === "succeeded" && !run2.signal.aborted) {
+      tools.print(`Sense answered on task #${job.taskId}`);
+    }
+  } catch {
+  }
+}
+var runClaudeSense = claudeSenseRunner(query4);
+
 // src/update.ts
 import { spawn as spawn4 } from "child_process";
 import { readFileSync as readFileSync2 } from "fs";
-import process5 from "process";
+import process6 from "process";
 var PACKAGE_NAME = "@tamsensedev/runner";
 var RELAUNCHED_ENV = "TAMSENSE_RELAUNCHED";
 var NO_UPDATE_ENV = "TAMSENSE_NO_UPDATE";
@@ -3778,27 +4118,27 @@ function relaunchArgs(argv) {
   return ["--yes", `${PACKAGE_NAME}@latest`, ...argv];
 }
 function relaunch(argv, env) {
-  const isWindows = process5.platform === "win32";
+  const isWindows = process6.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 = () => {
     };
-    process5.on("SIGINT", ignoreInterrupt);
+    process6.on("SIGINT", ignoreInterrupt);
     child.on("error", (error) => {
-      process5.off("SIGINT", ignoreInterrupt);
+      process6.off("SIGINT", ignoreInterrupt);
       reject(error);
     });
     child.on("close", (code) => {
-      process5.off("SIGINT", ignoreInterrupt);
+      process6.off("SIGINT", ignoreInterrupt);
       resolve5(code ?? 1);
     });
   });
 }
 
 // src/worker.ts
-import { rm as rm6 } from "fs/promises";
-import { dirname as dirname5 } from "path";
-import process6 from "process";
+import { rm as rm7 } from "fs/promises";
+import { dirname as dirname6, join as join12 } from "path";
+import process7 from "process";
 
 // src/feedQueue.ts
 var MAX_BATCH = 200;
@@ -3845,8 +4185,8 @@ function feedQueue(send) {
 
 // src/library.ts
 import { existsSync as existsSync7 } from "fs";
-import { cp, mkdir as mkdir5, rm as rm5 } from "fs/promises";
-import { join as join9 } from "path";
+import { cp, mkdir as mkdir5, rm as rm6 } from "fs/promises";
+import { join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var LIBRARY_PATH = fileURLToPath2(new URL("../library", import.meta.url));
 var SKILL_NAME = /^[a-z0-9-]+$/;
@@ -3858,19 +4198,19 @@ function allowedSkills(stage) {
   const skills = stage.role?.skills ?? null;
   return skills && [.../* @__PURE__ */ new Set([...skills, ...STAGE_SKILLS[stage.kind] ?? []])].filter((name) => SKILL_NAME.test(name));
 }
-function roleLibraryFolder(home, runId) {
-  return join9(home, ".tamsense", "libraries", `run-${runId}`);
+function roleLibraryFolder(dataFolder, runId) {
+  return join10(dataFolder, "libraries", `run-${runId}`);
 }
 async function prepareLibrary(folder, skills, source = LIBRARY_PATH) {
   if (skills === null) {
     return source;
   }
-  await rm5(folder, { recursive: true, force: 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 });
+  await rm6(folder, { recursive: true, force: true });
+  await mkdir5(join10(folder, "skills"), { recursive: true });
+  await cp(join10(source, ".claude-plugin"), join10(folder, ".claude-plugin"), { recursive: true });
+  await cp(join10(source, "agents"), join10(folder, "agents"), { recursive: true });
+  for (const skill of skills.filter((name) => SKILL_NAME.test(name) && existsSync7(join10(source, "skills", name)))) {
+    await cp(join10(source, "skills", skill), join10(folder, "skills", skill), { recursive: true });
   }
   return folder;
 }
@@ -3879,7 +4219,7 @@ async function prepareLibrary(folder, skills, source = LIBRARY_PATH) {
 import { randomUUID } from "crypto";
 import { createReadStream } from "fs";
 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 { basename as basename4, dirname as dirname5, extname as extname2, isAbsolute as isAbsolute3, join as join11 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { Readable } from "stream";
 import { promisify } from "util";
@@ -3959,12 +4299,12 @@ async function readMeta(file) {
 }
 async function metaFor(kind, file) {
   if (kind === "replay") {
-    return readMeta(join10(dirname4(file), `${sessionIdOf(file)}${META_SUFFIX}`));
+    return readMeta(join11(dirname5(file), `${sessionIdOf(file)}${META_SUFFIX}`));
   }
-  const folder = basename4(dirname4(file)) === "video" ? dirname4(dirname4(file)) : dirname4(file);
+  const folder = basename4(dirname5(file)) === "video" ? dirname5(dirname5(file)) : dirname5(file);
   for (const name of await readdir2(folder).catch(() => [])) {
     if (name.endsWith(META_SUFFIX) && name !== LEDGER_FILE) {
-      const meta = await readMeta(join10(folder, name));
+      const meta = await readMeta(join11(folder, name));
       if (meta?.video === file) {
         return meta;
       }
@@ -3974,7 +4314,7 @@ async function metaFor(kind, file) {
 }
 async function ledger(dir) {
   try {
-    return new Set(JSON.parse(await readFile4(join10(dir, LEDGER_FILE), "utf8")));
+    return new Set(JSON.parse(await readFile4(join11(dir, LEDGER_FILE), "utf8")));
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -3982,7 +4322,7 @@ async function ledger(dir) {
 async function remember(dir, file) {
   const done2 = await ledger(dir);
   done2.add(file);
-  await writeFile4(join10(dir, LEDGER_FILE), JSON.stringify([...done2]));
+  await writeFile4(join11(dir, LEDGER_FILE), JSON.stringify([...done2]));
 }
 async function nonEmpty(file) {
   return file !== null && ((await stat2(file).catch(() => null))?.size ?? 0) > 0;
@@ -3995,8 +4335,8 @@ async function pendingRecordings(dir) {
     if (!name.endsWith(META_SUFFIX) || name === LEDGER_FILE) {
       continue;
     }
-    const meta = await readMeta(join10(dir, name));
-    const replay = join10(dir, `${name.slice(0, -META_SUFFIX.length)}${REPLAY_SUFFIX}`);
+    const meta = await readMeta(join11(dir, name));
+    const replay = join11(dir, `${name.slice(0, -META_SUFFIX.length)}${REPLAY_SUFFIX}`);
     if (!done2.has(replay) && await nonEmpty(replay)) {
       pending.push({ kind: "replay", file: replay, meta });
     }
@@ -4143,7 +4483,7 @@ async function readScreenshot(request) {
 }
 
 // src/worker.ts
-var POLL_INTERVAL_MS = 5e3;
+var POLL_INTERVAL_MS = 2e3;
 var MAX_RETRY_WAIT_MS = 6e4;
 var POLL_DEADLINE_MS = 3 * 6e4;
 var INBOX_INTERVAL_MS = 2e3;
@@ -4154,8 +4494,10 @@ 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";
+var ROUTINE_DEADLINE_MS = 30 * 6e4;
+var MAX_SENSE = 2;
+var STOPPED_HERE2 = "stopped_here";
+var CLOSED_ON_SITE2 = "closed_on_site";
 function messageOf3(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -4228,9 +4570,9 @@ function inbox(job, tools, record, closedOnSite) {
   async function check() {
     const ack = input.takeDelivered();
     const body = { ack };
-    let reply4;
+    let reply5;
     try {
-      reply4 = await tools.api.request("POST", runPath(job.runId, "inbox"), body, { safeToRepeat: true });
+      reply5 = await tools.api.request("POST", runPath(job.runId, "inbox"), body, { safeToRepeat: true });
     } catch (error) {
       input.restoreDelivered(ack);
       if (!failing && !alreadyReported(error)) {
@@ -4240,23 +4582,23 @@ function inbox(job, tools, record, closedOnSite) {
       return;
     }
     failing = false;
-    if (!reply4.keepGoing) {
+    if (!reply5.keepGoing) {
       closedOnSite();
       return;
     }
-    for (const message of reply4.messages) {
+    for (const message of reply5.messages) {
       if (input.push(message)) {
         tools.print(`  ${messageLine(message)}`);
       }
     }
-    for (const stop of reply4.helperStops ?? []) {
+    for (const stop of reply5.helperStops ?? []) {
       if (!stopsSeen.has(stop.ref)) {
         stopsSeen.add(stop.ref);
         void stopHelper(input, stop, tools.print);
       }
     }
-    if (reply4.model !== null || reply4.effort !== null) {
-      const change = { model: reply4.model, effort: reply4.effort };
+    if (reply5.model !== null || reply5.effort !== null) {
+      const change = { model: reply5.model, effort: reply5.effort };
       void input.switchModel(change).then(
         (applied) => {
           if (applied) {
@@ -4311,11 +4653,11 @@ function permissionTools(job, tools) {
   }
   return {
     send: async (body) => {
-      const reply4 = await tools.api.request("POST", runPath(job.runId, "permissions"), body);
-      if (reply4.decision === "wait") {
+      const reply5 = await tools.api.request("POST", runPath(job.runId, "permissions"), body);
+      if (reply5.decision === "wait") {
         tools.print(`  Waiting for a person on TAMsense to allow: ${body.title || body.action}`);
       }
-      return reply4;
+      return reply5;
     },
     check: (id) => tools.api.request("GET", permissionPath(job.runId, id)),
     sleep: tools.sleep
@@ -4340,17 +4682,18 @@ function skillsLine(skills) {
 async function prepare(job, tools) {
   if (isFolderJob(job)) {
     tools.print("Preparing the task folder\u2026");
-    const { results, ...workspace2 } = await prepareFolder(job, taskFolder(tools.home, job), tools.api);
+    const { results, ...workspace2 } = await prepareFolder(job, taskFolder(tools.dataFolder, job), tools.api);
     return { workspace: workspace2, results, identity: {} };
   }
+  const taskResults = (workspace2) => writeResults(join12(workspace2.root, RESULTS_FOLDER), job, tools.api);
   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) };
+    return { workspace: workspace2, results: await taskResults(workspace2), 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) };
+  return { workspace, results: await taskResults(workspace), 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);
@@ -4362,13 +4705,13 @@ async function executeJob(job, tools, signal, input, record) {
   if (skills) {
     tools.print(skillsLine(skills));
   }
-  const library = await prepareLibrary(roleLibraryFolder(tools.home, job.runId), skills);
+  const library = await prepareLibrary(roleLibraryFolder(tools.dataFolder, job.runId), skills);
   signal.throwIfAborted();
   tools.print("Claude is working\u2026");
   const attached = { count: 0 };
   const session = sessionReporter(tools.api, job, tools.print);
-  const recordings = recordingsFolder(tools.home, job.runId);
-  const baseEnv = withNodeOnPath(process6.env, dirname5(process6.execPath));
+  const recordings = recordingsFolder(tools.dataFolder, job.runId);
+  const baseEnv = withNodeOnPath(process7.env, dirname6(process7.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,
@@ -4391,7 +4734,8 @@ async function executeJob(job, tools, signal, input, record) {
     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),
-    schedules: job.canSchedule ? scheduleTools(tools.api, runPath(job.runId, "schedules")) : null
+    schedules: job.canSchedule ? scheduleTools(tools.api, runPath(job.runId, "schedules"), runPath(job.runId, "wake")) : null,
+    sources: sourceTools(job.sourceTools, tools.api, runPath(job.runId, "sources"))
   });
   await session.sent();
   signal.throwIfAborted();
@@ -4453,7 +4797,7 @@ function resultLine(finish2, workspace = "repositories") {
   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);
+  const folder = recordingsFolder(tools.dataFolder, job.runId);
   try {
     const report = await uploadPendingRecordings(tools.api, job.runId, folder);
     if (report.uploaded > 0) {
@@ -4466,16 +4810,16 @@ async function sendRecordings(job, tools) {
       tools.print(`Could not attach a recording: ${line}`);
     }
   } finally {
-    await rm6(folder, { recursive: true, force: true });
+    await rm7(folder, { recursive: true, force: true });
   }
 }
 function failureReport(error, signal) {
-  return signal.reason === STOPPED_HERE ? "The run was stopped on the computer." : `The run stopped on the computer: ${messageOf3(error)}`;
+  return signal.reason === STOPPED_HERE2 ? "The run was stopped on the computer." : `The run stopped on the computer: ${messageOf3(error)}`;
 }
 async function runJob(job, tools, stop) {
   tools.print(`Task #${job.taskId}: ${job.title} (${job.stage.name})`);
   const run2 = new AbortController();
-  const stopRun = () => run2.abort(STOPPED_HERE);
+  const stopRun = () => run2.abort(STOPPED_HERE2);
   if (stop.aborted) {
     stopRun();
   }
@@ -4483,7 +4827,7 @@ async function runJob(job, tools, stop) {
   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));
+  const messages = inbox(job, tools, record, () => run2.abort(CLOSED_ON_SITE2));
   const { input } = messages;
   run2.signal.addEventListener("abort", input.close, { once: true });
   void messages.poll();
@@ -4494,7 +4838,7 @@ async function runJob(job, tools, stop) {
   } catch (error) {
     finish2 = { outcome: "failed", report: failureReport(error, run2.signal), pushed: [], model: null, usage: null, verdict: null, handoff: null, sessionId: null, pausedUntil: null, questions: null, spec: null, waitingFor: null };
   } finally {
-    await rm6(roleLibraryFolder(tools.home, job.runId), { recursive: true, force: true });
+    await rm7(roleLibraryFolder(tools.dataFolder, job.runId), { recursive: true, force: true });
     clearInterval(polling);
     clearInterval(feeding);
     stop.removeEventListener("abort", stopRun);
@@ -4505,8 +4849,8 @@ async function runJob(job, tools, stop) {
     await messages.poll();
   }
   await feed.flush();
-  if (run2.signal.reason === CLOSED_ON_SITE) {
-    await rm6(recordingsFolder(tools.home, job.runId), { recursive: true, force: true });
+  if (run2.signal.reason === CLOSED_ON_SITE2) {
+    await rm7(recordingsFolder(tools.dataFolder, job.runId), { recursive: true, force: true });
     tools.print("TAMsense closed this run while it was in progress. The result was not sent.");
     return;
   }
@@ -4519,33 +4863,36 @@ async function runJob(job, tools, stop) {
   }
 }
 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);
+function checkFailure(error, signal, deadlineMs) {
+  return signal.reason === CHECK_TOO_LONG ? `The run took longer than ${deadlineMs / 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 routine = routineRunTools(check, tools.api, tools.print, tools.sleep);
+  tools.print(routine ? `Routine: ${check.title}${check.routine?.dry ? " (test run)" : ""}` : `Schedule check: ${check.title}${check.taskId === null ? "" : ` (task #${check.taskId})`}`);
+  const deadlineMs = routine ? ROUTINE_DEADLINE_MS : CHECK_DEADLINE_MS;
   const run2 = new AbortController();
-  const stopRun = () => run2.abort(STOPPED_HERE);
+  const stopRun = () => run2.abort(STOPPED_HERE2);
   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 deadline = setTimeout(() => run2.abort(CHECK_TOO_LONG), deadlineMs);
+  const beat = checkHeartbeat(tools.api, check, () => run2.abort(CLOSED_ON_SITE2));
   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 }));
+    const folder = await checkFolder(tools.dataFolder, check);
+    const env = withNodeOnPath(process7.env, dirname6(process7.execPath));
+    const prompt = routine ? buildRoutinePrompt(check, folder) : buildCheckPrompt(check, folder);
+    body = checkFinishBody(await runCheck({ cwd: folder, prompt, model: check.model, env, signal: run2.signal, sources: sourceTools(check.sourceTools, tools.api, checkPath(check.checkId, "sources")), routine }));
   } catch (error) {
-    body = { outcome: "failed", report: checkFailure(error, run2.signal), model: null, usage: null, result: null };
+    body = { outcome: "failed", report: checkFailure(error, run2.signal, deadlineMs), model: null, usage: null, result: null };
   } finally {
     clearTimeout(deadline);
     clearInterval(beating);
     stop.removeEventListener("abort", stopRun);
   }
-  if (run2.signal.reason === CLOSED_ON_SITE) {
+  if (run2.signal.reason === CLOSED_ON_SITE2) {
     tools.print("TAMsense closed this check while it was in progress. The result was not sent.");
     return;
   }
@@ -4606,9 +4953,11 @@ async function work(tools, stop, parallel = 1) {
   const stopAll = AbortSignal.any([stop, halt.signal]);
   const running = /* @__PURE__ */ new Set();
   const checks = /* @__PURE__ */ new Set();
+  const senses = /* @__PURE__ */ new Set();
   const folderLock = keyedLock();
   const scheduleLock = keyedLock();
   const runCheck = tools.version ? tools.runCheck : void 0;
+  const runSense = tools.version ? tools.runSense : void 0;
   const reporting = reportCapabilities(tools, stopAll);
   const checking = tools.inspectFolder ? checkFolders({ ...tools, inspect: tools.inspectFolder }, stopAll) : Promise.resolve();
   if (tools.startFolder) {
@@ -4623,19 +4972,26 @@ async function work(tools, stop, parallel = 1) {
     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);
   };
+  const startSense = (job, runner) => {
+    const task = runSenseJob(job, runner, tools, stopAll).catch(() => {
+    }).finally(() => senses.delete(task));
+    senses.add(task);
+  };
   let failures = 0;
   try {
     while (!stopAll.aborted) {
       const jobsFull = running.size >= parallel;
       const checksFull = !runCheck || checks.size >= MAX_CHECKS;
-      if (jobsFull && checksFull) {
-        await Promise.race([...running, ...checks]);
+      const senseFull = !runSense || senses.size >= MAX_SENSE;
+      if (jobsFull && checksFull && senseFull) {
+        await Promise.race([...running, ...checks, ...senses]);
         continue;
       }
-      const body = runCheck && tools.version ? { version: tools.version, jobs: !jobsFull, checks: !checksFull } : void 0;
-      let reply4;
+      const named = tools.version && (runCheck || runSense) ? tools.version : null;
+      const body = named ? { version: named, jobs: !jobsFull, checks: !checksFull, ...runSense ? { sense: !senseFull } : {} } : void 0;
+      let reply5;
       try {
-        reply4 = await withDeadline(tools.api.request("POST", NEXT_RUN_PATH, body, { safeToRepeat: true }), POLL_DEADLINE_MS, tools.sleep);
+        reply5 = await withDeadline(tools.api.request("POST", NEXT_RUN_PATH, body, { safeToRepeat: true }), POLL_DEADLINE_MS, tools.sleep);
       } catch (error) {
         if (isFatal(error)) {
           halt.abort();
@@ -4649,65 +5005,80 @@ async function work(tools, stop, parallel = 1) {
         continue;
       }
       failures = 0;
-      if (reply4.check && runCheck) {
-        startCheck(reply4.check, runCheck);
-      } else if (reply4.job) {
-        start(reply4.job);
+      if (reply5.sense && runSense) {
+        startSense(reply5.sense, runSense);
+      } else if (reply5.check && runCheck) {
+        startCheck(reply5.check, runCheck);
+      } else if (reply5.job) {
+        start(reply5.job);
       } else {
         await tools.sleep(POLL_INTERVAL_MS, stopAll);
       }
     }
   } finally {
-    await Promise.allSettled([...running, ...checks, reporting, checking]);
+    await Promise.allSettled([...running, ...checks, ...senses, reporting, checking]);
   }
 }
 
 // src/cli.ts
-var NOT_CONNECTED_TEXT = `This computer is not connected. Run ${LOGIN_COMMAND}`;
-var DISCONNECTED_TEXT = `This computer was disconnected on the website. Run ${LOGIN_COMMAND}`;
 var NO_TASKS_ACCESS_TEXT = "Your account no longer has access to Tasks. Ask the project owner.";
-var ACCESS_PROBLEMS = { 401: DISCONNECTED_TEXT, 403: NO_TASKS_ACCESS_TEXT };
+var UNAUTHORIZED_STATUS = 401;
+var FORBIDDEN_STATUS = 403;
 var INTERRUPTED_EXIT_CODE = 130;
+function connectionFor(profile) {
+  const dataFolder = dataFolderFor(homedir2(), profile);
+  return { profile, dataFolder, configFile: configPath(dataFolder) };
+}
+function notConnectedText(profile) {
+  const which = profile === null ? "" : ` in the profile ${profile}`;
+  return `This computer is not connected${which}. Run ${withProfile(LOGIN_COMMAND, profile)}`;
+}
 function print(line) {
-  process7.stdout.write(`${line}
+  process8.stdout.write(`${line}
 `);
 }
 function serverFor(flag, saved) {
-  return serverOrigin(flag ?? process7.env.TAMSENSE_URL ?? saved?.server ?? DEFAULT_SERVER);
+  return serverOrigin(flag ?? process8.env.TAMSENSE_URL ?? saved?.server ?? DEFAULT_SERVER);
 }
-function accessProblem(error) {
-  return error instanceof ApiError ? ACCESS_PROBLEMS[error.status] ?? null : null;
+function accessProblem(error, profile) {
+  if (!(error instanceof ApiError)) {
+    return null;
+  }
+  if (error.status === UNAUTHORIZED_STATUS) {
+    return `This computer was disconnected on the website. Run ${withProfile(LOGIN_COMMAND, profile)}`;
+  }
+  return error.status === FORBIDDEN_STATUS ? NO_TASKS_ACCESS_TEXT : null;
 }
-async function forgetDevice(config) {
+async function forgetDevice(config, connection) {
   await createApi(config.server, config.token).request("DELETE", IDENTITY_PATH).catch(() => {
   });
-  await removeConfig();
+  await removeConfig(connection.configFile);
 }
-async function runLogin(server, deviceName) {
-  const saved = await readConfig();
+async function runLogin(connection, server, deviceName) {
+  const saved = await readConfig(connection.configFile);
   const api = createApi(serverFor(server, saved));
   if (saved) {
-    await forgetDevice(saved);
+    await forgetDevice(saved, connection);
   }
-  const name = deviceName?.trim() || defaultDeviceName();
+  const name = deviceName?.trim() || defaultDeviceName(connection.profile);
   const result = await login(
     { api, openBrowser, print, sleep, now: Date.now },
     { 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, go to your code folder and run ${START_COMMAND}`);
+  await writeConfig({ server: api.server, token: result.token, deviceId: result.device.id, deviceName: result.device.name }, connection.configFile);
+  print(`Connected: ${result.device.name}. To take your tasks, go to your code folder and run ${withProfile(START_COMMAND, connection.profile)}`);
 }
 function stopOnInterrupt() {
   const stop = new AbortController();
-  process7.once("SIGINT", () => {
+  process8.once("SIGINT", () => {
     print("Stopping\u2026 Press Ctrl+C again to quit at once.");
     stop.abort();
-    process7.once("SIGINT", () => process7.exit(INTERRUPTED_EXIT_CODE));
+    process8.once("SIGINT", () => process8.exit(INTERRUPTED_EXIT_CODE));
   });
   return stop.signal;
 }
 function installTools(home) {
-  return { home, nodePath: process7.execPath, env: process7.env, print, run: runProcess, exists: existsSync8 };
+  return { home, nodePath: process8.execPath, env: process8.env, print, run: runProcess, exists: existsSync8 };
 }
 async function browserForStart(home, install) {
   const installed = await installedBrowser(home);
@@ -4717,41 +5088,41 @@ async function browserForStart(home, install) {
   return ensureBrowser({ print, install: () => installBrowser(installTools(home)) });
 }
 async function startedNewVersion() {
-  const update = await updateToRun(process7.env, currentVersion(), () => latestVersion());
+  const update = await updateToRun(process8.env, currentVersion(), () => latestVersion());
   if (!update) {
     return false;
   }
   print(`TAMsense runner ${update.latest} is out, this is ${update.current}. Starting the new version...`);
   try {
-    process7.exitCode = await relaunch(process7.argv.slice(2), process7.env);
+    process8.exitCode = await relaunch(process8.argv.slice(2), process8.env);
     return true;
   } catch {
     print("Could not start the new version. Going on with this one.");
     return false;
   }
 }
-async function runStart(parallel, installsBrowser) {
+async function runStart(connection, parallel, installsBrowser) {
   if (await startedNewVersion()) {
     return;
   }
-  const saved = await readConfig();
+  const saved = await readConfig(connection.configFile);
   if (!saved) {
-    print(NOT_CONNECTED_TEXT);
+    print(notConnectedText(connection.profile));
     return;
   }
   const identity = await createApi(saved.server, saved.token).request("GET", IDENTITY_PATH);
-  const problem2 = teamKeyProblem(identity.device.team, process7.env);
+  const problem2 = teamKeyProblem(identity.device.team, process8.env);
   if (problem2) {
     throw new Error(problem2);
   }
   print(`${identity.device.name} is connected to ${saved.server} as ${describeDevice(identity)}.`);
-  const home = homedir3();
+  const home = homedir2();
   const browser = await browserForStart(home, installsBrowser);
   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);
+  await work({ api, runAgent: runClaude, runCheck: runClaudeCheck, runSense: runClaudeSense, version: currentVersion() ?? void 0, capabilities: probeCapabilities, print, sleep, home, dataFolder: connection.dataFolder, remoteUrl: githubRemoteUrl, browser, recorder: bundledRecorder(), inspectFolder: (path) => inspectFolder(path, home), startFolder: process8.cwd() }, stopOnInterrupt(), parallel);
 }
 async function runBrowser(remove) {
-  const home = homedir3();
+  const home = homedir2();
   if (remove) {
     print(await removeBrowser(home) ? "Removed the headless browser. The next start installs it again, unless you add --no-browser." : "No headless browser is installed.");
     return;
@@ -4764,46 +5135,53 @@ async function runBrowser(remove) {
   await installBrowser(installTools(home));
   print("Claude uses it for interface checks from the next start.");
 }
-async function runStatus() {
-  const saved = await readConfig();
+async function runStatus(connection) {
+  const saved = await readConfig(connection.configFile);
   if (!saved) {
-    print(NOT_CONNECTED_TEXT);
+    print(notConnectedText(connection.profile));
     return;
   }
   const identity = await createApi(saved.server, saved.token).request("GET", IDENTITY_PATH);
   print(`Connected: ${identity.device.name}, ${describeDevice(identity)}`);
   print(`Account: ${identity.email ?? "unknown"}, project ${identity.projectName}`);
   print(`Server: ${saved.server}`);
+  if (connection.profile !== null) {
+    print(`Profile: ${connection.profile}, folders in ${connection.dataFolder}`);
+  }
 }
-async function runLogout() {
-  const saved = await readConfig();
+async function runLogout(connection) {
+  const saved = await readConfig(connection.configFile);
   if (!saved) {
-    print(NOT_CONNECTED_TEXT);
+    print(notConnectedText(connection.profile));
     return;
   }
-  await forgetDevice(saved);
+  await forgetDevice(saved, connection);
   print("Disconnected. This computer no longer takes your tasks.");
 }
 async function run(command) {
   if (command.name === "login") {
-    await runLogin(command.server, command.deviceName);
+    await runLogin(connectionFor(command.profile), command.server, command.deviceName);
   } else if (command.name === "start") {
-    await runStart(command.parallel, command.browser);
+    await runStart(connectionFor(command.profile), command.parallel, command.browser);
   } else if (command.name === "browser") {
     await runBrowser(command.remove);
   } else if (command.name === "status") {
-    await runStatus();
+    await runStatus(connectionFor(command.profile));
   } else if (command.name === "logout") {
-    await runLogout();
+    await runLogout(connectionFor(command.profile));
   } else {
     print(HELP_TEXT);
   }
 }
+function fail(error, profile) {
+  process8.stderr.write(`${accessProblem(error, profile) ?? (error instanceof Error ? error.message : String(error))}
+`);
+  process8.exitCode = 1;
+}
 try {
-  await run(parseCommand(process7.argv.slice(2), process7.env));
+  const command = parseCommand(process8.argv.slice(2), process8.env);
+  await run(command).catch((error) => fail(error, "profile" in command ? command.profile : null));
 } catch (error) {
-  process7.stderr.write(`${accessProblem(error) ?? (error instanceof Error ? error.message : String(error))}
-`);
-  process7.exitCode = 1;
+  fail(error, null);
 }
 //# sourceMappingURL=cli.js.map