@tamsensedev/runner 0.1.0 → 0.3.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-import process3 from "process";
+import process5 from "process";
 
 // src/api.ts
 var DEFAULT_SERVER = "https://my.tamsense.com";
@@ -39,27 +39,26 @@ async function errorOf(response) {
   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,
-    async request(method, path, body) {
-      const headers = { accept: "application/json" };
-      if (body) {
-        headers["content-type"] = "application/json";
-      }
-      if (token) {
-        headers.authorization = `Bearer ${token}`;
-      }
-      let response;
-      try {
-        response = await fetchImpl(new URL(path, server), { method, headers, body: body && JSON.stringify(body) });
-      } 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();
-    }
+    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)
   };
 }
 
@@ -72,9 +71,9 @@ import { createInterface } from "readline";
 
 // src/commands.ts
 import { parseArgs } from "util";
-var LOGIN_COMMAND = "npx @tamsensedev/runner login";
-var START_COMMAND = "npx @tamsensedev/runner start";
-var BROWSER_COMMAND = "npx @tamsensedev/runner browser";
+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.
@@ -82,17 +81,18 @@ 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}  install the headless browser for interface checks now, or show it
   ${BROWSER_COMMAND} remove   delete that browser
-  npx @tamsensedev/runner status   show the connection
-  npx @tamsensedev/runner logout   disconnect this computer
+  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)`;
+  --parallel <n>   how many tasks to work on at once, 1 to ${MAX_PARALLEL} (default: ${DEFAULT_PARALLEL}, or TAMSENSE_PARALLEL)
+  --no-browser     do not install the headless browser for interface checks (start installs it when it is missing)`;
 function parallelFor(flag, env) {
   const [source, value] = flag !== void 0 ? ["--parallel", flag] : ["TAMSENSE_PARALLEL", env?.trim() || void 0];
   if (value === void 0) {
@@ -110,10 +110,11 @@ function parseCommand(argv, env = {}) {
     allowPositionals: true,
     strict: true,
     options: {
-      server: { type: "string" },
-      name: { type: "string" },
-      parallel: { type: "string" },
-      help: { type: "boolean" }
+      "server": { type: "string" },
+      "name": { type: "string" },
+      "parallel": { type: "string" },
+      "no-browser": { type: "boolean" },
+      "help": { type: "boolean" }
     }
   });
   const [name, detail] = positionals;
@@ -130,7 +131,7 @@ function parseCommand(argv, env = {}) {
     return { name: "login", server: values.server ?? null, deviceName: values.name ?? null };
   }
   if (name === "start") {
-    return { name: "start", parallel: parallelFor(values.parallel, env.TAMSENSE_PARALLEL) };
+    return { name: "start", parallel: parallelFor(values.parallel, env.TAMSENSE_PARALLEL), browser: !values["no-browser"] };
   }
   if (name === "status" || name === "logout") {
     return { name };
@@ -146,8 +147,7 @@ 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 INSTALLING_TEXT = "Interface checks need a headless browser. Installing it once into ~/.tamsense, about 150 MB. To start without it, add --no-browser.";
 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");
@@ -249,24 +249,13 @@ async function removeBrowser(home) {
   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;
-  }
+async function ensureBrowser(tools) {
+  tools.print(INSTALLING_TEXT);
   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.");
+    tools.print(`Tasks still run without it. To try again, run ${BROWSER_COMMAND}`);
     return null;
   }
 }
@@ -355,6 +344,56 @@ 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/askPerson.ts
+var MAX_ASK_TRIES = 5;
+var MAX_ASK_OPTIONS = 4;
+function personLine(person) {
+  const roles = person.roles.length > 0 ? `, ${person.roles.join(", ")}` : "";
+  return `${person.id}: ${person.name} (${person.relation}, ${person.access} access${roles})`;
+}
+function findPerson(people, to) {
+  const key = String(to).trim().toLowerCase();
+  return people.find((person) => String(person.id) === key || person.name.toLowerCase() === key) ?? null;
+}
+function cleanTry(item) {
+  return { did: item.did.trim(), error: item.error?.trim() || null, result: item.result.trim() };
+}
+function checkAsk(people, request) {
+  const question = request.question.trim();
+  const why = request.why.trim();
+  const assumption = request.assumption?.trim() ?? "";
+  if (!question) {
+    return { error: "Write the question: one plain sentence the person can answer without reading the code." };
+  }
+  const person = findPerson(people, request.to);
+  if (!person) {
+    return { error: `"${request.to}" is not a person on this task. Ask one of them by id:
+${people.map(personLine).join("\n")}` };
+  }
+  if (!why) {
+    return { error: `Say in one line why ${person.name} is the right person to ask.` };
+  }
+  if (!request.blocking && !assumption) {
+    return { error: "A question you do not wait for needs the assumption you continue with until the answer comes." };
+  }
+  const tried = (request.tried ?? []).map(cleanTry).filter((item) => item.did);
+  const options = (request.options ?? []).map((option) => ({ label: option.label.trim(), detail: option.detail.trim() })).filter((option) => option.label);
+  if (tried.length > MAX_ASK_TRIES || options.length > MAX_ASK_OPTIONS) {
+    return { error: `Keep it short: at most ${MAX_ASK_TRIES} things you tried and at most ${MAX_ASK_OPTIONS} suggested answers.` };
+  }
+  return {
+    person,
+    body: { to: person.id, why, question, context: request.context?.trim() ?? "", tried, options, blocking: request.blocking, assumption: request.blocking ? null : assumption }
+  };
+}
+function askedText(name, body) {
+  if (body.blocking) {
+    return `Sent to ${name}. This run now waits for the answer and frees the computer. Write one short line saying what you wait for, then end your turn without doing more work. When ${name} answers, this conversation continues here with the answer.`;
+  }
+  return `Sent to ${name}. Keep working on your assumption: ${body.assumption}. The answer comes as a message from ${name} while you work, or with the next run if this one has ended. If it differs, change what you did.`;
+}
+var ALREADY_WAITING_TEXT = "You already asked a question this run waits for. End your turn now: the conversation continues when the answer comes.";
+
 // src/claudeResult.ts
 var MAX_ACTIVITY_LENGTH = 120;
 var FILE_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "MultiEdit", "NotebookEdit"]);
