@tamsensedev/runner 0.1.0 → 0.2.1

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.
@@ -84,8 +83,8 @@ Usage:
   ${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 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)
@@ -407,6 +406,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;
@@ -437,8 +437,8 @@ function toolDraft(block, parent) {
   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,6 +813,8 @@ 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";
@@ -832,7 +834,9 @@ 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 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",
@@ -976,7 +980,8 @@ 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 rules = isCheck ? [...CHECK_RULES, ...evidence] : [...CODE_RULES, ...job.review ? [REWORK_RULE] : [], ...evidence, CODE_REPORT_RULE];
   const instructions = [
     UNATTENDED_RULE,
     MACHINE_RULE,
@@ -1243,15 +1248,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) {
@@ -1299,7 +1323,9 @@ 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;
     })] : [],
@@ -1458,6 +1484,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 +1493,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 +1525,318 @@ 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 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) {
@@ -1565,9 +1907,82 @@ async function sleep(ms, signal) {
   });
 }
 
+// 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 { 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 +2046,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 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 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 +2322,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 +2350,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 +2361,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;
   }
@@ -1742,7 +2383,7 @@ 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);
       await removeWorktree(cache, path);
@@ -1930,11 +2571,14 @@ 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),
@@ -1944,7 +2588,7 @@ async function executeJob(job, tools, signal, input, record) {
     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();
@@ -1968,20 +2612,37 @@ 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.verdict) {
+    return finish2.verdict.passed ? "Check passed." : `Check did not pass: ${finish2.verdict.report}`;
   }
-  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.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 (finish.spec) {
+  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 +2663,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 };
   } finally {
     clearInterval(polling);
     clearInterval(feeding);
@@ -2019,12 +2680,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 +2766,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;
@@ -2134,19 +2797,19 @@ async function runLogin(server, deviceName) {
 }
 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 };
+  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(process3.stdin.isTTY && process3.stdout.isTTY),
+    interactive: Boolean(process5.stdin.isTTY && process5.stdout.isTTY),
     declined: saved.browserDeclined === true,
     print,
     ask: askYesNo,
@@ -2154,7 +2817,24 @@ async function browserForStart(home, saved) {
     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);
@@ -2162,14 +2842,14 @@ 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);
+  await work({ api, runAgent: runClaude, capabilities: probeCapabilities, print, sleep, home, remoteUrl: githubRemoteUrl, browser, recorder: bundledRecorder() }, stopOnInterrupt(), parallel);
 }
 async function runBrowser(remove) {
   const home = homedir3();
@@ -2225,10 +2905,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