@tamsensedev/runner 0.0.0-stage → 0.2.1

package/dist/cli.js

@@ -0,0 +1,2914 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import process5 from "process";
+
+// src/api.ts
+var DEFAULT_SERVER = "https://my.tamsense.com";
+var ApiError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+function serverOrigin(address) {
+  let url;
+  try {
+    url = new URL(address);
+  } catch {
+    throw new Error(`"${address}" is not a valid address. Use a full address like ${DEFAULT_SERVER}`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error(`"${address}" is not a web address. Use a full address like ${DEFAULT_SERVER}`);
+  }
+  return url.origin;
+}
+function textOf(value) {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+async function errorOf(response) {
+  const reply2 = await response.json().catch(() => ({}));
+  const code = textOf(reply2.data?.code);
+  const message = textOf(reply2.message) ?? textOf(reply2.statusMessage) ?? `TAMsense answered with status ${response.status}`;
+  return new ApiError(response.status, code, message);
+}
+function createApi(server, token = null, fetchImpl = fetch) {
+  async function send(method, path, headers, body) {
+    const all = { accept: "application/json", ...headers };
+    if (token) {
+      all.authorization = `Bearer ${token}`;
+    }
+    let response;
+    try {
+      response = await fetchImpl(new URL(path, server), { method, headers: all, body, ...body instanceof ReadableStream ? { duplex: "half" } : {} });
+    } catch (error) {
+      throw new Error(`Could not reach ${server}. Check your internet connection.`, { cause: error });
+    }
+    if (!response.ok) {
+      throw await errorOf(response);
+    }
+    return await response.json();
+  }
+  return {
+    server,
+    request: (method, path, body) => send(method, path, body ? { "content-type": "application/json" } : {}, body && JSON.stringify(body)),
+    upload: (method, path, body, contentType) => send(method, path, { "content-type": contentType }, body)
+  };
+}
+
+// src/browser.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { delimiter, dirname, join } from "path";
+import { createInterface } from "readline";
+
+// src/commands.ts
+import { parseArgs } from "util";
+var LOGIN_COMMAND = "npx @tamsensedev/runner@latest login";
+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 HELP_TEXT = `Connects this computer to TAMsense so it can work on your tasks.
+
+Usage:
+  ${LOGIN_COMMAND}    connect this computer
+  ${START_COMMAND}    take your tasks and work on them until you press Ctrl+C
+  ${BROWSER_COMMAND}  install the headless browser for interface checks, or show it
+  ${BROWSER_COMMAND} remove   delete that browser
+  npx @tamsensedev/runner@latest status   show the connection
+  npx @tamsensedev/runner@latest logout   disconnect this computer
+
+Login options:
+  --name <name>    how this computer is called in TAMsense (default: its network name)
+  --server <url>   TAMsense address (default: ${DEFAULT_SERVER})
+
+Start options:
+  --parallel <n>   how many tasks to work on at once, 1 to ${MAX_PARALLEL} (default: ${DEFAULT_PARALLEL}, or TAMSENSE_PARALLEL)`;
+function parallelFor(flag, env) {
+  const [source, value] = flag !== void 0 ? ["--parallel", flag] : ["TAMSENSE_PARALLEL", env?.trim() || void 0];
+  if (value === void 0) {
+    return DEFAULT_PARALLEL;
+  }
+  const count = Number(value);
+  if (!/^\d+$/.test(value) || count < 1 || count > MAX_PARALLEL) {
+    throw new Error(`${source} must be a whole number from 1 to ${MAX_PARALLEL}, got "${value}".`);
+  }
+  return count;
+}
+function parseCommand(argv, env = {}) {
+  const { positionals, values } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: true,
+    options: {
+      server: { type: "string" },
+      name: { type: "string" },
+      parallel: { type: "string" },
+      help: { type: "boolean" }
+    }
+  });
+  const [name, detail] = positionals;
+  if (values.help) {
+    return { name: "help" };
+  }
+  if (name === "browser" && (detail === void 0 || detail === "remove") && positionals.length <= 2) {
+    return { name: "browser", remove: detail === "remove" };
+  }
+  if (positionals.length !== 1) {
+    return { name: "help" };
+  }
+  if (name === "login") {
+    return { name: "login", server: values.server ?? null, deviceName: values.name ?? null };
+  }
+  if (name === "start") {
+    return { name: "start", parallel: parallelFor(values.parallel, env.TAMSENSE_PARALLEL) };
+  }
+  if (name === "status" || name === "logout") {
+    return { name };
+  }
+  return { name: "help" };
+}
+
+// src/browser.ts
+var PLAYWRIGHT_VERSION = "1.64.1";
+var BROWSER_NAMES = ["chromium-headless-shell", "chromium"];
+var MARKER_FILE = "tamsense-browser.json";
+var OUTPUT_TAIL_LINES = 40;
+var ERROR_TAIL_LINES = 3;
+var ANSI_PATTERN = /\u001B\[[\d;]*m/g;
+var OFFLINE_PATTERN = /ENOTFOUND|EAI_AGAIN|ETIMEDOUT|ECONNREFUSED|ECONNRESET|ENETUNREACH|getaddrinfo/i;
+var BROWSER_QUESTION = "Interface checks need a headless browser (about 150 MB, installed once into ~/.tamsense). Install it now? [Y/n] ";
+var BROWSER_HINT = `Interface checks can use a headless browser. To install it (about 150 MB), run ${BROWSER_COMMAND}`;
+var OFFLINE_TEXT = `No connection to download it. Check your internet connection and run ${BROWSER_COMMAND} again.`;
+function browserFolders(home) {
+  const prefix = join(home, ".tamsense", "playwright");
+  return {
+    prefix,
+    packageDir: join(prefix, "node_modules", "playwright-core"),
+    browsers: join(home, ".tamsense", "browsers"),
+    marker: join(prefix, MARKER_FILE)
+  };
+}
+async function installedBrowser(home) {
+  const folders = browserFolders(home);
+  let saved;
+  try {
+    saved = JSON.parse(await readFile(folders.marker, "utf8"));
+  } catch {
+    return null;
+  }
+  const complete = saved.version === PLAYWRIGHT_VERSION && typeof saved.browser === "string" && existsSync(join(folders.packageDir, "package.json")) && existsSync(folders.browsers);
+  return complete ? { packageDir: folders.packageDir, browsers: folders.browsers, version: PLAYWRIGHT_VERSION, browser: String(saved.browser) } : null;
+}
+function browserEnv(browser) {
+  return { TAMSENSE_PLAYWRIGHT: browser.packageDir, TAMSENSE_PLAYWRIGHT_BROWSERS: browser.browsers };
+}
+function browserStatusText(browser) {
+  return `The headless browser is installed: ${browser.browser} with playwright-core ${browser.version}, in ${dirname(browser.browsers)}. To remove it, run ${BROWSER_COMMAND} remove`;
+}
+function findNpm(nodePath, env, exists) {
+  const pathKey = Object.keys(env).find((name) => name.toUpperCase() === "PATH") ?? "PATH";
+  const folders = [dirname(nodePath), ...(env[pathKey] ?? "").split(delimiter).filter(Boolean)];
+  for (const folder of folders) {
+    for (const cli of [join(folder, "node_modules", "npm", "bin", "npm-cli.js"), join(folder, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")]) {
+      if (exists(cli)) {
+        return cli;
+      }
+    }
+  }
+  return null;
+}
+var runProcess = (command, args, options) => new Promise((resolve, reject) => {
+  const child = spawn(command, args, { cwd: options.cwd, env: options.env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+  const tail = [];
+  for (const stream of [child.stdout, child.stderr]) {
+    createInterface({ input: stream }).on("line", (line) => {
+      const text2 = line.replace(ANSI_PATTERN, "").trim();
+      if (text2) {
+        tail.push(text2);
+        tail.splice(0, Math.max(0, tail.length - OUTPUT_TAIL_LINES));
+        options.onLine(text2);
+      }
+    });
+  }
+  child.on("error", reject);
+  child.on("close", (code) => resolve({ code: code ?? 1, output: tail.join("\n") }));
+});
+function failureText(what, result) {
+  if (OFFLINE_PATTERN.test(result.output)) {
+    return `${what}: ${OFFLINE_TEXT}`;
+  }
+  const lastLines = result.output.split("\n").slice(-ERROR_TAIL_LINES).join(" ");
+  return `${what} (exit code ${result.code})${lastLines ? `: ${lastLines}` : "."}`;
+}
+async function installBrowser(tools) {
+  const folders = browserFolders(tools.home);
+  const npmCli = findNpm(tools.nodePath, tools.env, tools.exists);
+  if (!npmCli) {
+    throw new Error(`npm was not found next to ${tools.nodePath} or on PATH. Install Node.js with npm and run ${BROWSER_COMMAND} again.`);
+  }
+  const showLine = (line) => tools.print(`  ${line}`);
+  await rm(folders.marker, { force: true });
+  await mkdir(folders.prefix, { recursive: true });
+  tools.print(`Step 1 of 2: downloading playwright-core ${PLAYWRIGHT_VERSION}\u2026`);
+  const npmArgs = [npmCli, "install", "--no-save", "--no-audit", "--no-fund", "--prefix", folders.prefix, `playwright-core@${PLAYWRIGHT_VERSION}`];
+  const npm = await tools.run(tools.nodePath, npmArgs, { cwd: folders.prefix, env: tools.env, onLine: showLine });
+  if (npm.code !== 0) {
+    throw new Error(failureText("npm could not download playwright-core", npm));
+  }
+  tools.print("Step 2 of 2: downloading the browser, about 150 MB\u2026");
+  const env = { ...tools.env, PLAYWRIGHT_BROWSERS_PATH: folders.browsers };
+  let result = { code: 1, output: "" };
+  for (const browser of BROWSER_NAMES) {
+    result = await tools.run(tools.nodePath, [join(folders.packageDir, "cli.js"), "install", browser], { cwd: folders.prefix, env, onLine: showLine });
+    if (result.code === 0) {
+      await writeFile(folders.marker, `${JSON.stringify({ version: PLAYWRIGHT_VERSION, browser }, null, 4)}
+`);
+      tools.print(`Installed ${browser} into ${folders.browsers}.`);
+      return { packageDir: folders.packageDir, browsers: folders.browsers, version: PLAYWRIGHT_VERSION, browser };
+    }
+    if (OFFLINE_PATTERN.test(result.output)) {
+      break;
+    }
+  }
+  throw new Error(failureText("Could not download the browser", result));
+}
+async function removeBrowser(home) {
+  const folders = browserFolders(home);
+  const present2 = existsSync(folders.prefix) || existsSync(folders.browsers);
+  await rm(folders.prefix, { recursive: true, force: true });
+  await rm(folders.browsers, { recursive: true, force: true });
+  return present2;
+}
+async function offerBrowser(tools) {
+  if (tools.declined) {
+    return null;
+  }
+  if (!tools.interactive) {
+    tools.print(BROWSER_HINT);
+    return null;
+  }
+  if (!await tools.ask(BROWSER_QUESTION)) {
+    await tools.rememberDecline();
+    tools.print(`Not installed. To install it later, run ${BROWSER_COMMAND}`);
+    return null;
+  }
+  try {
+    return await tools.install();
+  } catch (error) {
+    tools.print(`Could not install the browser: ${error instanceof Error ? error.message : String(error)}`);
+    tools.print("Tasks still run without it.");
+    return null;
+  }
+}
+
+// src/capabilities.ts
+import { homedir } from "os";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+var PROBE_TIMEOUT_MS = 6e4;
+var NO_ANSWER_TEXT = "Claude Code did not start in time.";
+var STOPPED_TEXT = "Stopped before Claude Code answered.";
+var API_KEY_SOURCES = /* @__PURE__ */ new Set(["ANTHROPIC_API_KEY", "apiKeyHelper", "/login managed key", "user", "project", "org", "temporary"]);
+var LOGIN_SOURCES = /* @__PURE__ */ new Set(["none", "oauth"]);
+var ACCOUNT_WORDS = {
+  subscription: "on your subscription",
+  api_key: "on an API key"
+};
+function accountOfKeySource(source) {
+  if (source && API_KEY_SOURCES.has(source)) {
+    return "api_key";
+  }
+  return source && LOGIN_SOURCES.has(source) ? "subscription" : null;
+}
+function accountOfInfo(info) {
+  if (info.apiProvider && info.apiProvider !== "firstParty") {
+    return null;
+  }
+  if (info.apiKeySource && API_KEY_SOURCES.has(info.apiKeySource)) {
+    return "api_key";
+  }
+  return info.subscriptionType ? "subscription" : null;
+}
+function sessionOf(init) {
+  return {
+    model: init.model || null,
+    account: accountOfKeySource(init.apiKeySource),
+    claudeVersion: init.claude_code_version || null
+  };
+}
+function capabilitiesOf(init) {
+  return {
+    account: accountOfInfo(init.account),
+    claudeVersion: init.claude_code_version || null,
+    models: init.models.map((model) => ({ value: model.value, displayName: model.displayName, description: model.description }))
+  };
+}
+function isAlias(value) {
+  return value !== "default" && !value.startsWith("claude-");
+}
+function capabilitiesLine(capabilities) {
+  const version = capabilities.claudeVersion ? `Claude Code ${capabilities.claudeVersion}` : "Claude Code";
+  const account = capabilities.account ? ` ${ACCOUNT_WORDS[capabilities.account]}` : "";
+  const names = capabilities.models.filter((model) => isAlias(model.value)).map((model) => model.displayName);
+  return names.length > 0 ? `${version}${account}: ${names.join(", ")}` : `${version}${account}`;
+}
+async function probeCapabilities(stop) {
+  stop?.throwIfAborted();
+  let release = () => {
+  };
+  const released = new Promise((resolve) => {
+    release = resolve;
+  });
+  const nothing = {
+    [Symbol.asyncIterator]: () => ({
+      next: async () => {
+        await released;
+        return { done: true, value: void 0 };
+      }
+    })
+  };
+  const session = query({ prompt: nothing, options: { cwd: homedir(), settingSources: ["user"], persistSession: false, strictMcpConfig: true } });
+  const timeout = AbortSignal.timeout(PROBE_TIMEOUT_MS);
+  const giveUp = stop ? AbortSignal.any([stop, timeout]) : timeout;
+  const gaveUp = new Promise((_, reject) => {
+    giveUp.addEventListener("abort", () => reject(new Error(stop?.aborted ? STOPPED_TEXT : NO_ANSWER_TEXT)), { once: true });
+  });
+  try {
+    return capabilitiesOf(await Promise.race([session.initializationResult(), gaveUp]));
+  } finally {
+    release();
+    session.close();
+  }
+}
+
+// src/claude.ts
+import { fileURLToPath } from "url";
+import { createSdkMcpServer, query as query2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
+import { z as z2 } from "zod";
+
+// src/claudeResult.ts
+var MAX_ACTIVITY_LENGTH = 120;
+var FILE_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var HELPER_TOOLS = /* @__PURE__ */ new Set(["Task", "Agent"]);
+function shorten(text2) {
+  const line = text2.replace(/\s+/g, " ").trim();
+  return line.length > MAX_ACTIVITY_LENGTH ? `${line.slice(0, MAX_ACTIVITY_LENGTH - 1)}\u2026` : line;
+}
+function activityLine(tool3, input) {
+  const fields = typeof input === "object" && input !== null ? input : {};
+  if (tool3 === "Bash" && typeof fields.command === "string") {
+    return `$ ${shorten(fields.command)}`;
+  }
+  if (FILE_TOOLS.has(tool3) && typeof fields.file_path === "string") {
+    return `${tool3} ${shorten(fields.file_path)}`;
+  }
+  if (tool3 === "Skill" && typeof fields.skill === "string") {
+    return `Skill ${shorten(fields.skill)}`;
+  }
+  if (HELPER_TOOLS.has(tool3) && typeof fields.subagent_type === "string") {
+    return `Agent ${shorten(fields.subagent_type)}`;
+  }
+  return tool3;
+}
+function usageOf(modelUsage) {
+  const entries = Object.values(modelUsage);
+  if (entries.length === 0) {
+    return null;
+  }
+  const sum = (pick) => entries.reduce((total, usage) => total + pick(usage), 0);
+  const inputTokens = sum((usage) => usage.inputTokens + usage.cacheReadInputTokens + usage.cacheCreationInputTokens);
+  const outputTokens = sum((usage) => usage.outputTokens);
+  return { inputTokens, cachedInputTokens: sum((usage) => usage.cacheReadInputTokens), outputTokens, totalTokens: inputTokens + outputTokens };
+}
+function mainModel(modelUsage) {
+  const ranked = Object.entries(modelUsage).sort(([, first], [, second]) => second.outputTokens - first.outputTokens);
+  return ranked[0]?.[0] ?? null;
+}
+function outcomeOf(result, lastText) {
+  const measured = { model: mainModel(result.modelUsage), usage: usageOf(result.modelUsage), verdict: null };
+  if (result.subtype === "success") {
+    return { completed: !result.is_error, report: result.result || lastText, ...measured };
+  }
+  return { completed: false, report: result.errors.join("\n") || `Claude stopped early: ${result.subtype}`, ...measured };
+}
+
+// src/feed.ts
+var MAX_TEXT_LENGTH = 8e3;
+var MAX_RESULT_LENGTH = 2e3;
+var MAX_SUMMARY_LENGTH = 500;
+var HELPER_TOOLS2 = /* @__PURE__ */ new Set(["Task", "Agent"]);
+var MCP_PREFIX = /^mcp__[^_]+(?:_[^_]+)*__/;
+var ATTACH_LABELS = { attach_screenshot: "Screenshot", attach_replay: "Replay", attach_video: "Video" };
+function clip(text2, max) {
+  const trimmed = text2.trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max - 1)}\u2026` : trimmed;
+}
+function fieldsOf(input) {
+  return typeof input === "object" && input !== null ? input : {};
+}
+function textField(fields, name) {
+  const value = fields[name];
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function toolDraft(block, parent) {
+  const tool3 = (block.name ?? "tool").replace(MCP_PREFIX, "");
+  const fields = fieldsOf(block.input);
+  const base = { tool: tool3, ref: block.id ?? null, parent, failed: false };
+  if (tool3 === "Skill" && textField(fields, "skill")) {
+    return { ...base, kind: "skill", text: clip(textField(fields, "skill"), MAX_SUMMARY_LENGTH) };
+  }
+  if (HELPER_TOOLS2.has(tool3)) {
+    const who = textField(fields, "subagent_type") ?? "general-purpose";
+    const what = textField(fields, "description");
+    return { ...base, kind: "agent", text: clip(what ? `${who}: ${what}` : who, MAX_SUMMARY_LENGTH) };
+  }
+  if (tool3 === "submit_verdict") {
+    const verdict = fields.passed === true ? "Passed" : "Did not pass";
+    return { ...base, kind: "tool", text: clip(`${verdict}. ${textField(fields, "report") ?? ""}`, MAX_SUMMARY_LENGTH) };
+  }
+  if (tool3 === "hand_off") {
+    return { ...base, kind: "tool", text: clip(`Hand off to ${textField(fields, "to") ?? "?"}: ${textField(fields, "note") ?? ""}`, MAX_SUMMARY_LENGTH) };
+  }
+  if (tool3 in ATTACH_LABELS) {
+    return { ...base, kind: "tool", text: clip(`${ATTACH_LABELS[tool3]}: ${textField(fields, "title") ?? textField(fields, "path") ?? ""}`, MAX_SUMMARY_LENGTH) };
+  }
+  const command = textField(fields, "command");
+  const summary = tool3 === "Bash" && command ? `$ ${command}` : activityLine(tool3, block.input);
+  return { ...base, kind: "tool", text: clip(summary, MAX_SUMMARY_LENGTH) };
+}
+function resultText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((part) => part.type === "text" ? part.text ?? "" : part.type === "image" ? "[image]" : "").filter(Boolean).join("\n");
+}
+function feedOf(message) {
+  if (message.type !== "assistant" && message.type !== "user") {
+    return [];
+  }
+  const parent = message.parent_tool_use_id ?? null;
+  const content = message.message.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const drafts = [];
+  for (const block of content) {
+    if (message.type === "assistant" && block.type === "thinking" && block.thinking?.trim()) {
+      drafts.push({ kind: "thinking", text: clip(block.thinking, MAX_TEXT_LENGTH), tool: null, ref: null, parent, failed: false });
+    } 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));
+    } 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 });
+    }
+  }
+  return drafts;
+}
+var CONSOLE_LABELS = { tool: "", skill: "Skill ", agent: "Agent " };
+var MAX_CONSOLE_LENGTH = 120;
+function consoleLine(draft) {
+  const label = CONSOLE_LABELS[draft.kind];
+  return label === void 0 ? null : clip(`${label}${draft.text}`.replace(/\s+/g, " "), MAX_CONSOLE_LENGTH);
+}
+var HIDDEN_TOOLS = /* @__PURE__ */ new Set(["ToolSearch", "SubagentHandback"]);
+function hiddenStepsFilter() {
+  const hidden = /* @__PURE__ */ new Set();
+  return (draft) => {
+    if (draft.kind === "tool" && draft.tool && HIDDEN_TOOLS.has(draft.tool)) {
+      if (draft.ref) {
+        hidden.add(draft.ref);
+      }
+      return false;
+    }
+    return !(draft.kind === "result" && draft.ref && hidden.has(draft.ref));
+  };
+}
+
+// src/handoff.ts
+var HANDOFF_OUTCOMES = ["pass", "problems", "ask"];
+function handoffTargetLine(target) {
+  return target.label ? `${target.name} (${target.outcome}: ${target.label})` : `${target.name} (${target.outcome})`;
+}
+function validTargets(targets) {
+  return `Valid targets: ${targets.map(handoffTargetLine).join(", ")}.`;
+}
+function chooseHandoff(targets, request) {
+  const to = request.to.trim();
+  const note = request.note.trim();
+  if (!note) {
+    return { error: "Write a note for the next agent and the owner: what was done, what to check and what is open." };
+  }
+  const matching = targets.filter((target) => target.name.toLowerCase() === to.toLowerCase() || String(target.columnId) === to);
+  if (matching.length === 0) {
+    return { error: `"${to}" is not a step this task can be handed to. ${validTargets(targets)}` };
+  }
+  const edge = matching.find((target) => target.outcome === request.outcome);
+  if (!edge) {
+    return { error: `${matching[0].name} does not take the outcome "${request.outcome}". ${validTargets(targets)}` };
+  }
+  return { handoff: { toColumnId: edge.columnId, outcome: edge.outcome, note } };
+}
+
+// src/input.ts
+var DEFAULT_MODEL = "default";
+var QUIET_MS = 1e3;
+var IDLE_LIMIT_MS = 3e4;
+function userMessage(text2) {
+  return { type: "user", message: { role: "user", content: text2 }, parent_tool_use_id: null };
+}
+function humanText(message) {
+  return `Message from ${message.authorName}: ${message.text}`;
+}
+function humanMessage(message) {
+  return { ...userMessage(humanText(message)), priority: message.mode === "steer" ? "now" : "next", client_composed: true };
+}
+function switchLine(change) {
+  const model = change.model === DEFAULT_MODEL ? "the default model" : change.model;
+  const effort = change.effort && `${change.effort} effort`;
+  return `Switched to ${[model, effort].filter(Boolean).join(", ")}`;
+}
+function isActivity(message) {
+  return message.type === "assistant" || message.type === "user" || message.type === "system" && message.subtype === "init";
+}
+function inputChannel(options = {}) {
+  const queue = [];
+  const seen = /* @__PURE__ */ new Set();
+  let delivered = [];
+  let started = false;
+  let opening = "";
+  let generation = 0;
+  let closed = false;
+  let idle = false;
+  let active = false;
+  let interrupted = 0;
+  let drained = false;
+  let quiet = false;
+  let idleEpoch = 0;
+  let inFlight = 0;
+  let statesSeen = false;
+  let wake = null;
+  let timers = [];
+  let applySwitch2 = null;
+  let waitingSwitch = null;
+  function wakeUp() {
+    wake?.();
+    wake = null;
+  }
+  function clearTimers() {
+    timers.forEach(clearTimeout);
+    timers = [];
+  }
+  function close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    clearTimers();
+    waitingSwitch?.resolve(false);
+    waitingSwitch = null;
+    wakeUp();
+  }
+  function maybeClose() {
+    if (started && idle && drained && quiet && queue.length === 0 && inFlight === 0) {
+      close();
+    }
+  }
+  function turnStarted() {
+    idle = false;
+    clearTimers();
+  }
+  function turnEnded() {
+    if (closed || idle) {
+      return;
+    }
+    idle = true;
+    idleEpoch += 1;
+    drained = !options.onIdle;
+    quiet = false;
+    timers = [
+      setTimeout(() => {
+        quiet = true;
+        maybeClose();
+      }, options.quietMs ?? QUIET_MS),
+      setTimeout(close, options.idleLimitMs ?? IDLE_LIMIT_MS)
+    ];
+    options.onIdle?.();
+  }
+  async function* stream(own) {
+    for (; ; ) {
+      if (closed || own !== generation) {
+        return;
+      }
+      const next = queue.shift();
+      if (!next) {
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+        continue;
+      }
+      if (active && !idle && next.message.priority === "now") {
+        interrupted += 1;
+      }
+      turnStarted();
+      delivered.push(...next.ids);
+      yield next.message;
+    }
+  }
+  return {
+    get closed() {
+      return closed;
+    },
+    // Сообщения, пришедшие, пока готовился код, идут вместе с задачей.
+    // Повторный start для нового Claude Code (прошлый сеанс не открылся) шлёт то же первое сообщение снова, а прежний поток кончается
+    start(prompt) {
+      if (started) {
+        queue.unshift({ ids: [], message: userMessage(opening) });
+      } else {
+        started = true;
+        const early = queue.splice(0);
+        opening = [prompt, ...early.map((item) => item.message.message.content)].join("\n\n");
+        queue.push({ ids: early.flatMap((item) => item.ids), message: userMessage(opening) });
+      }
+      generation += 1;
+      wakeUp();
+      return stream(generation);
+    },
+    // Если Claude Code сообщает состояние сессии, верим только ему: idle приходит после фоновых задач
+    observe(message) {
+      if (message.type === "system" && message.subtype === "session_state_changed") {
+        statesSeen = true;
+        if (message.state === "idle") {
+          turnEnded();
+        } else {
+          turnStarted();
+        }
+        return;
+      }
+      if (statesSeen) {
+        return;
+      }
+      if (message.type === "result") {
+        active = false;
+        if (interrupted > 0) {
+          interrupted -= 1;
+          return;
+        }
+        turnEnded();
+      } else if (isActivity(message)) {
+        active = true;
+        turnStarted();
+      }
+    },
+    onSwitch(apply) {
+      applySwitch2 = apply;
+      if (waitingSwitch) {
+        const { change, resolve } = waitingSwitch;
+        waitingSwitch = null;
+        void apply(change).then(() => resolve(true), () => resolve(false));
+      }
+    },
+    close,
+    push(message) {
+      if (closed || seen.has(message.id)) {
+        return false;
+      }
+      seen.add(message.id);
+      queue.push({ ids: [message.id], message: humanMessage(message) });
+      wakeUp();
+      return true;
+    },
+    async checking(work2) {
+      const epoch = idle ? idleEpoch : null;
+      inFlight += 1;
+      try {
+        await work2();
+      } finally {
+        inFlight -= 1;
+        if (idle && epoch === idleEpoch) {
+          drained = true;
+        }
+        maybeClose();
+      }
+    },
+    takeDelivered() {
+      const ids = delivered;
+      delivered = [];
+      return ids;
+    },
+    restoreDelivered(ids) {
+      delivered = [...ids, ...delivered];
+    },
+    hasDelivered: () => delivered.length > 0,
+    // До запуска Claude смена ждёт его; после конца работы менять уже нечего
+    async switchModel(change) {
+      if (closed) {
+        return false;
+      }
+      if (applySwitch2) {
+        await applySwitch2(change);
+        return true;
+      }
+      const earlier = waitingSwitch;
+      earlier?.resolve(false);
+      const merged = { model: change.model ?? earlier?.change.model ?? null, effort: change.effort ?? earlier?.change.effort ?? null };
+      return new Promise((resolve) => {
+        waitingSwitch = { change: merged, resolve };
+      });
+    }
+  };
+}
+
+// src/specText.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function texts(value) {
+  return Array.isArray(value) ? value.map(text).filter(Boolean) : [];
+}
+function records(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function section(title, lines) {
+  return lines.length > 0 ? `${title}
+${lines.join("\n")}` : null;
+}
+function criterionLine(value) {
+  if (typeof value === "string") {
+    return value.trim() ? `- ${value.trim()}` : null;
+  }
+  if (!isRecord(value) || !text(value.text)) {
+    return null;
+  }
+  const kind = ["main", "edge", "keep"].includes(value.kind) ? `(${value.kind})` : "";
+  const head = [text(value.id), kind].filter(Boolean).join(" ");
+  return `- ${head ? `${head}: ` : ""}${text(value.text)}`;
+}
+function assumptionLine(value) {
+  if (typeof value === "string") {
+    return value.trim() ? `- ${value.trim()}` : null;
+  }
+  if (!isRecord(value) || !text(value.text)) {
+    return null;
+  }
+  return `- ${text(value.text)}${text(value.reason) ? ` (${text(value.reason)})` : ""}`;
+}
+function changeLines(change, index) {
+  const action = ["create", "modify", "delete"].includes(change.action) ? ` (${change.action})` : "";
+  const [produces, consumes, acceptance] = [texts(change.produces), texts(change.consumes), texts(change.acceptance)];
+  return [
+    `${index + 1}. ${text(change.repo) ? `${text(change.repo)} ` : ""}${text(change.file)}${action}: ${text(change.description)}`,
+    ...produces.length > 0 ? [`   Produces: ${produces.join("; ")}`] : [],
+    ...consumes.length > 0 ? [`   Consumes: ${consumes.join("; ")}`] : [],
+    ...acceptance.length > 0 ? [`   Makes true: ${acceptance.join(", ")}`] : []
+  ];
+}
+var CODE_USE_TEXT = { reuse: "reuse", change: "change", keep: "do not touch" };
+var RISK_LEVELS = ["low", "medium", "high"];
+function present(lines) {
+  return lines.filter((line) => line !== null);
+}
+function specPromptText(spec) {
+  if (!isRecord(spec)) {
+    return null;
+  }
+  const structured = Array.isArray(spec.outOfScope) || isRecord(spec.testPlan);
+  const plan = isRecord(spec.testPlan) ? spec.testPlan : {};
+  const risks = records(spec.risks).filter((item) => text(item.risk));
+  const riskLevel = RISK_LEVELS.includes(spec.riskLevel) ? spec.riskLevel : null;
+  return [
+    text(spec.goal) && `Goal: ${text(spec.goal)}`,
+    text(spec.context) && `${structured ? "Summary" : "Context"}: ${text(spec.context)}`,
+    section("In scope:", texts(spec.inScope).map((item) => `- ${item}`)),
+    section("Out of scope (do not build):", texts(spec.outOfScope).map((item) => `- ${item}`)),
+    section("Decisions:", records(spec.decisions).filter((item) => text(item.question) && text(item.answer)).map((item) => `- ${text(item.question)} \u2192 ${text(item.answer)} (${item.by === "agent" ? "agent's call" : "owner"})`)),
+    section("Code map:", records(spec.codeMap).filter((item) => text(item.file)).map((item) => `- ${text(item.repo) ? `${text(item.repo)} ` : ""}${text(item.file)}: ${text(item.role)}${CODE_USE_TEXT[item.use] ? ` [${CODE_USE_TEXT[item.use]}]` : ""}`)),
+    section("Changes, in order:", records(spec.changes).filter((item) => text(item.file)).flatMap(changeLines)),
+    section("Acceptance criteria:", present(Array.isArray(spec.acceptance) ? spec.acceptance.map(criterionLine) : [])),
+    section("Test plan:", [
+      ...records(plan.automated).filter((item) => text(item.command)).map((item) => `- Run in ${text(item.repo) || "the repository"}: ${text(item.command)}${text(item.expect) ? `. Passing: ${text(item.expect)}` : ""}`),
+      ...records(plan.newTests).filter((item) => text(item.seam)).map((item) => `- New test at ${text(item.seam)}${texts(item.covers).length > 0 ? `, covers ${texts(item.covers).join(", ")}` : ""}`),
+      ...records(plan.manual).filter((item) => text(item.steps)).map((item) => `- By hand${text(item.page) ? ` on ${text(item.page)}` : ""}: ${text(item.steps)}`)
+    ]),
+    risks.length > 0 ? section(`Risks${riskLevel ? ` (risk level ${riskLevel})` : ""}:`, risks.map((item) => `- ${text(item.risk)}${text(item.mitigation) ? `. Mitigation: ${text(item.mitigation)}` : ""}`)) : riskLevel && `Risk level: ${riskLevel}`,
+    section("Assumptions:", present(Array.isArray(spec.assumptions) ? spec.assumptions.map(assumptionLine) : [])),
+    section("Open questions (not answered yet):", records(spec.openQuestions).filter((item) => text(item.question)).map((item) => `- ${text(item.question)}`))
+  ].filter(Boolean).join("\n\n");
+}
+
+// src/prompt.ts
+var VERDICT_TOOL_NAME = "submit_verdict";
+var SCREENSHOT_TOOL_NAME = "attach_screenshot";
+var REPLAY_TOOL_NAME = "attach_replay";
+var VIDEO_TOOL_NAME = "attach_video";
+var HANDOFF_TOOL_NAME = "hand_off";
+var SUBMIT_QUESTIONS_TOOL_NAME = "submit_questions";
+var SUBMIT_SPEC_TOOL_NAME = "submit_spec";
+var UNATTENDED_RULE = `You are working on a TAMsense task on the user's own computer. People on the task may send you messages during this run, each starting with "Message from <name>:". Follow them: they take priority over the original task where the two disagree. Nobody answers questions or approves actions during the run, so never stop to wait for a reply: decide yourself, keep working, and explain your decisions in your report.`;
+var MACHINE_RULE = "This is the person's own computer, and their other programs may be running on it. Stop only the processes you started yourself, by their process id, and stop them before you finish. Never kill processes by name or pattern (taskkill /IM, pkill, killall, Stop-Process -Name) and never touch programs you did not start.";
+var CODE_RULES = [
+  "Make the changes the task asks for, and keep them focused on it.",
+  "When there is an approved spec, follow it: make the changes in its order with the names and data shapes it gives, build nothing from its out of scope list, and add the tests and run the commands of its test plan.",
+  "Check your work with the project's own tools: run the tests, type checks and linters that exist, and fix what you broke.",
+  "Commit your work in every repository you changed, on the current branch. Do not push, do not switch or create branches, and do not rewrite history: TAMsense pushes the branch and opens the pull request."
+];
+var REWORK_RULE = "This is a rework. The branch already has the earlier work and maybe the reviewer's own commits: treat the current branch as the source of truth, keep the reviewer's changes unless a comment asks otherwise, and address every comment.";
+var CODE_REPORT_RULE = "End with a short report for the reviewer: what you changed, how you checked it, and anything left open.";
+var CHECK_RULES = [
+  "The work to check is on the current branch. See it with git diff against the base branch named for each repository below, and read the code around it.",
+  "Do not change, commit or push product code. You may run anything and create throwaway files outside the repositories.",
+  "Judge against the task, the spec and its acceptance criteria, checking each criterion by its id (AC-1 and so on) when the spec has ids. Be specific: every problem gets a file, a line and what to do about it.",
+  `Finish by calling the ${VERDICT_TOOL_NAME} tool exactly once: passed is true only if nothing must be fixed; report says what you checked and, if it failed, exactly what to fix.`
+];
+var SCREENSHOT_RULE = `If you render screens (screenshots of the interface), attach the ones that show the result with the ${SCREENSHOT_TOOL_NAME} tool. People see them on the task without opening the code.`;
+var NAMING_RULE = 'Name everything you attach (screenshots, replays, videos) by what it shows and why it was made: a short title such as "Design option 1", "Feature testing" or "Feature testing, attempt 2", and a one-line purpose such as "Comparing two layouts for the empty orders state". Number design variants, name test runs by their goal and attempt, and never use generic names like "screenshot1".';
+var RECORDING_RULE = `Every browser you open with Playwright from Node is recorded for the task as a replay people can watch, and requests from the tested site to the TAMsense tracker are blocked, so your runs never reach analytics. In every browser script, load the recorder from the TAMSENSE_RECORDER environment variable (require(process.env.TAMSENSE_RECORDER), or createRequire(import.meta.url)(process.env.TAMSENSE_RECORDER) in an .mjs script), open each context with await recorder.newRecordedContext(browser, { title, purpose, context: { viewport } }), call await recorder.mark(page, 'what just happened') at every meaningful step, and end with await recorder.closeRecorded(context). Add video: true when the page has a canvas, a map, a video player or iframes from another site (a replay cannot show them), or when someone asks for a video. Recordings are attached to the task when the run ends; ${REPLAY_TOOL_NAME} and ${VIDEO_TOOL_NAME} attach one earlier with a better title.`;
+var BROWSER_RULE = "A headless browser is installed for interface checks. If the project has no Playwright of its own, load playwright-core from the folder in the TAMSENSE_PLAYWRIGHT environment variable, with PLAYWRIGHT_BROWSERS_PATH set to the folder in TAMSENSE_PLAYWRIGHT_BROWSERS. Never install browsers or packages yourself.";
+var STAGE_GOALS = {
+  code: "Implement",
+  review: "Review the code for",
+  test: "Test"
+};
+var SPEC_UNATTENDED_RULE = `You are preparing a TAMsense task on the user's own computer. Nobody answers you during this run: the owner answers your questions and reviews the spec on the task page after it. So never stop to wait for a reply and never ask in your messages: hand in what this stage asks for with the TAMsense tool, then finish. People on the task may send you messages during this run, each starting with "Message from <name>:". Follow them.`;
+var READ_ONLY_RULE = "Read the code to research the task. Do not change, commit or push anything: nothing from this run is pushed, and the code step starts from a clean branch.";
+var RESEARCH_RULE = "Start by loading the tamsense:task-interview skill with the Skill tool and follow it: it holds the question test, the corner sweep and the rules for rounds. Research before asking: read the code in the repositories here and the evidence of the linked action, if there is one. Finding facts is your job; the decisions about intent are the owner's.";
+var BRIEF_RULE = "Write the brief as you go: findings (what the code does today that matters, each with owner/repo path:line), dataFacts (numbers and facts from the linked action, each with its source; empty when none), approach (2 to 4 sentences), codeMap (the files the change will touch or must reuse, each with its role), 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 QUESTION_SHAPE_RULE = 'Each question has a snake_case id, one plain sentence the owner can answer without reading code, a whyItMatters line, and 2 to 4 concrete options grounded in what you saw, each saying what happens if it is chosen. Put the option you recommend first and set recommended on it (in a multiSelect question, on every option you recommend). multiSelect is true only when the options are additive. Never add an "Other" option: the page adds a free-text field. An unanswered question takes your recommended option, so recommend the one you would defend.';
+var QUESTIONS_REPLY_RULE = "Then reply in one or two plain sentences: what you understood from the code and why you ask these questions, or that no questions are needed. Do not repeat the questions: the page shows them.";
+var SPEC_RULES = [
+  "Start by loading the tamsense:spec-writing skill with the Skill tool and follow it: it holds the shape of the spec, the rules for acceptance criteria, the size budget, the lint list and the builder check.",
+  "Start from the brief and the conversation below. Verify in the code what the spec depends on and research only what is missing; without a brief, research first as the tamsense task-interview skill describes.",
+  '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". If an answer contradicts the code or another answer, check the code before following it and say so in your reply.',
+  "Where the task, the answers and the project context are silent and a safe default exists, choose it and record it as an assumption with its reason. A point with no safe default that changes the scope or the behaviour becomes an open question; keep them to 3 at most.",
+  "Before you hand the spec in, run the builder check of the skill once. It is required, also for a small task: start one fresh general-purpose subagent with the Agent tool, give it only the spec as text inside the builder check prompt of the skill, and settle each point it reports as the skill says.",
+  `Hand in the FULL spec with ${SUBMIT_SPEC_TOOL_NAME}. TAMsense lints it and checks the files, and sends it back once if no fresh reader has checked it; if it returns feedback, the spec was not saved: fix it and call ${SUBMIT_SPEC_TOOL_NAME} again. After two rounds of lint feedback the spec is saved as it is.`,
+  "When the task already has a saved spec, the conversation holds the owner's feedback or answers to its open questions: apply them and hand in the full updated spec. An answered open question becomes a decision; a corrected or confirmed assumption becomes a decision and leaves the assumptions.",
+  "Then reply with a short plain summary: the approach, the risk level and the open questions, if any. Do not paste the spec: the page shows it."
+];
+var SPEC_WORK_MISSING = "TAMsense sent a spec step without its round and brief.";
+var SPEC_STYLE_RULE = "Write the brief, the questions, the spec and your reply in the language the task is written in. Replies are plain text, no Markdown. Use real file paths, function and table names; if you could not verify something, say so. No em dashes and no en dashes; use commas, colons or a plain hyphen.";
+function specText(spec) {
+  const text2 = specPromptText(spec);
+  return text2 ? `Approved spec:
+${text2}` : null;
+}
+function contextText(context) {
+  return context.trim() ? `Project context from the team (follow it like the project's own rules):
+${context.trim()}` : null;
+}
+function bulletList(lines) {
+  return lines.map((line) => `- ${line}`).join("\n");
+}
+function repositoryLines(job, workspace) {
+  const sourceOf = new Map(job.repositories.map((repository) => [repository.fullName, repository]));
+  return workspace.repositories.map((repository) => {
+    const source = sourceOf.get(repository.fullName);
+    const pull = source?.pullRequestUrl ? `, pull request ${source.pullRequestUrl}` : "";
+    return `${repository.folder} (${repository.fullName}), base branch origin/${source?.defaultBranch ?? "main"}${pull}`;
+  });
+}
+function stepLine(stage) {
+  return `This step of the board is "${stage.name}"${stage.helper ? `, and you work as the ${stage.helper}` : ""}.`;
+}
+function teamMessagesText(messages) {
+  return messages.length > 0 ? `Messages from the team before this run:
+${messages.map((message) => `${message.authorName}: ${message.text}`).join("\n")}` : null;
+}
+function handoffText(targets, isCheck) {
+  if (targets.length === 0) {
+    return null;
+  }
+  return [
+    `When you finish, hand the task on with the ${HANDOFF_TOOL_NAME} tool. Write a clear note for the next agent and the task owner: what was done, what to check and what is still open. The steps this task can go to from here:`,
+    bulletList(targets.map(handoffTargetLine)),
+    `If none of them fits, just finish without handing off.${isCheck ? ` Hand in your verdict with ${VERDICT_TOOL_NAME} as well.` : ""}`
+  ].join("\n");
+}
+function threadText(thread) {
+  if (thread.length === 0) {
+    return null;
+  }
+  const lines = thread.map((message) => `${message.role === "user" ? "Owner" : "You, earlier"}: ${message.text}`);
+  return `The conversation on the task so far (answers to the questions and the owner's feedback):
+${lines.join("\n\n")}`;
+}
+function questionRules(work2) {
+  const handIn = `Call ${SUBMIT_QUESTIONS_TOOL_NAME} once with the brief and the questions, or an empty list when none are needed. If it returns problems, fix them and call it again.`;
+  if (work2.round === 1) {
+    return [
+      RESEARCH_RULE,
+      BRIEF_RULE,
+      `Ask 0 to ${work2.maxQuestions} questions, ideally 2 or 3, the most important first, and only the ones that pass the three tests of the skill. Zero questions is a good result: the spec is then written right away. Ask only questions that do not depend on another question of this round; put a dependent decision into pendingDecisions.`,
+      QUESTION_SHAPE_RULE,
+      handIn,
+      QUESTIONS_REPLY_RULE
+    ];
+  }
+  const taken = work2.takenIds.length > 0 ? ` These ids are taken by round 1: ${work2.takenIds.join(", ")}.` : "";
+  return [
+    `This is the follow-up round ${work2.round} of 2, and there is no round after it. Follow the tamsense:task-interview skill (load it with the Skill tool if this conversation has not loaded it yet). Read the answers in the conversation below. Do not research again what your brief covers; check only what the answers changed.`,
+    `Ask at most ${work2.maxQuestions} more questions, and only when an answer is vague ("not sure", "depends", "maybe"), contradicts another answer or the code, or unlocked a decision from pendingDecisions that passes the tests of the tamsense task-interview skill. Otherwise hand in no questions: whatever is still open becomes an assumption.${taken}`,
+    QUESTION_SHAPE_RULE,
+    "Update the brief with what the answers changed and leave pendingDecisions empty.",
+    handIn,
+    QUESTIONS_REPLY_RULE
+  ];
+}
+function specGoal(job, work2) {
+  if (work2.round === null) {
+    return `Write the spec for TAMsense task #${job.taskId}: ${job.title}`;
+  }
+  return work2.round > 1 ? `Follow-up questions for TAMsense task #${job.taskId}: ${job.title}` : `Prepare TAMsense task #${job.taskId} for its spec: ${job.title}`;
+}
+function buildSpecPrompt(job, work2, workspace) {
+  const prompt = [
+    specGoal(job, work2),
+    job.description,
+    work2.linkedAction,
+    work2.brief ? `Brief from the clarification phase (research already done, verify only what you rely on):
+${JSON.stringify(work2.brief)}` : null,
+    work2.round === null && job.spec ? `Current saved spec (hand in the full updated version):
+${JSON.stringify(job.spec)}` : null,
+    job.handoffNote && `Note from another step: ${job.handoffNote}`,
+    threadText(work2.thread),
+    teamMessagesText(job.messages)
+  ].filter(Boolean).join("\n\n");
+  const instructions = [
+    SPEC_UNATTENDED_RULE,
+    MACHINE_RULE,
+    stepLine(job.stage),
+    job.stage.instructions,
+    contextText(job.projectContext),
+    `The repositories for this task are checked out in the current folder, one subfolder each:
+${bulletList(repositoryLines(job, workspace))}`,
+    READ_ONLY_RULE,
+    `How to work:
+${bulletList(work2.round === null ? SPEC_RULES : questionRules(work2))}`,
+    SPEC_STYLE_RULE
+  ].filter(Boolean).join("\n\n");
+  return { prompt, instructions };
+}
+function buildTaskPrompt(job, workspace, options = {}) {
+  const { kind } = job.stage;
+  if (kind === "interview" || kind === "spec") {
+    if (!job.specWork) {
+      throw new Error(SPEC_WORK_MISSING);
+    }
+    return buildSpecPrompt(job, job.specWork, workspace);
+  }
+  const isCheck = kind !== "code";
+  const prompt = [
+    `${STAGE_GOALS[kind]} TAMsense task #${job.taskId}: ${job.title}`,
+    job.description,
+    specText(job.spec),
+    job.handoffNote && `Note from the previous step: ${job.handoffNote}`,
+    job.review && `Review comments to address:
+${job.review}`,
+    teamMessagesText(job.messages)
+  ].filter(Boolean).join("\n\n");
+  const evidence = [SCREENSHOT_RULE, ...options.recorder ? [RECORDING_RULE] : [], NAMING_RULE];
+  const rules = isCheck ? [...CHECK_RULES, ...evidence] : [...CODE_RULES, ...job.review ? [REWORK_RULE] : [], ...evidence, CODE_REPORT_RULE];
+  const instructions = [
+    UNATTENDED_RULE,
+    MACHINE_RULE,
+    stepLine(job.stage),
+    job.stage.instructions,
+    contextText(job.projectContext),
+    `The repositories for this task are checked out in the current folder, one subfolder each, on branch ${job.branch}:
+${bulletList(repositoryLines(job, workspace))}`,
+    `How to work:
+${bulletList(rules)}`,
+    handoffText(job.allowedHandoffs, isCheck),
+    options.browser && BROWSER_RULE
+  ].filter(Boolean).join("\n\n");
+  return { prompt, instructions };
+}
+
+// src/specTools.ts
+import { tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+var MAX_FIRST_ROUND = 4;
+var questionSchema = z.object({
+  id: z.string().describe('Stable snake_case id, unique in the task, for example "empty_state"'),
+  question: z.string().describe("One plain sentence the owner can answer without reading code"),
+  whyItMatters: z.string().describe("One line: what changes in the result depending on the answer"),
+  options: z.array(z.object({
+    label: z.string().describe('Short, concrete answer (1-6 words), without "(Recommended)": use the recommended flag'),
+    description: z.string().describe("One sentence: what happens if this option is chosen"),
+    recommended: z.boolean().describe("true on the option you recommend (in a multiSelect question, on every option you recommend). Recommended options come first")
+  })).min(2).max(4).describe('2-4 mutually exclusive options grounded in the code and data. The UI always adds a free-text "Other" field, so never add "Other" yourself'),
+  multiSelect: z.boolean().describe("true only when the options are additive and several can apply together")
+});
+var briefSchema = z.object({
+  findings: z.array(z.object({
+    fact: z.string().describe("What the code does today that matters for this task"),
+    where: z.string().describe("Where it is: owner/repo path:line")
+  })).describe("Findings from the code"),
+  dataFacts: z.array(z.string()).describe("Numbers and facts from the events or the business data, each with its source. Empty when the task needs no data"),
+  approach: z.string().describe("The approach you would take, in 2-4 sentences"),
+  codeMap: z.array(z.object({
+    repo: z.string().describe("Repository full name (owner/name)"),
+    file: z.string().describe("Path relative to the repository root"),
+    role: z.string().describe("Why it matters: what to change or reuse there")
+  })).describe("The files the change will touch or must reuse"),
+  assumptions: z.array(z.object({
+    text: z.string().describe("The default you chose"),
+    reason: z.string().describe("Why it is safe or why it was chosen")
+  })).describe("Corners settled with a default instead of a question"),
+  pendingDecisions: z.array(z.string()).describe("Decisions that depend on an answer to this round and cannot be asked yet. Empty when none")
+});
+var questionsPayloadSchema = z.object({
+  brief: briefSchema,
+  questions: z.array(questionSchema).max(MAX_FIRST_ROUND).describe(`0-${MAX_FIRST_ROUND} questions that pass the question test, most important first. An empty list when research settled everything`)
+});
+var specSchema = z.object({
+  goal: z.string().describe("The problem solved, for whom, and the outcome a user or the business will notice"),
+  context: z.string().describe("Summary: the problem in 1-2 sentences, then the chosen approach in 1-2 sentences"),
+  inScope: z.array(z.string()).describe("What this task delivers, one item each"),
+  outOfScope: z.array(z.string()).describe("What this task does not do: nearby additions a coder might be tempted to make and approaches that are ruled out. Never empty"),
+  decisions: z.array(z.object({
+    question: z.string(),
+    answer: z.string(),
+    by: z.enum(["owner", "agent"]).describe("owner: answered by a person; agent: your own call")
+  })).describe("Every answered question with by: owner, and your own calls that matter with by: agent"),
+  codeMap: z.array(z.object({
+    repo: z.string().describe("Repository full name (owner/name)"),
+    file: z.string().describe("Path relative to the repository root"),
+    role: z.string().describe("What the coder needs to know about this file"),
+    use: z.enum(["reuse", "change", "keep"]).describe("reuse: build on it; change: it is in changes; keep: do not touch")
+  })).describe("The files a coder must read before starting"),
+  changes: z.array(z.object({
+    repo: z.string().describe("Repository full name (owner/name) where the change happens"),
+    file: z.string().describe("Path to the file, relative to the repository root"),
+    action: z.enum(["create", "modify", "delete"]),
+    description: z.string().describe("The behaviour the file has after the change and which existing functions or patterns to extend. No code snippets or diffs"),
+    produces: z.array(z.string()).describe("Names with signatures or data shapes this change creates or changes for other changes. Empty when none"),
+    consumes: z.array(z.string()).describe("Names with signatures or data shapes this change uses from earlier changes. Empty when none"),
+    acceptance: z.array(z.string()).describe("Ids of the criteria this change makes true, like AC-1")
+  })).min(1).describe("File changes in dependency order: each uses only what earlier changes or the code already provide"),
+  acceptance: z.array(z.object({
+    id: z.string().describe("AC-1, AC-2 and so on, in order"),
+    kind: z.enum(["main", "edge", "keep"]).describe("main: the main path; edge: an error, empty or limit case; keep: existing behaviour that must keep working"),
+    text: z.string().describe('"Given <state>, when <action>, then <observable result>", saying where to look. No file paths or function names')
+  })).min(1).describe("Acceptance criteria: main path first, then edge cases, then what must keep working"),
+  testPlan: z.object({
+    automated: z.array(z.object({
+      repo: z.string(),
+      command: z.string().describe("The exact command to run"),
+      expect: z.string().describe("What passing looks like")
+    })).describe("At least one command"),
+    newTests: z.array(z.object({
+      seam: z.string().describe("Where the test goes: the highest seam that covers the behaviour (an endpoint, a page, a public function)"),
+      covers: z.array(z.string()).describe("Ids of the criteria it covers")
+    })),
+    manual: z.array(z.object({
+      page: z.string().describe("The page or screen"),
+      steps: z.string().describe("What a person does and sees")
+    }))
+  }),
+  risks: z.array(z.object({
+    risk: z.string(),
+    mitigation: z.string()
+  })).describe("What could go wrong: migrations, existing data, access, performance, compatibility"),
+  riskLevel: z.enum(["low", "medium", "high"]).describe("How closely a person should review the result"),
+  assumptions: z.array(z.object({
+    text: z.string().describe("The default you chose"),
+    reason: z.string().describe("Why, so the owner can confirm or correct it quickly")
+  })).describe("Defaults chosen where the task was silent. Empty when nothing was assumed"),
+  openQuestions: z.array(questionSchema).describe("Questions only the owner can settle; the spec cannot be approved until each is answered or dismissed. Empty when none"),
+  split: z.array(z.string()).describe("When the task holds more than one shippable goal or more than about 8 files: the separate tasks you propose, one line each. Empty otherwise")
+});
+function reply(text2, isError = false) {
+  return { content: [{ type: "text", text: text2 }], ...isError ? { isError: true } : {} };
+}
+function unreachable(error, toolName) {
+  const message = error instanceof Error ? error.message : String(error);
+  return reply(`Could not reach TAMsense to check this: ${message}. Call ${toolName} again in a moment.`, true);
+}
+function questionsTool(review, onSubmit) {
+  return tool(
+    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,
+    async (args) => {
+      let verdict;
+      try {
+        verdict = await review({ questions: args });
+      } catch (error) {
+        return unreachable(error, SUBMIT_QUESTIONS_TOOL_NAME);
+      }
+      if (!verdict.accepted) {
+        return reply(verdict.feedback, true);
+      }
+      onSubmit(args);
+      return reply(args.questions.length > 0 ? "Questions saved. The owner answers them on the task page after this run. Finish now with a reply of one or two sentences." : "Saved with no questions: the spec is written next. Finish now with a reply of one or two sentences.");
+    }
+  );
+}
+var BUILDER_CHECK_FIRST = "The spec passed the lint but was not saved yet: the builder check of the tamsense:spec-writing skill has not run in this session. Start one fresh general-purpose subagent with the Agent tool, give it only the spec as text inside the builder check prompt of the skill, settle each point it reports as the skill says, then call submit_spec again with the full spec.";
+function specTool(review, onSubmit, builderCheckRan) {
+  let repairs = 0;
+  let reminded = false;
+  return tool(
+    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,
+    async (args) => {
+      let verdict;
+      try {
+        verdict = await review({ spec: args, repairs });
+      } catch (error) {
+        return unreachable(error, SUBMIT_SPEC_TOOL_NAME);
+      }
+      if (!verdict.accepted) {
+        repairs += 1;
+        return reply(verdict.feedback, true);
+      }
+      if (!builderCheckRan() && !reminded) {
+        reminded = true;
+        return reply(BUILDER_CHECK_FIRST, true);
+      }
+      onSubmit({ spec: args, problems: verdict.problems });
+      return reply(verdict.problems.length > 0 ? `Spec saved with these problems left: ${verdict.problems.join("; ")}. Mention them in your reply.` : "Spec saved.");
+    }
+  );
+}
+
+// src/usageLimit.ts
+var USAGE_LIMIT_REPORT = "Claude hit its usage limit";
+var DEFAULT_PAUSE_MS = 30 * 6e4;
+var DAY_MS = 24 * 60 * 6e4;
+var SECONDS_BELOW = 1e11;
+var LIMIT_TEXT = /You['’]ve (?:hit|reached) your|You['’]re out of (?:usage credits|extra usage)|usage limit/i;
+var EPOCH_RESET = /\|(\d{10,13})\b/;
+var CLOCK_RESET = /resets?\s+(?:at\s+)?(?:([a-z]{3})[a-z]*\.?\s+(\d{1,2}),?\s+(?:at\s+)?)?(\d{1,2})(?::(\d{2}))?\s*([ap]m)?/i;
+var MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+function fromEpoch(value) {
+  return new Date(value < SECONDS_BELOW ? value * 1e3 : value);
+}
+function hourOf(hour, meridiem) {
+  if (!meridiem) {
+    return hour < 24 ? hour : null;
+  }
+  if (hour < 1 || hour > 12) {
+    return null;
+  }
+  return hour % 12 + (meridiem.toLowerCase() === "pm" ? 12 : 0);
+}
+function resetTimeOf(text2, now) {
+  const epoch = EPOCH_RESET.exec(text2);
+  if (epoch) {
+    const reset2 = fromEpoch(Number(epoch[1]));
+    return reset2 > now ? reset2 : null;
+  }
+  const clock = CLOCK_RESET.exec(text2);
+  if (!clock) {
+    return null;
+  }
+  const [, monthName, day, hourText, minuteText, meridiem] = clock;
+  const hour = hourOf(Number(hourText), meridiem);
+  const minute = Number(minuteText ?? 0);
+  const month = monthName ? MONTHS.indexOf(monthName.toLowerCase()) : now.getMonth();
+  if (hour === null || minute > 59 || month < 0) {
+    return null;
+  }
+  const reset = new Date(now.getFullYear(), month, day ? Number(day) : now.getDate(), hour, minute);
+  if (reset > now) {
+    return reset;
+  }
+  if (!monthName) {
+    return new Date(reset.getTime() + DAY_MS);
+  }
+  const nextYear = new Date(now.getFullYear() + 1, month, Number(day), hour, minute);
+  return nextYear.getTime() - now.getTime() < 31 * DAY_MS ? nextYear : null;
+}
+function assistantText(message) {
+  return message.message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
+}
+function usageLimitWatch() {
+  let limitedByText = false;
+  let limitedByEvent = false;
+  let eventReset = null;
+  let texts2 = [];
+  function hitText(text2) {
+    limitedByText = true;
+    texts2.push(text2);
+  }
+  return {
+    observe(message) {
+      if (message.type === "rate_limit_event") {
+        const info = message.rate_limit_info;
+        limitedByEvent = info.status === "rejected" && !info.isUsingOverage;
+        eventReset = limitedByEvent && info.resetsAt ? fromEpoch(info.resetsAt) : null;
+      } else if (message.type === "assistant" && message.error) {
+        const text2 = assistantText(message);
+        if (message.error === "rate_limit" || LIMIT_TEXT.test(text2)) {
+          hitText(text2);
+        }
+      } else if (message.type === "result") {
+        if (message.subtype === "success" && !message.is_error) {
+          limitedByText = false;
+          texts2 = [];
+          return;
+        }
+        const text2 = message.subtype === "success" ? message.result : message.errors.join("\n");
+        if (LIMIT_TEXT.test(text2)) {
+          hitText(text2);
+        }
+      }
+    },
+    pausedUntil(completed, now = /* @__PURE__ */ new Date()) {
+      if (completed || !(limitedByText || limitedByEvent)) {
+        return null;
+      }
+      const fromText = texts2.map((text2) => resetTimeOf(text2, now)).find((reset2) => reset2 !== null);
+      const reset = eventReset && eventReset > now ? eventReset : fromText ?? new Date(now.getTime() + DEFAULT_PAUSE_MS);
+      return reset.toISOString();
+    }
+  };
+}
+
+// src/claude.ts
+var NOBODY_TO_ASK = "Nobody is at the computer to approve this during a TAMsense run. Do it another way, or explain in your report why it is needed.";
+var NO_RESULT_TEXT = "Claude finished without a result.";
+var SERVER_NAME = "tamsense";
+var LIBRARY_PATH = fileURLToPath(new URL("../library", import.meta.url));
+var denyWhenAsked = async () => ({ behavior: "deny", message: NOBODY_TO_ASK });
+var CAPTION_FIELDS = {
+  title: z2.string().describe('short name of what it shows, at most 60 characters: "Design option 1", "Feature testing", "Feature testing, attempt 2". Never generic names like "screenshot1"'),
+  purpose: z2.string().describe('one line, at most 160 characters, on why it was made: "Comparing two layouts for the empty orders state"')
+};
+var ATTACH_TOOLS = {
+  screenshot: {
+    name: SCREENSHOT_TOOL_NAME,
+    description: "Attach a screenshot to the TAMsense task so people can see the result without opening the code. Attach the final look of each changed screen and anything a reviewer must see. PNG, JPEG or WebP up to 5 MB, at most 20 per run.",
+    path: "absolute path of the image file"
+  },
+  replay: {
+    name: REPLAY_TOOL_NAME,
+    description: "Attach a browser replay (the .rrweb.ndjson file the TAMsense recorder wrote) to the task now, with your own title and purpose. Every recording is attached at the end of the run anyway; use this to attach one earlier or to name it better. Close the browser context first so the file is complete.",
+    path: "absolute path of the .rrweb.ndjson replay file"
+  },
+  video: {
+    name: VIDEO_TOOL_NAME,
+    description: "Attach a browser video (.webm or .mp4, up to 200 MB) to the task now, with your own title and purpose. Videos recorded with video: true are attached at the end of the run anyway. Close the browser context first so the file is complete.",
+    path: "absolute path of the video file"
+  }
+};
+function attachTool(kind, attach) {
+  const spec = ATTACH_TOOLS[kind];
+  return tool2(
+    spec.name,
+    spec.description,
+    { path: z2.string().describe(spec.path), ...CAPTION_FIELDS },
+    async (args) => ({ content: [{ type: "text", text: await attach({ kind, ...args }) }] })
+  );
+}
+function verdictTool(onVerdict) {
+  return tool2(
+    VERDICT_TOOL_NAME,
+    "Hand in the result of this check. Call it exactly once, at the very end.",
+    {
+      passed: z2.boolean().describe("true only if nothing must be fixed"),
+      report: z2.string().describe("what you checked and, if it failed, exactly what to fix with file and line")
+    },
+    async (args) => {
+      onVerdict({ passed: args.passed, report: args.report });
+      return { content: [{ type: "text", text: "Verdict received. You can stop now." }] };
+    }
+  );
+}
+function handoffTool(targets, onHandoff) {
+  return tool2(
+    HANDOFF_TOOL_NAME,
+    "Hand the task to the next step of the TAMsense board when you finish. The next agent and the task owner read your note. Only one handoff counts: calling it again replaces the earlier one.",
+    {
+      to: z2.string().describe("name or id of the step to hand the task to"),
+      outcome: z2.enum(HANDOFF_OUTCOMES).describe("pass: the work is done; problems: something must be fixed; ask: a question for that step"),
+      note: z2.string().describe("for the next agent and the owner: what was done, what to check, what is open")
+    },
+    async (args) => {
+      const choice = chooseHandoff(targets, args);
+      if ("error" in choice) {
+        return { content: [{ type: "text", text: choice.error }], isError: true };
+      }
+      onHandoff(choice.handoff);
+      return { content: [{ type: "text", text: "Handoff recorded. It happens when you finish." }] };
+    }
+  );
+}
+function specWorkTools(specWork, submitted) {
+  if (!specWork) {
+    return [];
+  }
+  return specWork.stage === "interview" ? [questionsTool(specWork.review, (questions) => {
+    submitted.questions = questions;
+  })] : [specTool(specWork.review, (spec) => {
+    submitted.spec = spec;
+  }, () => submitted.helperStarted)];
+}
+function tamsenseServer(request, submitted) {
+  const tools = [
+    attachTool("screenshot", request.attach),
+    attachTool("replay", request.attach),
+    attachTool("video", request.attach),
+    ...request.wantsVerdict ? [verdictTool((verdict) => {
+      submitted.verdict = verdict;
+    })] : [],
+    ...specWorkTools(request.specWork, submitted),
+    ...request.handoffs.length > 0 ? [handoffTool(request.handoffs, (handoff) => {
+      submitted.handoff = handoff;
+    })] : []
+  ];
+  return {
+    server: createSdkMcpServer({ name: SERVER_NAME, version: "1.0.0", tools }),
+    allowed: tools.map((item) => `mcp__${SERVER_NAME}__${item.name}`)
+  };
+}
+function modelOptions(request) {
+  return {
+    ...request.model === null ? {} : { model: request.model },
+    ...request.effort === null ? {} : { effort: request.effort }
+  };
+}
+async function applySwitch(target, change) {
+  if (change.model !== null) {
+    await target.setModel(change.model === DEFAULT_MODEL ? void 0 : change.model);
+  }
+  if (change.effort !== null) {
+    await target.applyFlagSettings({ effortLevel: change.effort });
+  }
+}
+async function attempt(request, context, resume) {
+  let lastText = "";
+  let sessionId = null;
+  let outcome = { completed: false, report: NO_RESULT_TEXT, model: null, usage: null, verdict: null };
+  const tamsense = tamsenseServer(request, context.submitted);
+  const shown = hiddenStepsFilter();
+  const messages = context.startQuery({
+    prompt: request.input.start(request.prompt.prompt),
+    options: {
+      cwd: request.cwd,
+      systemPrompt: { type: "preset", preset: "claude_code", append: request.prompt.instructions },
+      settingSources: ["user", "project", "local"],
+      permissionMode: "auto",
+      // краткий пересказ размышлений Claude идёт в журнал задачи, как в Paseo
+      thinking: { type: "adaptive", display: "summarized" },
+      canUseTool: denyWhenAsked,
+      plugins: [{ type: "local", path: LIBRARY_PATH }],
+      mcpServers: { [SERVER_NAME]: tamsense.server },
+      allowedTools: tamsense.allowed,
+      abortController: context.abortController,
+      env: request.env,
+      ...modelOptions(request),
+      ...resume === null ? {} : { resume }
+    }
+  });
+  request.input.onSwitch((change) => applySwitch(messages, change));
+  const failedToResume = () => resume !== null && sessionId === null && !request.signal.aborted;
+  try {
+    for await (const message of messages) {
+      if (message.type === "system" && message.subtype === "init") {
+        sessionId = message.session_id;
+        request.onSession(sessionOf(message));
+      }
+      if (message.type === "result" && (message.is_error || message.subtype !== "success") && failedToResume()) {
+        messages.close();
+        return { outcome, sessionId, resumeFailed: true };
+      }
+      for (const draft of feedOf(message).filter(shown)) {
+        if (draft.kind === "agent" && draft.parent === null) {
+          context.submitted.helperStarted = true;
+        }
+        request.onFeed(draft);
+        if (draft.kind === "text" && draft.parent === null) {
+          lastText = draft.text;
+        }
+      }
+      if (message.type === "result") {
+        outcome = outcomeOf(message, lastText);
+      }
+      context.limit.observe(message);
+      request.input.observe(message);
+    }
+  } catch (error) {
+    if (failedToResume()) {
+      return { outcome, sessionId, resumeFailed: true };
+    }
+    throw error;
+  }
+  return { outcome, sessionId, resumeFailed: false };
+}
+function claudeRunner(startQuery) {
+  return async (request) => {
+    request.signal.throwIfAborted();
+    const abortController = new AbortController();
+    request.signal.addEventListener("abort", () => {
+      request.input.close();
+      abortController.abort();
+    }, { once: true });
+    const submitted = { verdict: null, handoff: null, questions: null, spec: null, helperStarted: false };
+    const limit = usageLimitWatch();
+    const context = { startQuery, abortController, submitted, limit };
+    try {
+      let result = await attempt(request, context, request.resumeSessionId);
+      if (result.resumeFailed) {
+        result = await attempt(request, context, null);
+      }
+      const pausedUntil = limit.pausedUntil(result.outcome.completed);
+      const outcome = pausedUntil ? { ...result.outcome, completed: false, report: USAGE_LIMIT_REPORT } : result.outcome;
+      return { ...outcome, verdict: submitted.verdict, handoff: submitted.handoff, questions: submitted.questions, spec: submitted.spec, sessionId: result.sessionId, pausedUntil };
+    } finally {
+      request.input.close();
+    }
+  };
+}
+var runClaude = claudeRunner(query2);
+
+// src/config.ts
+import { mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+var OWNER_ONLY_FILE = 384;
+var OWNER_ONLY_FOLDER = 448;
+function configPath(home = homedir2()) {
+  return join2(home, ".tamsense", "runner.json");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseConfig(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const { server, token, deviceId, deviceName, browserDeclined } = value;
+  const isValid = typeof server === "string" && typeof token === "string" && typeof deviceId === "number" && typeof deviceName === "string";
+  return isValid ? { server, token, deviceId, deviceName, ...browserDeclined === true ? { browserDeclined } : {} } : null;
+}
+function isMissingFile(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function readConfig(path = configPath()) {
+  try {
+    return parseConfig(JSON.parse(await readFile2(path, "utf8")));
+  } catch (error) {
+    if (isMissingFile(error) || error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeConfig(config, path = configPath()) {
+  await mkdir2(dirname2(path), { recursive: true, mode: OWNER_ONLY_FOLDER });
+  await writeFile2(path, `${JSON.stringify(config, null, 4)}
+`, { mode: OWNER_ONLY_FILE });
+}
+async function removeConfig(path = configPath()) {
+  await rm2(path, { force: true });
+}
+
+// src/protocol.ts
+var MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+var MAX_ATTACHMENTS_PER_RUN = 20;
+var MAX_VIDEO_BYTES = 200 * 1024 * 1024;
+var PAIRINGS_PATH = "/api/runner/pairings";
+var PAIRING_TOKEN_PATH = "/api/runner/pairings/token";
+var IDENTITY_PATH = "/api/runner/me";
+var NEXT_RUN_PATH = "/api/runner/runs/next";
+var CAPABILITIES_PATH = "/api/runner/me/capabilities";
+function runPath(runId, action) {
+  return `/api/runner/runs/${runId}/${action}`;
+}
+function recordingUploadPath(runId, upload, part) {
+  return `/api/runner/runs/${runId}/recordings/${upload}/${part}`;
+}
+
+// src/login.ts
+var MS_PER_SECOND = 1e3;
+var EXPIRED_TEXT = `The code expired before it was confirmed. Run ${LOGIN_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);
+  const pageUrl = new URL(pairing.verificationPath, tools.api.server).toString();
+  const expiresAt = Date.parse(pairing.expiresAt);
+  tools.print(`Your code: ${pairing.userCode}`);
+  tools.print(`Confirm it in the browser: ${pageUrl}`);
+  tools.print("Waiting for confirmation\u2026");
+  tools.openBrowser(pageUrl);
+  while (tools.now() < expiresAt) {
+    await tools.sleep(pairing.intervalSeconds * MS_PER_SECOND);
+    const reply2 = await tools.api.request("POST", PAIRING_TOKEN_PATH, { deviceCode: pairing.deviceCode });
+    if (reply2.status === "connected") {
+      return { token: reply2.token, device: reply2.device };
+    }
+    if (reply2.status === "denied") {
+      throw new Error(DENIED_TEXT);
+    }
+    if (reply2.status === "expired") {
+      break;
+    }
+  }
+  throw new Error(EXPIRED_TEXT);
+}
+
+// src/recorderEnv.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/recorder.ts
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import Module, { createRequire } from "module";
+import { basename, dirname as dirname3, join as join3 } from "path";
+import process2 from "process";
+var RECORDINGS_DIR_ENV = "TAMSENSE_RECORDINGS_DIR";
+var SERVER_ENV = "TAMSENSE_SERVER";
+var DEFAULT_TITLE_ENV = "TAMSENSE_RECORDING_TITLE";
+var DEFAULT_PURPOSE_ENV = "TAMSENSE_RECORDING_PURPOSE";
+var MARK_TAG = "tamsense.mark";
+var REPLAY_SUFFIX = ".rrweb.ndjson";
+var META_SUFFIX = ".json";
+var MAX_TITLE_LENGTH = 60;
+var MAX_PURPOSE_LENGTH = 160;
+var DEFAULT_TRACKER_ORIGINS = ["https://my.tamsense.com"];
+var BINDING = "__tamsenseRecord";
+var STATE_KEY = /* @__PURE__ */ Symbol.for("tamsense.recorder");
+var FLUSH_MS = 100;
+var MAX_SESSION_BYTES = 300 * 1024 * 1024;
+var GAP_CHECK_MS = 1500;
+var RRWEB_META = 4;
+function state() {
+  const holder = globalThis;
+  holder[STATE_KEY] ??= { contexts: /* @__PURE__ */ new WeakMap(), pages: /* @__PURE__ */ new WeakMap(), instrumented: /* @__PURE__ */ new WeakSet(), script: null, hooked: false };
+  return holder[STATE_KEY];
+}
+function recordingsDir() {
+  const dir = process2.env[RECORDINGS_DIR_ENV];
+  if (!dir) {
+    throw new Error(`${RECORDINGS_DIR_ENV} is not set: recordings work only inside a TAMsense run`);
+  }
+  return dir;
+}
+function warn(text2) {
+  process2.stderr.write(`[tamsense recorder] ${text2}
+`);
+}
+function isTrackerIngest(url, tamsenseOrigins) {
+  if (!/\/api\/events\/?$/.test(url.pathname)) {
+    return false;
+  }
+  return url.searchParams.has("key") || tamsenseOrigins.includes(url.origin);
+}
+function trackerOrigins(env = process2.env) {
+  const origins = new Set(DEFAULT_TRACKER_ORIGINS);
+  try {
+    if (env[SERVER_ENV]) {
+      origins.add(new URL(env[SERVER_ENV]).origin);
+    }
+  } catch {
+  }
+  return [...origins];
+}
+function checkCaption(caption) {
+  const title = typeof caption?.title === "string" ? caption.title.trim() : "";
+  const purpose = typeof caption?.purpose === "string" ? caption.purpose.trim() : "";
+  if (!title || !purpose) {
+    throw new Error('Give it a title (what it shows, for example "Design option 1" or "Feature testing, attempt 2") and a purpose (one line on why it was made).');
+  }
+  if (title.length > MAX_TITLE_LENGTH || purpose.length > MAX_PURPOSE_LENGTH) {
+    throw new Error(`Keep the title within ${MAX_TITLE_LENGTH} characters and the purpose within ${MAX_PURPOSE_LENGTH}.`);
+  }
+  return { title, purpose };
+}
+function clip2(text2, max) {
+  return text2.length > max ? `${text2.slice(0, max - 1).trimEnd()}\u2026` : text2;
+}
+function automaticCaption(env = process2.env, script2 = process2.argv[1]) {
+  const from = script2 ? `, opened by ${basename(script2)}` : "";
+  return {
+    title: clip2(env[DEFAULT_TITLE_ENV]?.trim() || "Browser session", MAX_TITLE_LENGTH),
+    purpose: clip2(`${env[DEFAULT_PURPOSE_ENV]?.trim() || "Recorded automatically while the agent used a browser"}${from}`, MAX_PURPOSE_LENGTH)
+  };
+}
+function rrwebSource() {
+  const entry = createRequire(import.meta.url).resolve("rrweb");
+  return readFileSync(join3(dirname3(entry), "rrweb.umd.min.cjs"), "utf8");
+}
+function pageScript(rrweb) {
+  return `(() => {
+if (window.top !== window || window.__tamsenseRecording) return;
+window.__tamsenseRecording = true;
+const rrweb = (() => { const module = { exports: {} }; const exports = module.exports; ${rrweb}
+; return module.exports; })();
+let buffer = [];
+let timer = null;
+const send = (extra) => {
+    clearTimeout(timer);
+    timer = null;
+    if (!buffer.length && !extra) return Promise.resolve();
+    const events = buffer;
+    buffer = [];
+    return window.${BINDING}(JSON.stringify({ events, ...extra })).catch(() => {});
+};
+rrweb.record({
+    emit(event) {
+        buffer.push(event);
+        if (!timer) timer = setTimeout(send, ${FLUSH_MS});
+    },
+    maskInputOptions: { password: true },
+});
+const crossOrigin = (frame) => { try { return new URL(frame.src, location.href).origin !== location.origin; } catch { return false; } };
+const checkGaps = () => {
+    const gaps = [];
+    if (document.querySelector('canvas')) gaps.push('canvas');
+    if (document.querySelector('video')) gaps.push('video');
+    if ([...document.querySelectorAll('iframe')].some(crossOrigin)) gaps.push('cross-origin iframe');
+    if (gaps.length) send({ gaps });
+};
+window.__tamsenseFlush = () => send();
+window.__tamsenseMark = (label) => { rrweb.record.addCustomEvent('${MARK_TAG}', { label }); return send(); };
+addEventListener('pagehide', () => { send(); });
+addEventListener('load', () => setTimeout(checkGaps, ${GAP_CHECK_MS}));
+})();`;
+}
+function script() {
+  const current = state();
+  current.script ??= pageScript(rrwebSource());
+  return current.script;
+}
+var Session = class {
+  file;
+  metaFile;
+  meta;
+  bytes = 0;
+  constructor(dir, recording, url) {
+    const id = `${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
+    this.file = join3(dir, `${id}${REPLAY_SUFFIX}`);
+    this.metaFile = join3(dir, `${id}${META_SUFFIX}`);
+    this.meta = { version: 1, id, ...recording.caption, startedAt: Date.now(), endedAt: null, url, marks: [], video: null, gaps: [], blockedTrackerRequests: 0, truncated: false, automatic: recording.automatic };
+    writeFileSync(this.file, "");
+    this.save();
+  }
+  save() {
+    writeFileSync(this.metaFile, `${JSON.stringify(this.meta, null, 2)}
+`);
+  }
+  receive(payload) {
+    let batch;
+    try {
+      batch = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    if (batch.gaps?.length) {
+      this.meta.gaps = [.../* @__PURE__ */ new Set([...this.meta.gaps, ...batch.gaps])];
+      this.save();
+    }
+    const page = batch.events?.find((event) => event.type === RRWEB_META && typeof event.data?.href === "string" && event.data.href !== "about:blank");
+    if (page && this.meta.url === "about:blank") {
+      this.meta.url = String(page.data.href);
+      this.save();
+    }
+    const lines = (batch.events ?? []).map((event) => JSON.stringify(event)).join("\n");
+    if (!lines || this.meta.truncated) {
+      return;
+    }
+    if (this.bytes + lines.length > MAX_SESSION_BYTES) {
+      this.meta.truncated = true;
+      this.save();
+      return;
+    }
+    this.bytes += lines.length + 1;
+    appendFileSync(this.file, `${lines}
+`);
+  }
+  end() {
+    if (this.meta.endedAt === null) {
+      this.meta.endedAt = Date.now();
+      this.save();
+    }
+  }
+  summary() {
+    const { title, purpose, video, marks, gaps, blockedTrackerRequests } = this.meta;
+    return { title, purpose, replay: this.file, video, marks: marks.length, gaps, blockedTrackerRequests };
+  }
+};
+async function startSession(recording, page, injectNow) {
+  const current = state();
+  if (current.pages.has(page)) {
+    return;
+  }
+  const session = new Session(recordingsDir(), recording, page.url());
+  current.pages.set(page, session);
+  recording.sessions.push(session);
+  page.on("close", () => session.end());
+  const video = page.video();
+  if (video) {
+    session.meta.video = await video.path().catch(() => null);
+    session.save();
+  }
+  if (injectNow) {
+    await page.evaluate(script()).catch(() => {
+    });
+  }
+}
+async function flush(context) {
+  await Promise.all(context.pages().filter((page) => !page.isClosed()).map(
+    (page) => page.evaluate(() => window.__tamsenseFlush?.(), void 0).catch(() => {
+    })
+  ));
+}
+async function recordContext(context, caption, automatic = false) {
+  const checked = checkCaption(caption);
+  const current = state();
+  const known = current.contexts.get(context);
+  if (known) {
+    Object.assign(known, { caption: checked, automatic });
+    for (const session of known.sessions) {
+      Object.assign(session.meta, checked, { automatic });
+      session.save();
+    }
+    return;
+  }
+  mkdirSync(recordingsDir(), { recursive: true });
+  const recording = { caption: checked, automatic, sessions: [] };
+  current.contexts.set(context, recording);
+  const origins = trackerOrigins();
+  await context.route((url) => isTrackerIngest(url, origins), async (route) => {
+    try {
+      const session = current.pages.get(route.request().frame().page());
+      if (session) {
+        session.meta.blockedTrackerRequests += 1;
+        session.save();
+      }
+    } catch {
+    }
+    await route.fulfill({ status: 200, contentType: "application/json", body: '{"ok":true}' });
+  });
+  await context.exposeBinding(BINDING, ({ page }, payload) => current.pages.get(page)?.receive(payload));
+  await context.addInitScript({ content: script() });
+  context.on("page", (page) => void startSession(recording, page, false));
+  context.on("close", () => recording.sessions.forEach((session) => session.end()));
+  for (const page of context.pages()) {
+    await startSession(recording, page, true);
+  }
+  const close = context.close.bind(context);
+  context.close = async (options) => {
+    await flush(context);
+    return close(options);
+  };
+}
+function instrument(exports) {
+  const chromium = exports?.chromium;
+  const instrumentation = exports?._instrumentation ?? chromium?._instrumentation;
+  const current = state();
+  if (typeof chromium?.launch !== "function" || typeof instrumentation?.addListener !== "function" || current.instrumented.has(instrumentation)) {
+    return;
+  }
+  current.instrumented.add(instrumentation);
+  instrumentation.addListener({
+    runAfterCreateBrowserContext: async (context) => {
+      try {
+        if (!current.contexts.has(context)) {
+          await recordContext(context, automaticCaption(), true);
+        }
+      } catch (error) {
+        warn(`could not record this browser: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  });
+}
+function installAutoRecording() {
+  const current = state();
+  if (current.hooked) {
+    return;
+  }
+  current.hooked = true;
+  const loader = Module;
+  const load = loader._load;
+  loader._load = function(...args) {
+    const exports = load.apply(this, args);
+    try {
+      instrument(exports);
+    } catch {
+    }
+    return exports;
+  };
+}
+if (process2.env[RECORDINGS_DIR_ENV]) {
+  installAutoRecording();
+}
+
+// src/recorderEnv.ts
+var RECORDER_ENV = "TAMSENSE_RECORDER";
+function bundledRecorder() {
+  const path = fileURLToPath2(new URL("./recorder.cjs", import.meta.url));
+  return existsSync2(path) ? path : null;
+}
+function recordingsFolder(home, runId) {
+  return join4(home, ".tamsense", "recordings", `run-${runId}`);
+}
+function nodeOptionsWithRecorder(recorder, nodeOptions) {
+  return [nodeOptions?.trim(), `--require "${recorder.replaceAll("\\", "/")}"`].filter(Boolean).join(" ");
+}
+function recorderEnv(input) {
+  const { job } = input;
+  return {
+    [RECORDER_ENV]: input.recorder,
+    [RECORDINGS_DIR_ENV]: input.folder,
+    [SERVER_ENV]: input.server,
+    [DEFAULT_TITLE_ENV]: `${job.stage.name} browser session`.slice(0, MAX_TITLE_LENGTH),
+    [DEFAULT_PURPOSE_ENV]: `Recorded automatically in the ${job.stage.name} step of task #${job.taskId}`.slice(0, MAX_PURPOSE_LENGTH),
+    NODE_OPTIONS: nodeOptionsWithRecorder(input.recorder, input.nodeOptions)
+  };
+}
+
+// src/scope.ts
+var TEAM_KEY_MISSING_TEXT = "This is a team computer: Claude must run on the Anthropic API key of your company, not on a personal Claude subscription. Set ANTHROPIC_API_KEY on this computer and start again.";
+function teamKeyProblem(isTeam, env) {
+  return isTeam && !env.ANTHROPIC_API_KEY?.trim() ? TEAM_KEY_MISSING_TEXT : null;
+}
+function describeDevice(identity) {
+  return identity.device.team ? `a team computer of ${identity.projectName}` : `the personal computer of ${identity.email ?? "its owner"}`;
+}
+
+// src/system.ts
+import { spawn as spawn2 } from "child_process";
+import { hostname } from "os";
+import { delimiter as delimiter2 } from "path";
+import { createInterface as createInterface2 } from "readline/promises";
+import { setTimeout as wait } from "timers/promises";
+var PLATFORM_LABELS = {
+  win32: "Windows",
+  darwin: "macOS",
+  linux: "Linux"
+};
+var MAX_NAME_LENGTH = 80;
+function platformLabel(platform = process.platform) {
+  return PLATFORM_LABELS[platform] ?? platform;
+}
+function defaultDeviceName() {
+  return hostname().slice(0, MAX_NAME_LENGTH) || "My computer";
+}
+function browserCommand(url, platform) {
+  if (platform === "win32") {
+    return ["rundll32", ["url.dll,FileProtocolHandler", url]];
+  }
+  return [platform === "darwin" ? "open" : "xdg-open", [url]];
+}
+function openBrowser(url, platform = process.platform) {
+  const [command, args] = browserCommand(url, platform);
+  const child = spawn2(command, args, { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function withNodeOnPath(env, nodeDir, separator = delimiter2) {
+  const key = Object.keys(env).find((name) => name.toUpperCase() === "PATH") ?? "PATH";
+  const entries = (env[key] ?? "").split(separator).filter(Boolean);
+  const normalize = (dir) => dir.replace(/[\\/]+$/, "").toLowerCase();
+  if (entries.some((entry) => normalize(entry) === normalize(nodeDir))) {
+    return env;
+  }
+  return { ...env, [key]: [...entries, nodeDir].join(separator) };
+}
+async function askYesNo(question) {
+  const prompt = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    for (; ; ) {
+      const answer = (await prompt.question(question)).trim().toLowerCase();
+      if (answer === "" || answer === "y" || answer === "yes") {
+        return true;
+      }
+      if (answer === "n" || answer === "no") {
+        return false;
+      }
+    }
+  } finally {
+    prompt.close();
+  }
+}
+async function sleep(ms, signal) {
+  await wait(ms, void 0, { signal }).catch(() => {
+  });
+}
+
+// src/update.ts
+import { spawn as spawn3 } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+import process3 from "process";
+var PACKAGE_NAME = "@tamsensedev/runner";
+var RELAUNCHED_ENV = "TAMSENSE_RELAUNCHED";
+var NO_UPDATE_ENV = "TAMSENSE_NO_UPDATE";
+var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME.replace("/", "%2f")}/latest`;
+var REGISTRY_TIMEOUT_MS = 3e3;
+var RELEASE_PATTERN = /^(\d+)\.(\d+)\.(\d+)$/;
+function releaseParts(version) {
+  const match = RELEASE_PATTERN.exec(version.trim());
+  return match ? match.slice(1).map(Number) : null;
+}
+function isNewer(latest, current) {
+  const next = releaseParts(latest);
+  const now = releaseParts(current);
+  if (!next || !now) {
+    return false;
+  }
+  const index = next.findIndex((part, position) => part !== now[position]);
+  return index !== -1 && next[index] > now[index];
+}
+function currentVersion() {
+  try {
+    const manifest = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
+    return manifest.name === PACKAGE_NAME && typeof manifest.version === "string" ? manifest.version : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchLatest(url, signal) {
+  const response = await fetch(url, { signal, headers: { accept: "application/json" } });
+  return response.ok ? await response.json() : null;
+}
+async function latestVersion(fetchJson = fetchLatest, timeoutMs = REGISTRY_TIMEOUT_MS) {
+  try {
+    const body = await fetchJson(REGISTRY_URL, AbortSignal.timeout(timeoutMs));
+    const version = body && typeof body === "object" ? body.version : null;
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+async function updateToRun(env, current, latest) {
+  if (!current || env[RELAUNCHED_ENV] || env[NO_UPDATE_ENV]) {
+    return null;
+  }
+  const found = await latest();
+  return found && isNewer(found, current) ? { current, latest: found } : null;
+}
+function relaunchArgs(argv) {
+  return ["--yes", `${PACKAGE_NAME}@latest`, ...argv];
+}
+function relaunch(argv, env) {
+  const isWindows = process3.platform === "win32";
+  return new Promise((resolve, reject) => {
+    const child = spawn3(isWindows ? "npx.cmd" : "npx", relaunchArgs(argv), { stdio: "inherit", shell: isWindows, env: { ...env, [RELAUNCHED_ENV]: "1" } });
+    const ignoreInterrupt = () => {
+    };
+    process3.on("SIGINT", ignoreInterrupt);
+    child.on("error", (error) => {
+      process3.off("SIGINT", ignoreInterrupt);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      process3.off("SIGINT", ignoreInterrupt);
+      resolve(code ?? 1);
+    });
+  });
+}
+
+// src/worker.ts
+import { rm as rm4 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+import process4 from "process";
+
+// src/feedQueue.ts
+var MAX_BATCH = 200;
+var MAX_WAITING = 2e3;
+function feedQueue(send) {
+  let seq = 0;
+  let waiting = [];
+  let sending = Promise.resolve();
+  async function drain() {
+    while (waiting.length > 0) {
+      const batch = waiting.slice(0, MAX_BATCH);
+      try {
+        await send(batch);
+      } catch {
+        return;
+      }
+      const lastSent = batch.at(-1).seq;
+      waiting = waiting.filter((entry) => entry.seq > lastSent);
+    }
+  }
+  return {
+    push(draft) {
+      seq += 1;
+      const entry = { ...draft, seq };
+      waiting.push(entry);
+      if (waiting.length > MAX_WAITING) {
+        waiting = waiting.slice(-MAX_WAITING);
+      }
+      return entry;
+    },
+    flush() {
+      sending = sending.then(drain);
+      return sending;
+    }
+  };
+}
+
+// src/lock.ts
+function keyedLock() {
+  const tails = /* @__PURE__ */ new Map();
+  return {
+    async run(key, work2) {
+      const previous = tails.get(key) ?? Promise.resolve();
+      let release = () => {
+      };
+      const done = new Promise((resolve) => {
+        release = resolve;
+      });
+      const tail = previous.then(() => done);
+      tails.set(key, tail);
+      await previous;
+      try {
+        return await work2();
+      } finally {
+        release();
+        if (tails.get(key) === tail) {
+          tails.delete(key);
+        }
+      }
+    }
+  };
+}
+
+// src/recordings.ts
+import { randomUUID } from "crypto";
+import { createReadStream } from "fs";
+import { readdir, readFile as readFile3, stat, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename2, dirname as dirname4, extname, isAbsolute, join as join5 } from "path";
+import { createInterface as createInterface3 } from "readline";
+import { Readable } from "stream";
+import { promisify } from "util";
+import { gzip } from "zlib";
+var gzipAsync = promisify(gzip);
+var CHUNK_TARGET_BYTES = 2 * 1024 * 1024;
+var MAX_LINE_BYTES = 30 * 1024 * 1024;
+var LEDGER_FILE = "uploaded.json";
+var RRWEB_FULL_SNAPSHOT = 2;
+var RRWEB_META2 = 4;
+var RRWEB_CUSTOM = 5;
+var VIDEO_TYPES_BY_EXTENSION = {
+  ".webm": "video/webm",
+  ".mp4": "video/mp4"
+};
+function eventOf(line) {
+  try {
+    const event = JSON.parse(line);
+    return typeof event?.type === "number" && typeof event.timestamp === "number" ? event : null;
+  } catch {
+    return null;
+  }
+}
+async function* replayChunks(lines, scan, targetBytes = CHUNK_TARGET_BYTES) {
+  let chunk = [];
+  let bytes = 0;
+  let previous = null;
+  for await (const line of lines) {
+    const event = line.trim() ? eventOf(line) : null;
+    if (!event) {
+      continue;
+    }
+    if (line.length > MAX_LINE_BYTES) {
+      throw new Error("One event of this replay is larger than 30 MB, so it cannot be uploaded.");
+    }
+    const startsGroup = event.type === RRWEB_META2 || event.type === RRWEB_FULL_SNAPSHOT && previous?.type !== RRWEB_META2;
+    if (chunk.length > 0 && (startsGroup || bytes + line.length > targetBytes)) {
+      yield `${chunk.join("\n")}
+`;
+      chunk = [];
+      bytes = 0;
+    }
+    chunk.push(line);
+    bytes += line.length + 1;
+    previous = event;
+    scan.startTs = Math.min(scan.startTs, event.timestamp);
+    scan.snapshot ||= event.type === RRWEB_FULL_SNAPSHOT;
+    if (event.type === RRWEB_CUSTOM && event.data?.tag === MARK_TAG && typeof event.data.payload?.label === "string") {
+      scan.marks.push({ ts: event.timestamp, label: event.data.payload.label });
+    }
+  }
+  if (chunk.length > 0) {
+    yield `${chunk.join("\n")}
+`;
+  }
+}
+function marksFrom(marks, startTs) {
+  return marks.map((mark) => ({ at: Math.max(0, mark.ts - startTs), label: mark.label })).sort((a, b) => a.at - b.at);
+}
+function sessionIdOf(file) {
+  return basename2(file).replace(REPLAY_SUFFIX, "");
+}
+async function readMeta(file) {
+  try {
+    return JSON.parse(await readFile3(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function metaFor(kind, file) {
+  if (kind === "replay") {
+    return readMeta(join5(dirname4(file), `${sessionIdOf(file)}${META_SUFFIX}`));
+  }
+  const folder = basename2(dirname4(file)) === "video" ? dirname4(dirname4(file)) : dirname4(file);
+  for (const name of await readdir(folder).catch(() => [])) {
+    if (name.endsWith(META_SUFFIX) && name !== LEDGER_FILE) {
+      const meta = await readMeta(join5(folder, name));
+      if (meta?.video === file) {
+        return meta;
+      }
+    }
+  }
+  return null;
+}
+async function ledger(dir) {
+  try {
+    return new Set(JSON.parse(await readFile3(join5(dir, LEDGER_FILE), "utf8")));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function remember(dir, file) {
+  const done = await ledger(dir);
+  done.add(file);
+  await writeFile3(join5(dir, LEDGER_FILE), JSON.stringify([...done]));
+}
+async function nonEmpty(file) {
+  return file !== null && ((await stat(file).catch(() => null))?.size ?? 0) > 0;
+}
+async function pendingRecordings(dir) {
+  const done = await ledger(dir);
+  const names = (await readdir(dir).catch(() => [])).sort();
+  const pending = [];
+  for (const name of names) {
+    if (!name.endsWith(META_SUFFIX) || name === LEDGER_FILE) {
+      continue;
+    }
+    const meta = await readMeta(join5(dir, name));
+    const replay = join5(dir, `${name.slice(0, -META_SUFFIX.length)}${REPLAY_SUFFIX}`);
+    if (!done.has(replay) && await nonEmpty(replay)) {
+      pending.push({ kind: "replay", file: replay, meta });
+    }
+    if (meta?.video && !done.has(meta.video) && await nonEmpty(meta.video)) {
+      pending.push({ kind: "video", file: meta.video, meta });
+    }
+  }
+  return pending;
+}
+async function uploadReplay(upload, file, caption) {
+  const id = randomUUID();
+  const scan = { startTs: Number.POSITIVE_INFINITY, snapshot: false, marks: [] };
+  const lines = createInterface3({ input: createReadStream(file, "utf8"), crlfDelay: Infinity });
+  for await (const chunk of replayChunks(lines, scan)) {
+    await upload.api.upload("POST", recordingUploadPath(upload.runId, id, "chunks"), new Uint8Array(await gzipAsync(chunk)), "application/gzip");
+  }
+  if (!scan.snapshot) {
+    throw new Error("This replay has no page snapshot, so it cannot be played. Was the page ever opened?");
+  }
+  return finish(upload, { kind: "replay", upload: id, name: basename2(file), ...caption, contentType: "application/x-ndjson", durationMs: null, marks: marksFrom(scan.marks, scan.startTs) });
+}
+async function uploadVideo(upload, file, caption, meta) {
+  const contentType = VIDEO_TYPES_BY_EXTENSION[extname(file).toLowerCase()];
+  const info = await stat(file);
+  if (info.size > MAX_VIDEO_BYTES) {
+    throw new Error(`The video is larger than ${MAX_VIDEO_BYTES / 1024 / 1024} MB. Record a shorter one.`);
+  }
+  const id = randomUUID();
+  const body = Readable.toWeb(createReadStream(file));
+  await upload.api.upload("PUT", recordingUploadPath(upload.runId, id, "video"), body, contentType);
+  const startedAt = meta?.startedAt ?? info.birthtimeMs;
+  const endedAt = meta?.endedAt ?? info.mtimeMs;
+  const durationMs = Math.max(0, Math.round(endedAt - startedAt));
+  const marks = marksFrom(meta?.marks ?? [], startedAt).filter((mark) => mark.at <= durationMs);
+  return finish(upload, { kind: "video", upload: id, name: basename2(file), ...caption, contentType, durationMs, marks });
+}
+async function finish(upload, body) {
+  return (await upload.api.request("POST", runPath(upload.runId, "recordings"), body)).id;
+}
+async function attachRecording(api, runId, recordingsDir2, request) {
+  if (!isAbsolute(request.path)) {
+    return `Give the absolute path of the ${request.kind === "replay" ? "replay (.rrweb.ndjson)" : "video (.webm or .mp4)"} file.`;
+  }
+  const fitsKind = request.kind === "replay" ? request.path.endsWith(REPLAY_SUFFIX) : extname(request.path).toLowerCase() in VIDEO_TYPES_BY_EXTENSION;
+  if (!fitsKind) {
+    return request.kind === "replay" ? `A replay is the ${REPLAY_SUFFIX} file the TAMsense recorder wrote.` : "Only WebM and MP4 videos can be attached.";
+  }
+  if (!await nonEmpty(request.path)) {
+    return `There is no recording at ${request.path}. Close the browser context first (closeRecorded) so the file is complete.`;
+  }
+  let caption;
+  try {
+    caption = checkCaption(request);
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  try {
+    const meta = await metaFor(request.kind, request.path);
+    const upload = { api, runId };
+    await (request.kind === "replay" ? uploadReplay(upload, request.path, caption) : uploadVideo(upload, request.path, caption, meta));
+    await remember(recordingsDir2, request.path);
+  } catch (error) {
+    return `Could not attach the ${request.kind}: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  return "Attached to the task.";
+}
+function numbered(key, title, used) {
+  const count = (used.get(key) ?? 0) + 1;
+  used.set(key, count);
+  const suffix = count > 1 ? ` (${count})` : "";
+  return `${title.slice(0, MAX_TITLE_LENGTH - suffix.length)}${suffix}`;
+}
+function overLimit(error) {
+  return error instanceof ApiError && error.status === 422 && /at most/i.test(error.message);
+}
+async function uploadPendingRecordings(api, runId, dir) {
+  const report = { uploaded: 0, failed: [], skipped: 0 };
+  const used = /* @__PURE__ */ new Map();
+  const full = /* @__PURE__ */ new Set();
+  const upload = { api, runId };
+  const pending = (await pendingRecordings(dir)).sort((a, b) => Number(a.meta?.automatic ?? true) - Number(b.meta?.automatic ?? true));
+  for (const recording of pending) {
+    if (full.has(recording.kind)) {
+      report.skipped += 1;
+      continue;
+    }
+    const title = recording.meta?.title || "Browser session";
+    const caption = checkCaption({
+      title: numbered(`${recording.kind}:${title}`, title, used),
+      purpose: recording.meta?.purpose || "Recorded automatically while the agent used a browser"
+    });
+    try {
+      await (recording.kind === "replay" ? uploadReplay(upload, recording.file, caption) : uploadVideo(upload, recording.file, caption, recording.meta));
+      await remember(dir, recording.file);
+      report.uploaded += 1;
+    } catch (error) {
+      if (overLimit(error)) {
+        full.add(recording.kind);
+        report.skipped += 1;
+        continue;
+      }
+      report.failed.push(`${caption.title} (${recording.kind}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return report;
+}
+
+// src/screenshot.ts
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
+import { basename as basename3, extname as extname2, isAbsolute as isAbsolute2 } from "path";
+var TYPES_BY_EXTENSION = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp"
+};
+async function readScreenshot(request) {
+  if (!isAbsolute2(request.path)) {
+    return "Give the absolute path of the image file.";
+  }
+  const contentType = TYPES_BY_EXTENSION[extname2(request.path).toLowerCase()];
+  if (!contentType) {
+    return "Only PNG, JPEG and WebP images can be attached.";
+  }
+  let caption;
+  try {
+    caption = checkCaption(request);
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  const info = await stat2(request.path).catch(() => null);
+  if (!info?.isFile()) {
+    return `There is no file at ${request.path}.`;
+  }
+  if (info.size > MAX_ATTACHMENT_BYTES) {
+    return "The image is larger than 5 MB. Take a smaller screenshot (viewport instead of full page, or JPEG).";
+  }
+  const data = (await readFile4(request.path)).toString("base64");
+  return { name: basename3(request.path), ...caption, contentType, data };
+}
+
+// src/workspace.ts
+import { existsSync as existsSync3 } from "fs";
+import { rm as rm3 } from "fs/promises";
+import { join as join6 } from "path";
+
+// src/git.ts
+import { Buffer } from "buffer";
+import { spawn as spawn4 } from "child_process";
+var GITHUB_ORIGIN = "https://github.com/";
+function githubAuthEnv(token) {
+  const credentials = Buffer.from(`x-access-token:${token}`).toString("base64");
+  return {
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: `http.${GITHUB_ORIGIN}.extraheader`,
+    GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${credentials}`,
+    GIT_TERMINAL_PROMPT: "0"
+  };
+}
+function runGit(args, options) {
+  const env = { ...process.env, ...options.env, ...options.token ? githubAuthEnv(options.token) : {} };
+  return new Promise((resolve, reject) => {
+    const child = spawn4("git", args, { cwd: options.cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() }));
+  });
+}
+async function git(args, options) {
+  const result = await runGit(args, options);
+  if (result.code !== 0) {
+    throw new Error(`git ${args[0]} failed: ${result.stderr || result.stdout || `exit code ${result.code}`}`);
+  }
+  return result.stdout;
+}
+
+// src/workspace.ts
+var FALLBACK_IDENTITY = { name: "TAMsense", email: "noreply@tamsense.com" };
+var cacheLock = keyedLock();
+function githubRemoteUrl(fullName) {
+  return `https://github.com/${fullName}.git`;
+}
+function tamsenseFolder(home, ...parts) {
+  return join6(home, ".tamsense", ...parts);
+}
+function folderNames(repositories) {
+  const shortName = (fullName) => fullName.split("/").pop() ?? fullName;
+  const counts = /* @__PURE__ */ new Map();
+  for (const repository of repositories) {
+    counts.set(shortName(repository.fullName), (counts.get(shortName(repository.fullName)) ?? 0) + 1);
+  }
+  return repositories.map((repository) => counts.get(shortName(repository.fullName)) === 1 ? shortName(repository.fullName) : repository.fullName.replace("/", "__"));
+}
+async function refreshCache(cache, repository, token, tools) {
+  if (existsSync3(join6(cache, ".git"))) {
+    await git(["fetch", "--prune", "origin"], { cwd: cache, token });
+    return;
+  }
+  await git(["clone", "--no-checkout", tools.remoteUrl(repository.fullName), cache], { cwd: tools.home, token });
+}
+async function removeWorktree(cache, path) {
+  await runGit(["worktree", "remove", "--force", path], { cwd: cache });
+  await rm3(path, { recursive: true, force: true });
+  await git(["worktree", "prune"], { cwd: cache });
+}
+async function baseRef(cache, job, repository) {
+  const pushed = await runGit(["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${job.branch}`], { cwd: cache });
+  return pushed.code === 0 ? `origin/${job.branch}` : `origin/${repository.defaultBranch}`;
+}
+async function prepareWorkspace(job, token, tools) {
+  const root = tamsenseFolder(tools.home, "work", `task-${job.taskId}`);
+  const folders = folderNames(job.repositories);
+  const repositories = [];
+  for (const [index, repository] of job.repositories.entries()) {
+    const cache = tamsenseFolder(tools.home, "repos", repository.fullName.replace("/", "__"));
+    const folder = folders[index] ?? repository.fullName;
+    const path = join6(root, folder);
+    const baseSha = await cacheLock.run(repository.fullName, async () => {
+      await refreshCache(cache, repository, token, tools);
+      await removeWorktree(cache, path);
+      await git(["worktree", "add", "--force", "-B", job.branch, path, await baseRef(cache, job, repository)], { cwd: cache });
+      return git(["rev-parse", "HEAD"], { cwd: path });
+    });
+    repositories.push({ fullName: repository.fullName, folder, path, baseSha });
+  }
+  return { root, repositories };
+}
+async function commitIdentityEnv(home) {
+  const configured = await runGit(["config", "--get", "user.email"], { cwd: home });
+  if (configured.code === 0 && configured.stdout) {
+    return {};
+  }
+  return {
+    GIT_AUTHOR_NAME: FALLBACK_IDENTITY.name,
+    GIT_AUTHOR_EMAIL: FALLBACK_IDENTITY.email,
+    GIT_COMMITTER_NAME: FALLBACK_IDENTITY.name,
+    GIT_COMMITTER_EMAIL: FALLBACK_IDENTITY.email
+  };
+}
+async function publishWorkspace(workspace, job, token, identity) {
+  const pushed = [];
+  for (const repository of workspace.repositories) {
+    const options = { cwd: repository.path, env: identity };
+    const sha = await cacheLock.run(repository.fullName, async () => {
+      await git(["add", "--all"], options);
+      const hasStaged = (await runGit(["diff", "--cached", "--quiet"], options)).code === 1;
+      if (hasStaged) {
+        await git(["commit", "--message", `Task #${job.taskId}: ${job.title}`], options);
+      }
+      const newCommits = Number(await git(["rev-list", "--count", `${repository.baseSha}..HEAD`], options));
+      if (newCommits === 0) {
+        return null;
+      }
+      await git(["push", "origin", `HEAD:refs/heads/${job.branch}`], { ...options, token });
+      return git(["rev-parse", "HEAD"], options);
+    });
+    if (sha) {
+      pushed.push({ repository: repository.fullName, branch: job.branch, sha });
+    }
+  }
+  return pushed;
+}
+
+// src/worker.ts
+var POLL_INTERVAL_MS = 5e3;
+var RETRY_AFTER_ERROR_MS = 15e3;
+var INBOX_INTERVAL_MS = 2e3;
+var MAX_MESSAGE_LINE = 200;
+var CAPABILITIES_INTERVAL_MS = 30 * 6e4;
+var FEED_INTERVAL_MS = 1500;
+var FATAL_STATUSES = /* @__PURE__ */ new Set([401, 403]);
+var STOPPED_HERE = "stopped_here";
+var CLOSED_ON_SITE = "closed_on_site";
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isFatal(error) {
+  return error instanceof ApiError && FATAL_STATUSES.has(error.status);
+}
+async function gitToken(api, job) {
+  return (await api.request("POST", runPath(job.runId, "git-token"))).token;
+}
+async function attachScreenshot(api, job, screenshot, attached) {
+  if (attached.count >= MAX_ATTACHMENTS_PER_RUN) {
+    return `This run already attached ${MAX_ATTACHMENTS_PER_RUN} screenshots. Mention the rest in your report.`;
+  }
+  const body = await readScreenshot(screenshot);
+  if (typeof body === "string") {
+    return body;
+  }
+  try {
+    await api.request("POST", runPath(job.runId, "attachments"), body);
+  } catch (error) {
+    return `Could not attach the screenshot: ${messageOf(error)}`;
+  }
+  attached.count += 1;
+  return "Attached to the task.";
+}
+function sessionReporter(api, job, print2) {
+  let sending = null;
+  return {
+    report: (session) => {
+      sending ??= api.request("POST", runPath(job.runId, "session"), session).then(() => {
+      }, (error) => print2(`Could not tell TAMsense which Claude took the task: ${messageOf(error)}`));
+    },
+    sent: async () => {
+      await sending;
+    }
+  };
+}
+function journal(feed, print2) {
+  return (draft) => {
+    feed.push(draft);
+    const line = consoleLine(draft);
+    if (line) {
+      print2(`  ${line}`);
+    }
+  };
+}
+function messageLine(message) {
+  const line = `Message from ${message.authorName}: ${message.text}`.replace(/\s+/g, " ").trim();
+  return line.length > MAX_MESSAGE_LINE ? `${line.slice(0, MAX_MESSAGE_LINE - 1)}\u2026` : line;
+}
+function inbox(job, tools, record, closedOnSite) {
+  const input = inputChannel({ onIdle: () => void poll() });
+  let running = null;
+  let again = false;
+  let failing = false;
+  async function check() {
+    const ack = input.takeDelivered();
+    const body = { ack };
+    let reply2;
+    try {
+      reply2 = await tools.api.request("POST", runPath(job.runId, "inbox"), body);
+    } catch (error) {
+      input.restoreDelivered(ack);
+      if (!failing) {
+        tools.print(`Could not check for new messages on TAMsense, trying again: ${messageOf(error)}`);
+      }
+      failing = true;
+      return;
+    }
+    failing = false;
+    if (!reply2.keepGoing) {
+      closedOnSite();
+      return;
+    }
+    for (const message of reply2.messages) {
+      if (input.push(message)) {
+        tools.print(`  ${messageLine(message)}`);
+      }
+    }
+    if (reply2.model !== null || reply2.effort !== null) {
+      const change = { model: reply2.model, effort: reply2.effort };
+      void input.switchModel(change).then(
+        (applied) => {
+          if (applied) {
+            record({ kind: "tool", text: switchLine(change), tool: "model", ref: null, parent: null, failed: false });
+          }
+        },
+        (error) => tools.print(`Could not switch the model: ${messageOf(error)}`)
+      );
+    }
+  }
+  function poll() {
+    if (running) {
+      again = true;
+      return running;
+    }
+    running = input.checking(check).finally(() => {
+      running = null;
+      if (again) {
+        again = false;
+        void poll();
+      }
+    });
+    return running;
+  }
+  return {
+    input,
+    poll,
+    settled: async () => {
+      for (let current = running; current; current = running) {
+        await current;
+      }
+    }
+  };
+}
+function specWorkTools2(job, api) {
+  const { kind } = job.stage;
+  if (kind !== "interview" && kind !== "spec") {
+    return null;
+  }
+  return { stage: kind, review: (body) => api.request("POST", runPath(job.runId, "review"), body) };
+}
+async function executeJob(job, tools, signal, input, record) {
+  const isCheck = job.stage.kind === "review" || job.stage.kind === "test";
+  tools.print("Preparing the code\u2026");
+  const workspace = await prepareWorkspace(job, await gitToken(tools.api, job), tools);
+  const identity = await commitIdentityEnv(tools.home);
+  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(process4.env, dirname5(process4.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,
+    prompt: buildTaskPrompt(job, workspace, { browser: Boolean(tools.browser), recorder: Boolean(tools.recorder) }),
+    input,
+    env: { ...baseEnv, ...tools.browser ? browserEnv(tools.browser) : {}, ...recording, ...identity },
+    signal,
+    wantsVerdict: isCheck,
+    specWork: specWorkTools2(job, tools.api),
+    handoffs: job.allowedHandoffs,
+    resumeSessionId: job.resumeSessionId,
+    model: job.model,
+    effort: job.effort,
+    onFeed: record,
+    onSession: session.report,
+    attach: (request) => request.kind === "screenshot" ? attachScreenshot(tools.api, job, request, attached) : attachRecording(tools.api, job.runId, recordings, request)
+  });
+  await session.sent();
+  signal.throwIfAborted();
+  const shouldPublish = job.stage.kind === "code" && outcome.completed;
+  const pushed = shouldPublish ? await publishWorkspace(workspace, job, await gitToken(tools.api, job), identity) : [];
+  return {
+    outcome: outcome.completed ? "succeeded" : "failed",
+    report: outcome.report,
+    pushed,
+    model: outcome.model,
+    usage: outcome.usage,
+    verdict: outcome.verdict,
+    handoff: outcome.handoff ?? null,
+    sessionId: outcome.sessionId ?? null,
+    pausedUntil: outcome.pausedUntil ?? null,
+    questions: outcome.questions ?? null,
+    spec: outcome.spec ?? null
+  };
+}
+function clockOf(iso) {
+  const time = new Date(iso);
+  return `${String(time.getHours()).padStart(2, "0")}:${String(time.getMinutes()).padStart(2, "0")}`;
+}
+function resultLine(finish2) {
+  if (finish2.pausedUntil) {
+    return `Paused: ${USAGE_LIMIT_REPORT}, resumes at ${clockOf(finish2.pausedUntil)}`;
+  }
+  if (finish2.verdict) {
+    return finish2.verdict.passed ? "Check passed." : `Check did not pass: ${finish2.verdict.report}`;
+  }
+  if (finish2.questions) {
+    return finish2.questions.questions.length > 0 ? `Done. ${finish2.questions.questions.length} question(s) wait for the owner on TAMsense.` : "Done. No questions needed, the spec is written next.";
+  }
+  if (finish2.spec) {
+    return "Done. The spec waits for the owner on TAMsense.";
+  }
+  return finish2.outcome === "succeeded" ? `Done. Pushed ${finish2.pushed.length} branch(es), the pull requests open on TAMsense.` : `Failed: ${finish2.report}`;
+}
+async function sendRecordings(job, tools) {
+  const folder = recordingsFolder(tools.home, job.runId);
+  try {
+    const report = await uploadPendingRecordings(tools.api, job.runId, folder);
+    if (report.uploaded > 0) {
+      tools.print(`Attached ${report.uploaded} browser recording(s) to the task.`);
+    }
+    if (report.skipped > 0) {
+      tools.print(`${report.skipped} more recording(s) were not attached: the run reached its limit.`);
+    }
+    for (const line of report.failed) {
+      tools.print(`Could not attach a recording: ${line}`);
+    }
+  } finally {
+    await rm4(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: ${messageOf(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);
+  if (stop.aborted) {
+    stopRun();
+  }
+  stop.addEventListener("abort", stopRun, { once: true });
+  const feed = feedQueue((entries) => tools.api.request("POST", runPath(job.runId, "feed"), { entries }));
+  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 { input } = messages;
+  run2.signal.addEventListener("abort", input.close, { once: true });
+  void messages.poll();
+  const polling = setInterval(() => void messages.poll(), INBOX_INTERVAL_MS);
+  let finish2;
+  try {
+    finish2 = await executeJob(job, tools, run2.signal, input, record);
+  } 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 };
+  } finally {
+    clearInterval(polling);
+    clearInterval(feeding);
+    stop.removeEventListener("abort", stopRun);
+    input.close();
+  }
+  await messages.settled();
+  if (input.hasDelivered()) {
+    await messages.poll();
+  }
+  await feed.flush();
+  if (run2.signal.reason === CLOSED_ON_SITE) {
+    await rm4(recordingsFolder(tools.home, job.runId), { recursive: true, force: true });
+    tools.print("TAMsense closed this run while it was in progress. The result was not sent.");
+    return;
+  }
+  await sendRecordings(job, tools).catch((error) => tools.print(`Could not attach the browser recordings: ${messageOf(error)}`));
+  try {
+    await tools.api.request("POST", runPath(job.runId, "finish"), finish2);
+    tools.print(resultLine(finish2));
+  } catch (error) {
+    tools.print(`Could not send the result to TAMsense: ${messageOf(error)}`);
+  }
+}
+async function reportCapabilities(tools, stop) {
+  if (!tools.capabilities) {
+    return;
+  }
+  let printed = false;
+  let complained = false;
+  while (!stop.aborted) {
+    try {
+      const capabilities = await tools.capabilities(stop);
+      await tools.api.request("PUT", CAPABILITIES_PATH, capabilities);
+      if (!printed) {
+        tools.print(capabilitiesLine(capabilities));
+        printed = true;
+      }
+    } catch (error) {
+      if (!complained && !stop.aborted) {
+        tools.print(`Could not tell TAMsense which Claude models this computer has: ${messageOf(error)}`);
+        complained = true;
+      }
+    }
+    await tools.sleep(CAPABILITIES_INTERVAL_MS, stop);
+  }
+}
+function jobTools(job, tools, parallel) {
+  return parallel > 1 ? { ...tools, print: (line) => tools.print(`[#${job.taskId}] ${line}`) } : tools;
+}
+async function work(tools, stop, parallel = 1) {
+  tools.print(parallel > 1 ? `Waiting for tasks, up to ${parallel} at once. Press Ctrl+C to stop.` : "Waiting for tasks. Press Ctrl+C to stop.");
+  const halt = new AbortController();
+  const stopAll = AbortSignal.any([stop, halt.signal]);
+  const running = /* @__PURE__ */ new Set();
+  const taskLock = keyedLock();
+  const reporting = reportCapabilities(tools, stopAll);
+  const start = (job) => {
+    const runTools = jobTools(job, tools, parallel);
+    const task = taskLock.run(String(job.taskId), () => runJob(job, runTools, stopAll)).catch((error) => runTools.print(`The run stopped: ${messageOf(error)}`)).finally(() => running.delete(task));
+    running.add(task);
+  };
+  try {
+    while (!stopAll.aborted) {
+      if (running.size >= parallel) {
+        await Promise.race(running);
+        continue;
+      }
+      let reply2;
+      try {
+        reply2 = await tools.api.request("POST", NEXT_RUN_PATH);
+      } catch (error) {
+        if (isFatal(error)) {
+          halt.abort();
+          throw error;
+        }
+        tools.print(`Could not reach TAMsense: ${messageOf(error)}. Trying again soon.`);
+        await tools.sleep(RETRY_AFTER_ERROR_MS, stopAll);
+        continue;
+      }
+      if (reply2.job) {
+        start(reply2.job);
+      } else {
+        await tools.sleep(POLL_INTERVAL_MS, stopAll);
+      }
+    }
+  } finally {
+    await Promise.allSettled([...running, reporting]);
+  }
+}
+
+// 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 INTERRUPTED_EXIT_CODE = 130;
+function print(line) {
+  process5.stdout.write(`${line}
+`);
+}
+function serverFor(flag, saved) {
+  return serverOrigin(flag ?? process5.env.TAMSENSE_URL ?? saved?.server ?? DEFAULT_SERVER);
+}
+function accessProblem(error) {
+  return error instanceof ApiError ? ACCESS_PROBLEMS[error.status] ?? null : null;
+}
+async function forgetDevice(config) {
+  await createApi(config.server, config.token).request("DELETE", IDENTITY_PATH).catch(() => {
+  });
+  await removeConfig();
+}
+async function runLogin(server, deviceName) {
+  const saved = await readConfig();
+  const api = createApi(serverFor(server, saved));
+  if (saved) {
+    await forgetDevice(saved);
+  }
+  const name = deviceName?.trim() || defaultDeviceName();
+  const result = await login(
+    { api, openBrowser, print, sleep, now: Date.now },
+    { name, platform: platformLabel() }
+  );
+  const browserDeclined = saved?.browserDeclined ? { browserDeclined: true } : {};
+  await writeConfig({ server: api.server, token: result.token, deviceId: result.device.id, deviceName: result.device.name, ...browserDeclined });
+  print(`Connected: ${result.device.name}. To take your tasks, run ${START_COMMAND}`);
+}
+function stopOnInterrupt() {
+  const stop = new AbortController();
+  process5.once("SIGINT", () => {
+    print("Stopping\u2026 Press Ctrl+C again to quit at once.");
+    stop.abort();
+    process5.once("SIGINT", () => process5.exit(INTERRUPTED_EXIT_CODE));
+  });
+  return stop.signal;
+}
+function installTools(home) {
+  return { home, nodePath: process5.execPath, env: process5.env, print, run: runProcess, exists: existsSync4 };
+}
+async function browserForStart(home, saved) {
+  return await installedBrowser(home) ?? await offerBrowser({
+    interactive: Boolean(process5.stdin.isTTY && process5.stdout.isTTY),
+    declined: saved.browserDeclined === true,
+    print,
+    ask: askYesNo,
+    install: () => installBrowser(installTools(home)),
+    rememberDecline: async () => writeConfig({ ...saved, browserDeclined: true })
+  });
+}
+async function startedNewVersion() {
+  const update = await updateToRun(process5.env, currentVersion(), () => latestVersion());
+  if (!update) {
+    return false;
+  }
+  print(`TAMsense runner ${update.latest} is out, this is ${update.current}. Starting the new version...`);
+  try {
+    process5.exitCode = await relaunch(process5.argv.slice(2), process5.env);
+    return true;
+  } catch {
+    print("Could not start the new version. Going on with this one.");
+    return false;
+  }
+}
+async function runStart(parallel) {
+  if (await startedNewVersion()) {
+    return;
+  }
+  const saved = await readConfig();
+  if (!saved) {
+    print(NOT_CONNECTED_TEXT);
+    return;
+  }
+  const api = createApi(saved.server, saved.token);
+  const identity = await api.request("GET", IDENTITY_PATH);
+  const problem = teamKeyProblem(identity.device.team, process5.env);
+  if (problem) {
+    throw new Error(problem);
+  }
+  print(`${identity.device.name} is connected to ${saved.server} as ${describeDevice(identity)}.`);
+  const home = homedir3();
+  const browser = await browserForStart(home, saved);
+  await work({ api, runAgent: runClaude, capabilities: probeCapabilities, print, sleep, home, remoteUrl: githubRemoteUrl, browser, recorder: bundledRecorder() }, stopOnInterrupt(), parallel);
+}
+async function runBrowser(remove) {
+  const home = homedir3();
+  if (remove) {
+    print(await removeBrowser(home) ? "Removed the headless browser." : "No headless browser is installed.");
+    const saved = await readConfig();
+    if (saved) {
+      await writeConfig({ ...saved, browserDeclined: true });
+    }
+    return;
+  }
+  const installed = await installedBrowser(home);
+  if (installed) {
+    print(browserStatusText(installed));
+    return;
+  }
+  await installBrowser(installTools(home));
+  print("Claude uses it for interface checks from the next start.");
+}
+async function runStatus() {
+  const saved = await readConfig();
+  if (!saved) {
+    print(NOT_CONNECTED_TEXT);
+    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}`);
+}
+async function runLogout() {
+  const saved = await readConfig();
+  if (!saved) {
+    print(NOT_CONNECTED_TEXT);
+    return;
+  }
+  await forgetDevice(saved);
+  print("Disconnected. This computer no longer takes your tasks.");
+}
+async function run(command) {
+  if (command.name === "login") {
+    await runLogin(command.server, command.deviceName);
+  } else if (command.name === "start") {
+    await runStart(command.parallel);
+  } else if (command.name === "browser") {
+    await runBrowser(command.remove);
+  } else if (command.name === "status") {
+    await runStatus();
+  } else if (command.name === "logout") {
+    await runLogout();
+  } else {
+    print(HELP_TEXT);
+  }
+}
+try {
+  await run(parseCommand(process5.argv.slice(2), process5.env));
+} catch (error) {
+  process5.stderr.write(`${accessProblem(error) ?? (error instanceof Error ? error.message : String(error))}
+`);
+  process5.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map