@@ -407,6 +446,7 @@ 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;
@@ -431,14 +471,14 @@ function toolDraft(block, parent) {
     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";
+    const verdict = fields.couldNotRun === true ? "Could not run" : fields.passed === true ? "Passed" : "Did not pass";
     return { ...base, kind: "tool", text: clip(`${verdict}. ${textField(fields, "report") ?? ""}`, MAX_SUMMARY_LENGTH) };
   }
   if (tool3 === "hand_off") {
     return { ...base, kind: "tool", text: clip(`Hand off to ${textField(fields, "to") ?? "?"}: ${textField(fields, "note") ?? ""}`, MAX_SUMMARY_LENGTH) };
   }
-  if (tool3 === "attach_screenshot") {
-    return { ...base, kind: "tool", text: clip(`Screenshot: ${textField(fields, "caption") ?? textField(fields, "path") ?? ""}`, 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);
@@ -813,10 +853,15 @@ function specPromptText(spec) {
 // 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 ASK_PERSON_TOOL_NAME = "ask_person";
+var MESSAGES_RULE = `You are working on a TAMsense task on the user's own computer. People on the task may send you messages during this run, each starting with "Message from <name>:". Follow them: they take priority over the original task where the two disagree.`;
+var UNATTENDED_RULE = `${MESSAGES_RULE} Nobody answers questions or approves actions during the run, so never stop to wait for a reply: decide yourself, keep working, and explain your decisions in your report.`;
+var ASKING_RULE = `${MESSAGES_RULE} Decide yourself when you reasonably can, keep working, and explain your decisions in your report. When you are stuck, or the decision belongs to a person (intent, design, access, how the team runs something locally), ask one of the people on the task with the ${ASK_PERSON_TOOL_NAME} tool instead of guessing, and say what you tried. Never ask what the code or the project knowledge already answers. Nobody watches your messages, so ask only with the tool.`;
 var 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.",
@@ -832,8 +877,24 @@ var CHECK_RULES = [
   "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, with a caption saying what each one shows. People see them on the task without opening the code.`;
-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 SCREENSHOT_RULE = `If you render screens (screenshots of the interface), attach the ones that show the result with the ${SCREENSHOT_TOOL_NAME} tool. People see them on the task without opening the code.`;
+var NAMING_RULE = 'Name everything you attach (screenshots, replays, videos) by what it shows and why it was made: a short title such as "Design option 1", "Feature testing" or "Feature testing, attempt 2", and a one-line purpose such as "Comparing two layouts for the empty orders state". Number design variants, name test runs by their goal and attempt, and never use generic names like "screenshot1".';
+var RECORDING_RULE = `Every browser you open with Playwright from Node is recorded for the task as a replay people can watch, requests from the tested site to the TAMsense tracker are blocked, so your runs never reach analytics, and requests other than GET, HEAD and OPTIONS to addresses outside this computer are aborted. In every browser script, load the recorder from the TAMSENSE_RECORDER environment variable (require(process.env.TAMSENSE_RECORDER), or createRequire(import.meta.url)(process.env.TAMSENSE_RECORDER) in an .mjs script), open each context with await recorder.newRecordedContext(browser, { title, purpose, context: { viewport } }), call await recorder.mark(page, 'what just happened') at every meaningful step, and end with await recorder.closeRecorded(context). Add video: true when the page has a canvas, a map, a video player or iframes from another site (a replay cannot show them), or when someone asks for a video. Recordings are attached to the task when the run ends; ${REPLAY_TOOL_NAME} and ${VIDEO_TOOL_NAME} attach one earlier with a better title.`;
+var BROWSER_RULE = "A headless browser is installed for interface checks. If the project has no Playwright of its own, load playwright-core from the folder in the TAMSENSE_PLAYWRIGHT environment variable, with PLAYWRIGHT_BROWSERS_PATH set to the folder in TAMSENSE_PLAYWRIGHT_BROWSERS.";
+var DEPENDENCIES_RULE = "The checkout may have no dependencies installed. To run the app or its tests, install the project's own dependencies from its lockfile with its package manager (pnpm install --frozen-lockfile, npm ci, yarn install --immutable and similar). Never add packages, change a lockfile or download browsers.";
+function localAppRule(taskId, isCheck, canAsk) {
+  const project = `tamsense-task-${taskId}`;
+  const cannotRun = isCheck ? `call ${VERDICT_TOOL_NAME} with passed false and couldNotRun true, write the exact reason and what a person should do in the report, and do not hand off: the task waits on this step for a person.` : "say so in your report with the exact reason and what a person should do.";
+  return [
+    "When you need the running app, start a local copy from this task folder only.",
+    "Find how the project runs locally yourself: the README, compose files named local or dev, .env.example and local env files, package scripts.",
+    canAsk ? `If you still cannot tell how the team prepares it, for example how the local database gets its tables, ask with ${ASK_PERSON_TOOL_NAME} instead of guessing.` : null,
+    "Use only settings meant for a local run that are in this checkout. Never read or copy .env files from elsewhere on this computer, including the person's own checkout, and never use staging, shared dev or production addresses.",
+    "Before starting, check every address in the settings you use: databases, caches, queues and APIs must point at localhost or at containers you started, and keys of outside services stay empty.",
+    `Start containers as a separate compose project named ${project} on free host ports (an override file in a temp folder), never stop or change containers you did not start, and remove yours with their volumes at the end (docker compose -p ${project} down -v).`,
+    `If Docker is not running, there is no local setup, or the settings point outside this computer, do not start anything: ${cannotRun}`
+  ].filter(Boolean).join(" ");
+}
 var STAGE_GOALS = {
   code: "Implement",
   review: "Review the code for",
@@ -884,6 +945,16 @@ 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 peopleText(people) {
+  if (people.length === 0) {
+    return null;
+  }
+  return [
+    `People on this task you can ask with ${ASK_PERSON_TOOL_NAME} (id: name, relation, access):`,
+    bulletList(people.map(personLine)),
+    "Ask the assignee first; a question on a topic goes to the person whose role fits it. Set blocking only when you cannot go on without the answer: the run then pauses and the computer is freed for other tasks. Otherwise give the assumption you continue with."
+  ].join("\n");
+}
 function handoffText(targets, isCheck) {
   if (targets.length === 0) {
     return null;
@@ -967,6 +1038,8 @@ function buildTaskPrompt(job, workspace, options = {}) {
     return buildSpecPrompt(job, job.specWork, workspace);
   }
   const isCheck = kind !== "code";
+  const people = job.people ?? [];
+  const canAsk = people.length > 0;
   const prompt = [
     `${STAGE_GOALS[kind]} TAMsense task #${job.taskId}: ${job.title}`,
     job.description,
@@ -976,9 +1049,11 @@ function buildTaskPrompt(job, workspace, options = {}) {
 ${job.review}`,
     teamMessagesText(job.messages)
   ].filter(Boolean).join("\n\n");
-  const rules = isCheck ? [...CHECK_RULES, SCREENSHOT_RULE] : [...CODE_RULES, ...job.review ? [REWORK_RULE] : [], SCREENSHOT_RULE, CODE_REPORT_RULE];
+  const evidence = [SCREENSHOT_RULE, ...options.recorder ? [RECORDING_RULE] : [], NAMING_RULE];
+  const localApp = localAppRule(job.taskId, isCheck, canAsk);
+  const rules = isCheck ? [...CHECK_RULES, DEPENDENCIES_RULE, localApp, ...evidence] : [...CODE_RULES, ...job.review ? [REWORK_RULE] : [], DEPENDENCIES_RULE, localApp, ...evidence, CODE_REPORT_RULE];
   const instructions = [
-    UNATTENDED_RULE,
+    canAsk ? ASKING_RULE : UNATTENDED_RULE,
     MACHINE_RULE,
     stepLine(job.stage),
     job.stage.instructions,
@@ -987,6 +1062,7 @@ ${job.review}`,
 ${bulletList(repositoryLines(job, workspace))}`,
     `How to work:
 ${bulletList(rules)}`,
+    peopleText(people),
     handoffText(job.allowedHandoffs, isCheck),
     options.browser && BROWSER_RULE
   ].filter(Boolean).join("\n\n");
@@ -1243,15 +1319,34 @@ 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 });
-function screenshotTool(attach) {
+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(
-    SCREENSHOT_TOOL_NAME,
-    "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: z2.string().describe("absolute path of the image file"),
-      caption: z2.string().describe('what it shows, for example "Orders page, phone width, empty state"')
-    },
-    async (args) => ({ content: [{ type: "text", text: await attach(args) }] })
+    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) {
@@ -1260,10 +1355,11 @@ function verdictTool(onVerdict) {
     "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")
+      report: z2.string().describe("what you checked and, if it failed, exactly what to fix with file and line"),
+      couldNotRun: z2.boolean().optional().describe("true when the check could not run at all because of this computer: Docker not running, no local setup, or settings that point outside this computer; passed must be false and the report gives the exact reason and what a person should do")
     },
     async (args) => {
-      onVerdict({ passed: args.passed, report: args.report });
+      onVerdict(args.couldNotRun ? { passed: false, report: args.report, couldNotRun: true } : { passed: args.passed, report: args.report });
       return { content: [{ type: "text", text: "Verdict received. You can stop now." }] };
     }
   );
@@ -1287,6 +1383,48 @@ function handoffTool(targets, onHandoff) {
     }
   );
 }
+function askPersonTool(asking, waiting) {
+  return tool2(
+    ASK_PERSON_TOOL_NAME,
+    "Ask a person on this TAMsense task when you are stuck or the decision belongs to a person: intent, design, access, or how the team runs something locally. Never ask what the code or the project knowledge already answers. With blocking true the run pauses and frees the computer until the answer comes; with blocking false you keep working on your assumption.",
+    {
+      to: z2.union([z2.number(), z2.string()]).describe("id of the person from the people list in your instructions: the assignee first; a topic question goes to the person whose role fits"),
+      why: z2.string().describe('one line on why this person: "assignee, and the run is on her computer", "Designer, owns empty states"'),
+      question: z2.string().describe("one plain question the person can answer without reading the code"),
+      context: z2.string().optional().describe("one line on what you saw that led to the question"),
+      tried: z2.array(z2.object({
+        did: z2.string().describe("the command or step"),
+        error: z2.string().optional().describe("the exact error line, if there was one"),
+        result: z2.string().describe("what it showed, one line")
+      })).max(MAX_ASK_TRIES).optional().describe("what you already tried, the most telling first"),
+      options: z2.array(z2.object({
+        label: z2.string().describe("a short answer the person can pick"),
+        detail: z2.string().describe("one line on what happens if it is picked")
+      })).max(MAX_ASK_OPTIONS).optional().describe("2 to 4 answers you suggest, the one you would pick first"),
+      blocking: z2.boolean().describe("true when you cannot go on without the answer"),
+      assumption: z2.string().optional().describe("when blocking is false: what you continue with until the answer comes")
+    },
+    async (args) => {
+      if (waiting.waitingFor !== null) {
+        return { content: [{ type: "text", text: ALREADY_WAITING_TEXT }], isError: true };
+      }
+      const choice = checkAsk(asking.people, args);
+      if ("error" in choice) {
+        return { content: [{ type: "text", text: choice.error }], isError: true };
+      }
+      let reply2;
+      try {
+        reply2 = await asking.send(choice.body);
+      } catch (error) {
+        return { content: [{ type: "text", text: `Could not send the question: ${error instanceof Error ? error.message : String(error)}. Decide yourself and say so in your report.` }], isError: true };
+      }
+      if (choice.body.blocking) {
+        waiting.waitingFor = reply2.id;
+      }
+      return { content: [{ type: "text", text: askedText(reply2.name, choice.body) }] };
+    }
+  );
+}
 function specWorkTools(specWork, submitted) {
   if (!specWork) {
     return [];
@@ -1299,11 +1437,14 @@ function specWorkTools(specWork, submitted) {
 }
 function tamsenseServer(request, submitted) {
   const tools = [
-    screenshotTool(request.attach),
+    attachTool("screenshot", request.attach),
+    attachTool("replay", request.attach),
+    attachTool("video", request.attach),
     ...request.wantsVerdict ? [verdictTool((verdict) => {
       submitted.verdict = verdict;
     })] : [],
     ...specWorkTools(request.specWork, submitted),
+    ...request.asking ? [askPersonTool(request.asking, submitted)] : [],
     ...request.handoffs.length > 0 ? [handoffTool(request.handoffs, (handoff) => {
       submitted.handoff = handoff;
     })] : []
@@ -1395,7 +1536,7 @@ function claudeRunner(startQuery) {
       request.input.close();
       abortController.abort();
     }, { once: true });
-    const submitted = { verdict: null, handoff: null, questions: null, spec: null, helperStarted: false };
+    const submitted = { verdict: null, handoff: null, questions: null, spec: null, helperStarted: false, waitingFor: null };
     const limit = usageLimitWatch();
     const context = { startQuery, abortController, submitted, limit };
     try {
@@ -1405,7 +1546,7 @@ function claudeRunner(startQuery) {
       }
       const pausedUntil = limit.pausedUntil(result.outcome.completed);
       const outcome = pausedUntil ? { ...result.outcome, completed: false, report: USAGE_LIMIT_REPORT } : result.outcome;
-      return { ...outcome, verdict: submitted.verdict, handoff: submitted.handoff, questions: submitted.questions, spec: submitted.spec, sessionId: result.sessionId, pausedUntil };
+      return { ...outcome, verdict: submitted.verdict, handoff: submitted.handoff, questions: submitted.questions, spec: submitted.spec, sessionId: result.sessionId, pausedUntil, waitingFor: submitted.waitingFor };
     } finally {
       request.input.close();
     }
@@ -1429,9 +1570,9 @@ function parseConfig(value) {
   if (!isRecord2(value)) {
     return null;
   }
-  const { server, token, deviceId, deviceName, browserDeclined } = value;
+  const { server, token, deviceId, deviceName } = 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;
+  return isValid ? { server, token, deviceId, deviceName } : null;
 }
 function isMissingFile(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
@@ -1458,6 +1599,7 @@ async function removeConfig(path = configPath()) {
 // 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";
@@ -1466,6 +1608,9 @@ 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;
@@ -1495,6 +1640,340 @@ async function login(tools, request) {
   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 READ_METHODS = ["GET", "HEAD", "OPTIONS"];
+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 isLocalHost(hostname2) {
+  const host = hostname2.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  return host === "localhost" || host.endsWith(".localhost") || host === "::1" || host === "0.0.0.0" || /^127(?:\.\d{1,3}){3}$/.test(host);
+}
+function isExternalWrite(method, url) {
+  return !READ_METHODS.includes(method.toUpperCase()) && !isLocalHost(url.hostname);
+}
+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, blockedExternalWrites: 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, blockedExternalWrites } = this.meta;
+    return { title, purpose, replay: this.file, video, marks: marks.length, gaps, blockedTrackerRequests, blockedExternalWrites };
+  }
+};
+function countBlocked(route, counter) {
+  try {
+    const session = state().pages.get(route.request().frame().page());
+    if (session) {
+      session.meta[counter] += 1;
+      session.save();
+    }
+  } catch {
+  }
+}
+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) => !isLocalHost(url.hostname), async (route) => {
+    const request = route.request();
+    if (!isExternalWrite(request.method(), new URL(request.url()))) {
+      await route.continue().catch(() => {
+      });
+      return;
+    }
+    countBlocked(route, "blockedExternalWrites");
+    await route.abort("blockedbyclient").catch(() => {
+    });
+  });
+  await context.route((url) => isTrackerIngest(url, origins), async (route) => {
+    countBlocked(route, "blockedTrackerRequests");
+    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) {
@@ -1508,7 +1987,6 @@ function describeDevice(identity) {
 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",
@@ -1544,30 +2022,87 @@ function withNodeOnPath(env, nodeDir, separator = delimiter2) {
   }
   return { ...env, [key]: [...entries, nodeDir].join(separator) };
 }
-async function askYesNo(question) {
-  const prompt = createInterface2({ input: process.stdin, output: process.stdout });
+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 {
-    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();
+    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 sleep(ms, signal) {
-  await wait(ms, void 0, { signal }).catch(() => {
+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 { dirname as dirname3 } from "path";
-import process2 from "process";
+import { rm as rm4 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+import process4 from "process";
 
 // src/feedQueue.ts
 var MAX_BATCH = 200;
@@ -1631,43 +2166,269 @@ function keyedLock() {
   };
 }
 
+// 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 createInterface2 } 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 = createInterface2({ 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 readFile3, stat } from "fs/promises";
-import { basename, extname, isAbsolute } from "path";
+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"
 };
-var MAX_CAPTION_LENGTH = 300;
 async function readScreenshot(request) {
-  if (!isAbsolute(request.path)) {
+  if (!isAbsolute2(request.path)) {
     return "Give the absolute path of the image file.";
   }
-  const contentType = TYPES_BY_EXTENSION[extname(request.path).toLowerCase()];
+  const contentType = TYPES_BY_EXTENSION[extname2(request.path).toLowerCase()];
   if (!contentType) {
     return "Only PNG, JPEG and WebP images can be attached.";
   }
-  const info = await stat(request.path).catch(() => null);
+  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 readFile3(request.path)).toString("base64");
-  return { name: basename(request.path), caption: request.caption.trim().slice(0, MAX_CAPTION_LENGTH), contentType, data };
+  const data = (await readFile4(request.path)).toString("base64");
+  return { name: basename3(request.path), ...caption, contentType, data };
 }
 
 // src/workspace.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { rm as rm3 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join6 } from "path";
 
 // src/git.ts
 import { Buffer } from "buffer";
-import { spawn as spawn3 } from "child_process";
+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");
@@ -1681,7 +2442,7 @@ function githubAuthEnv(token) {
 function runGit(args, options) {
   const env = { ...process.env, ...options.env, ...options.token ? githubAuthEnv(options.token) : {} };
   return new Promise((resolve, reject) => {
-    const child = spawn3("git", args, { cwd: options.cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn4("git", args, { cwd: options.cwd, env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (chunk) => {
@@ -1709,7 +2470,7 @@ function githubRemoteUrl(fullName) {
   return `https://github.com/${fullName}.git`;
 }
 function tamsenseFolder(home, ...parts) {
-  return join3(home, ".tamsense", ...parts);
+  return join6(home, ".tamsense", ...parts);
 }
 function folderNames(repositories) {
   const shortName = (fullName) => fullName.split("/").pop() ?? fullName;
@@ -1720,7 +2481,7 @@ function folderNames(repositories) {
   return repositories.map((repository) => counts.get(shortName(repository.fullName)) === 1 ? shortName(repository.fullName) : repository.fullName.replace("/", "__"));
 }
 async function refreshCache(cache, repository, token, tools) {
-  if (existsSync2(join3(cache, ".git"))) {
+  if (existsSync3(join6(cache, ".git"))) {
     await git(["fetch", "--prune", "origin"], { cwd: cache, token });
     return;
   }
@@ -1735,6 +2496,16 @@ async function baseRef(cache, job, repository) {
   const pushed = await runGit(["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${job.branch}`], { cwd: cache });
   return pushed.code === 0 ? `origin/${job.branch}` : `origin/${repository.defaultBranch}`;
 }
+async function keptBase(cache, path, job, repository) {
+  if (!job.keepWorkspace || !existsSync3(join6(path, ".git"))) {
+    return null;
+  }
+  const branch = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: path });
+  if (branch.code !== 0 || branch.stdout !== job.branch) {
+    return null;
+  }
+  return git(["rev-parse", await baseRef(cache, job, repository)], { cwd: cache });
+}
 async function prepareWorkspace(job, token, tools) {
   const root = tamsenseFolder(tools.home, "work", `task-${job.taskId}`);
   const folders = folderNames(job.repositories);
@@ -1742,9 +2513,13 @@ async function prepareWorkspace(job, token, tools) {
   for (const [index, repository] of job.repositories.entries()) {
     const cache = tamsenseFolder(tools.home, "repos", repository.fullName.replace("/", "__"));
     const folder = folders[index] ?? repository.fullName;
-    const path = join3(root, folder);
+    const path = join6(root, folder);
     const baseSha = await cacheLock.run(repository.fullName, async () => {
       await refreshCache(cache, repository, token, tools);
+      const kept = await keptBase(cache, path, job, repository);
+      if (kept) {
+        return kept;
+      }
       await removeWorktree(cache, path);
       await git(["worktree", "add", "--force", "-B", job.branch, path, await baseRef(cache, job, repository)], { cwd: cache });
       return git(["rev-parse", "HEAD"], { cwd: path });
@@ -1921,6 +2696,13 @@ function specWorkTools2(job, api) {
   }
   return { stage: kind, review: (body) => api.request("POST", runPath(job.runId, "review"), body) };
 }
+function askingTools(job, api) {
+  const people = job.people ?? [];
+  if (people.length === 0 || job.stage.kind === "interview" || job.stage.kind === "spec") {
+    return null;
+  }
+  return { people, send: (body) => api.request("POST", runPath(job.runId, "questions"), 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");
@@ -1930,25 +2712,30 @@ async function executeJob(job, tools, signal, input, record) {
   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) }),
+    prompt: buildTaskPrompt(job, workspace, { browser: Boolean(tools.browser), recorder: Boolean(tools.recorder) }),
     input,
-    env: { ...withNodeOnPath(process2.env, dirname3(process2.execPath)), ...tools.browser ? browserEnv(tools.browser) : {}, ...identity },
+    env: { ...baseEnv, ...tools.browser ? browserEnv(tools.browser) : {}, ...recording, ...identity },
     signal,
     wantsVerdict: isCheck,
     specWork: specWorkTools2(job, tools.api),
+    asking: askingTools(job, tools.api),
     handoffs: job.allowedHandoffs,
     resumeSessionId: job.resumeSessionId,
     model: job.model,
     effort: job.effort,
     onFeed: record,
     onSession: session.report,
-    attach: (screenshot) => attachScreenshot(tools.api, job, screenshot, attached)
+    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 waitingFor = outcome.waitingFor ?? null;
+  const shouldPublish = job.stage.kind === "code" && outcome.completed && waitingFor === null;
   const pushed = shouldPublish ? await publishWorkspace(workspace, job, await gitToken(tools.api, job), identity) : [];
   return {
     outcome: outcome.completed ? "succeeded" : "failed",
@@ -1961,27 +2748,51 @@ async function executeJob(job, tools, signal, input, record) {
     sessionId: outcome.sessionId ?? null,
     pausedUntil: outcome.pausedUntil ?? null,
     questions: outcome.questions ?? null,
-    spec: outcome.spec ?? null
+    spec: outcome.spec ?? null,
+    waitingFor
   };
 }
 function clockOf(iso) {
   const time = new Date(iso);
   return `${String(time.getHours()).padStart(2, "0")}:${String(time.getMinutes()).padStart(2, "0")}`;
 }
-function resultLine(finish) {
-  if (finish.pausedUntil) {
-    return `Paused: ${USAGE_LIMIT_REPORT}, resumes at ${clockOf(finish.pausedUntil)}`;
+function resultLine(finish2) {
+  if (finish2.pausedUntil) {
+    return `Paused: ${USAGE_LIMIT_REPORT}, resumes at ${clockOf(finish2.pausedUntil)}`;
   }
-  if (finish.verdict) {
-    return finish.verdict.passed ? "Check passed." : `Check did not pass: ${finish.verdict.report}`;
+  if (finish2.waitingFor !== null) {
+    return "Waiting for an answer on TAMsense. This computer is free for other tasks; the run continues here after the answer.";
   }
-  if (finish.questions) {
-    return finish.questions.questions.length > 0 ? `Done. ${finish.questions.questions.length} question(s) wait for the owner on TAMsense.` : "Done. No questions needed, the spec is written next.";
+  if (finish2.verdict?.couldNotRun) {
+    return `Check could not run: ${finish2.verdict.report}`;
   }
-  if (finish.spec) {
+  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 finish.outcome === "succeeded" ? `Done. Pushed ${finish.pushed.length} branch(es), the pull requests open on TAMsense.` : `Failed: ${finish.report}`;
+  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)}`;
@@ -2002,11 +2813,11 @@ async function runJob(job, tools, stop) {
   run2.signal.addEventListener("abort", input.close, { once: true });
   void messages.poll();
   const polling = setInterval(() => void messages.poll(), INBOX_INTERVAL_MS);
-  let finish;
+  let finish2;
   try {
-    finish = await executeJob(job, tools, run2.signal, input, record);
+    finish2 = await executeJob(job, tools, run2.signal, input, record);
   } catch (error) {
-    finish = { outcome: "failed", report: failureReport(error, run2.signal), pushed: [], model: null, usage: null, verdict: null, handoff: null, sessionId: null, pausedUntil: null, questions: null, spec: null };
+    finish2 = { outcome: "failed", report: failureReport(error, run2.signal), pushed: [], model: null, usage: null, verdict: null, handoff: null, sessionId: null, pausedUntil: null, questions: null, spec: null, waitingFor: null };
   } finally {
     clearInterval(polling);
     clearInterval(feeding);
@@ -2019,12 +2830,14 @@ async function runJob(job, tools, stop) {
   }
   await feed.flush();
   if (run2.signal.reason === CLOSED_ON_SITE) {
+    await rm4(recordingsFolder(tools.home, job.runId), { recursive: true, force: true });
     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"), finish);
-    tools.print(resultLine(finish));
+    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)}`);
   }
@@ -2103,11 +2916,11 @@ var NO_TASKS_ACCESS_TEXT = "Your account no longer has access to Tasks. Ask the
 var ACCESS_PROBLEMS = { 401: DISCONNECTED_TEXT, 403: NO_TASKS_ACCESS_TEXT };
 var INTERRUPTED_EXIT_CODE = 130;
 function print(line) {
-  process3.stdout.write(`${line}
+  process5.stdout.write(`${line}
 `);
 }
 function serverFor(flag, saved) {
-  return serverOrigin(flag ?? process3.env.TAMSENSE_URL ?? saved?.server ?? DEFAULT_SERVER);
+  return serverOrigin(flag ?? process5.env.TAMSENSE_URL ?? saved?.server ?? DEFAULT_SERVER);
 }
 function accessProblem(error) {
   return error instanceof ApiError ? ACCESS_PROBLEMS[error.status] ?? null : null;
@@ -2128,33 +2941,46 @@ async function runLogin(server, deviceName) {
     { 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 });
+  await writeConfig({ server: api.server, token: result.token, deviceId: result.device.id, deviceName: result.device.name });
   print(`Connected: ${result.device.name}. To take your tasks, run ${START_COMMAND}`);
 }
 function stopOnInterrupt() {
   const stop = new AbortController();
-  process3.once("SIGINT", () => {
+  process5.once("SIGINT", () => {
     print("Stopping\u2026 Press Ctrl+C again to quit at once.");
     stop.abort();
-    process3.once("SIGINT", () => process3.exit(INTERRUPTED_EXIT_CODE));
+    process5.once("SIGINT", () => process5.exit(INTERRUPTED_EXIT_CODE));
   });
   return stop.signal;
 }
 function installTools(home) {
-  return { home, nodePath: process3.execPath, env: process3.env, print, run: runProcess, exists: existsSync3 };
-}
-async function browserForStart(home, saved) {
-  return await installedBrowser(home) ?? await offerBrowser({
-    interactive: Boolean(process3.stdin.isTTY && process3.stdout.isTTY),
-    declined: saved.browserDeclined === true,
-    print,
-    ask: askYesNo,
-    install: () => installBrowser(installTools(home)),
-    rememberDecline: async () => writeConfig({ ...saved, browserDeclined: true })
-  });
+  return { home, nodePath: process5.execPath, env: process5.env, print, run: runProcess, exists: existsSync4 };
+}
+async function browserForStart(home, install) {
+  const installed = await installedBrowser(home);
+  if (installed || !install) {
+    return installed;
+  }
+  return ensureBrowser({ print, install: () => installBrowser(installTools(home)) });
 }
-async function runStart(parallel) {
+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, installsBrowser) {
+  if (await startedNewVersion()) {
+    return;
+  }
   const saved = await readConfig();
   if (!saved) {
     print(NOT_CONNECTED_TEXT);
@@ -2162,23 +2988,19 @@ async function runStart(parallel) {
   }
   const api = createApi(saved.server, saved.token);
   const identity = await api.request("GET", IDENTITY_PATH);
-  const problem = teamKeyProblem(identity.device.team, process3.env);
+  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 }, stopOnInterrupt(), parallel);
+  const browser = await browserForStart(home, installsBrowser);
+  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 });
-    }
+    print(await removeBrowser(home) ? "Removed the headless browser. The next start installs it again, unless you add --no-browser." : "No headless browser is installed.");
     return;
   }
   const installed = await installedBrowser(home);
@@ -2213,7 +3035,7 @@ async function run(command) {
   if (command.name === "login") {
     await runLogin(command.server, command.deviceName);
   } else if (command.name === "start") {
-    await runStart(command.parallel);
+    await runStart(command.parallel, command.browser);
   } else if (command.name === "browser") {
     await runBrowser(command.remove);
   } else if (command.name === "status") {
@@ -2225,10 +3047,10 @@ async function run(command) {
   }
 }
 try {
-  await run(parseCommand(process3.argv.slice(2), process3.env));
+  await run(parseCommand(process5.argv.slice(2), process5.env));
 } catch (error) {
-  process3.stderr.write(`${accessProblem(error) ?? (error instanceof Error ? error.message : String(error))}
+  process5.stderr.write(`${accessProblem(error) ?? (error instanceof Error ? error.message : String(error))}
 `);
-  process3.exitCode = 1;
+  process5.exitCode = 1;
 }
 //# sourceMappingURL=cli.js.map