@dunnewold-labs/mr-manager 0.4.14 → 0.4.16

package/dist/index.mjs

@@ -185,7 +185,7 @@ import { fileURLToPath } from "url";
 // cli/package.json
 var package_default = {
   name: "@dunnewold-labs/mr-manager",
-  version: "0.4.14",
+  version: "0.4.16",
   description: "Mr. Manager - Task and project management CLI",
   bin: {
     mr: "./dist/index.mjs"
@@ -250,6 +250,45 @@ var ApiError = class extends Error {
     this.name = "ApiError";
   }
 };
+var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNABORTED",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETDOWN",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ETIMEDOUT"
+]);
+var NETWORK_ERROR_PATTERNS = [
+  "fetch failed",
+  "network",
+  "offline",
+  "socket hang up",
+  "timed out",
+  "timeout",
+  "connection refused",
+  "connection reset",
+  "host is down",
+  "host unreachable",
+  "internet disconnected"
+];
+function isLikelyNetworkError(err) {
+  if (!err || typeof err !== "object") return false;
+  if (err instanceof ApiError) return false;
+  const error = err;
+  const directCode = typeof error.code === "string" ? error.code.toUpperCase() : null;
+  const causeCode = typeof error.cause?.code === "string" ? error.cause.code.toUpperCase() : null;
+  if (directCode && NETWORK_ERROR_CODES.has(directCode) || causeCode && NETWORK_ERROR_CODES.has(causeCode)) {
+    return true;
+  }
+  const combinedMessage = [
+    typeof error.message === "string" ? error.message : "",
+    typeof error.cause?.message === "string" ? error.cause.message : ""
+  ].join(" ").toLowerCase();
+  return NETWORK_ERROR_PATTERNS.some((pattern) => combinedMessage.includes(pattern));
+}
 async function request(method, path, body) {
   const config = loadConfig();
   if (!config.apiKey) {
@@ -492,7 +531,7 @@ import { Command as Command8 } from "commander";
 import { spawn as spawn4, exec } from "child_process";
 import { randomUUID } from "crypto";
 import { resolve as resolve2 } from "path";
-import { readFileSync as readFileSync5, readdirSync, unlinkSync, existsSync as existsSync7, statSync, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync5, readdirSync, unlinkSync, existsSync as existsSync7, statSync, writeFileSync as writeFileSync3 } from "fs";
 import * as readline from "readline";
 
 // lib/test-runner.ts
@@ -557,10 +596,13 @@ function findExistingWorktreeForBranch(repoDir, branch) {
     return null;
   }
 }
-function createWorktree(repoDir, branch, worktreeName) {
+function createWorktree(repoDir, branch, worktreeName, options = {}) {
   const wtPath = join4(repoDir, ".mr-worktrees", worktreeName);
   if (existsSync4(wtPath)) {
-    execSync2(`git checkout ${branch}`, { cwd: wtPath, stdio: "pipe" });
+    execSync2(`git checkout "${branch}"`, { cwd: wtPath, stdio: "pipe" });
+    if (options.syncRemoteBranch) {
+      syncBranchWithRemote(repoDir, wtPath, branch);
+    }
     return {
       path: wtPath,
       created: false,
@@ -569,6 +611,9 @@ function createWorktree(repoDir, branch, worktreeName) {
   }
   const existingBranchWorktree = findExistingWorktreeForBranch(repoDir, branch);
   if (existingBranchWorktree) {
+    if (options.syncRemoteBranch) {
+      syncBranchWithRemote(repoDir, existingBranchWorktree, branch);
+    }
     return {
       path: existingBranchWorktree,
       created: false,
@@ -613,6 +658,18 @@ function createWorktree(repoDir, branch, worktreeName) {
     reusedBranchWorktree: false
   };
 }
+function syncBranchWithRemote(repoDir, wtPath, branch) {
+  tryExec(`git fetch origin "${branch}"`, repoDir);
+  const hasRemoteBranch = tryExec(`git rev-parse --verify "origin/${branch}"`, repoDir);
+  if (!hasRemoteBranch) return;
+  try {
+    execSync2(`git pull --ff-only origin "${branch}"`, {
+      cwd: wtPath,
+      stdio: "pipe"
+    });
+  } catch {
+  }
+}
 function removeWorktree(repoDir, wtPath) {
   try {
     execSync2(`git worktree remove --force "${wtPath}"`, {
@@ -819,7 +876,9 @@ async function runTest(options) {
     uploadScreenshot: uploadScreenshot2,
     uploadVideo,
     postUpdate,
-    onProgress
+    onProgress,
+    recordingEnabled = true,
+    recordingContext = "test-run"
   } = options;
   const log2 = onProgress || (() => {
   });
@@ -828,7 +887,11 @@ async function runTest(options) {
     assertions: [],
     screenshots: [],
     errors: [],
-    summary: ""
+    summary: "",
+    proof: {
+      state: recordingEnabled ? "proof_missing_capture_failed" : "proof_missing_disabled",
+      details: recordingEnabled ? "Proof recording did not complete." : "Proof recording disabled for this run."
+    }
   };
   let devProc = null;
   let wtPath = null;
@@ -858,6 +921,29 @@ async function runTest(options) {
     devProc = await startDevServer(wtPath, port);
     const baseUrl = `http://127.0.0.1:${port}`;
     log2(`Dev server running on ${baseUrl}`);
+    let recordingStarted = false;
+    if (recordingEnabled) {
+      try {
+        const recordingStart = await browseRunner(["recording-start"]);
+        if (recordingStart.exitCode !== 0) {
+          throw new Error(recordingStart.stdout || "recording-start failed");
+        }
+        recordingStarted = true;
+        log2("Proof recording started");
+      } catch (err) {
+        result.proof = {
+          state: "proof_missing_capture_failed",
+          details: `Proof recording could not start: ${err.message}`
+        };
+        log2(result.proof.details);
+      }
+    } else {
+      result.proof = {
+        state: "proof_missing_disabled",
+        details: "Proof recording disabled for this run."
+      };
+      log2(result.proof.details);
+    }
     await browseRunner(["goto", baseUrl]);
     const plan = customPlan || buildDefaultTestPlan(baseUrl);
     log2(`Executing ${plan.length}-step test plan...`);
@@ -917,6 +1003,62 @@ async function runTest(options) {
         log2(`Step ${i + 1} error: ${err.message}`);
       }
     }
+    if (recordingStarted) {
+      const recordingPath = `/tmp/mr-proof-${taskId.slice(0, 8)}-${Date.now()}.webm`;
+      try {
+        const recordingStop = await browseRunner(["recording-stop", recordingPath]);
+        const savedPath = recordingStop.stdout.match(/Recording saved: (.+)/)?.[1]?.trim();
+        if (!savedPath) {
+          throw new Error(recordingStop.stdout || "recording-stop did not return a file path");
+        }
+        result.proof.localPath = savedPath;
+        log2(`Proof recording finalized at ${savedPath}`);
+        if (uploadVideo) {
+          const videoUrl = await uploadVideo(savedPath);
+          if (videoUrl) {
+            result.videoUrl = videoUrl;
+            result.proof = {
+              state: "proof_attached",
+              details: result.status === "passed" ? "Proof recording attached." : "Proof recording attached for the failed run.",
+              localPath: savedPath,
+              videoUrl,
+              media: [
+                {
+                  kind: "recording",
+                  url: videoUrl,
+                  mimeType: "video/webm",
+                  label: "Proof recording",
+                  captureContext: recordingContext,
+                  uploadState: "uploaded",
+                  isCanonical: true
+                }
+              ]
+            };
+            log2(`Proof recording uploaded to ${videoUrl}`);
+          } else {
+            result.proof = {
+              state: "proof_missing_upload_failed",
+              details: "Proof recording captured, but upload failed.",
+              localPath: savedPath
+            };
+            log2(result.proof.details);
+          }
+        } else {
+          result.proof = {
+            state: "proof_missing_upload_failed",
+            details: "Proof recording captured, but no upload handler was configured.",
+            localPath: savedPath
+          };
+          log2(result.proof.details);
+        }
+      } catch (err) {
+        result.proof = {
+          state: "proof_missing_capture_failed",
+          details: `Proof recording could not be finalized: ${err.message}`
+        };
+        log2(result.proof.details);
+      }
+    }
     const totalAssertions = result.assertions.length;
     const passedAssertions = result.assertions.filter((a) => a.passed).length;
     const failedSteps = result.assertions.filter((a) => !a.passed).map((a) => `step ${a.step + 1}`);
@@ -928,13 +1070,25 @@ async function runTest(options) {
     if (result.errors.length > 0) {
       result.summary += ` (${result.errors.length} errors)`;
     }
-    await postUpdate(result.summary);
+    if (result.proof.state === "proof_attached") {
+      result.summary += result.status === "passed" ? " Proof recording attached." : " Proof recording attached for review.";
+    } else {
+      result.summary = result.status === "passed" ? result.summary.replace(/^Test passed/, "Test passed with warning") : result.summary.replace(/^Test failed/, "Test failed with warning");
+      result.summary += ` ${result.proof.details}`;
+    }
+    await postUpdate({
+      message: result.summary,
+      imageUrl: result.videoUrl,
+      media: result.proof.media,
+      proofState: result.proof.state,
+      proofDetails: result.proof.details
+    });
   } catch (err) {
     result.status = "failed";
     result.summary = `Test failed: ${err.message}`;
     result.errors.push(err.message);
     try {
-      await postUpdate(`Test failed: ${err.message}`);
+      await postUpdate({ message: `Test failed: ${err.message}` });
     } catch {
     }
   } finally {
@@ -1009,7 +1163,7 @@ function taskLikelyDoesNotNeedCodeChanges(task) {
 }
 
 // cli/browse-runner.ts
-import { execSync as execSync4, spawn as spawn3 } from "child_process";
+import { execSync as execSync3, spawn as spawn3 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
 import { join as join6 } from "path";
 var BROWSE_DIR = join6(import.meta.dirname, "..", "..", "browse");
@@ -1020,7 +1174,7 @@ function getBrowseRunner() {
     return { cmd: BROWSE_BINARY, args: [] };
   }
   try {
-    execSync4("which bun", { stdio: "pipe" });
+    execSync3("which bun", { stdio: "pipe" });
     if (existsSync6(BROWSE_DEV_CMD)) {
       return { cmd: "bun", args: ["run", BROWSE_DEV_CMD] };
     }
@@ -1247,9 +1401,19 @@ function logDispatch(prefix, msg) {
 function logSpinner(prefix, msg) {
   console.log(`${timestamp()} ${prefix} ${paint("blue", "\u27F3")} ${msg}`);
 }
-async function postTaskUpdate(taskId, message, source = "system") {
+function isLikelyNetworkFailureDetail(detail) {
+  return isLikelyNetworkError(new Error(detail));
+}
+async function postTaskUpdate(taskId, payloadOrMessage, source = "system") {
   try {
-    await api.post(`/api/tasks/${taskId}/updates`, { message, source });
+    if (typeof payloadOrMessage === "string") {
+      await api.post(`/api/tasks/${taskId}/updates`, { message: payloadOrMessage, source });
+      return;
+    }
+    await api.post(`/api/tasks/${taskId}/updates`, {
+      ...payloadOrMessage,
+      source: payloadOrMessage.source || source
+    });
   } catch (err) {
     logError(taskTag(shortId(taskId)), `Failed to post update: ${err.message}`);
   }
@@ -1285,6 +1449,12 @@ function ownerPrefix(task) {
   const first = name.split(/\s+/)[0].toLowerCase().replace(/[^a-z0-9]/g, "");
   return first || "mr";
 }
+function taskBranchName(task) {
+  if (task.attachedBranch?.trim()) {
+    return task.attachedBranch.trim();
+  }
+  return `${ownerPrefix(task)}/${slugify(task.title)}`;
+}
 function formatElapsed(ms) {
   const totalMinutes = Math.max(1, Math.floor(ms / 6e4));
   const hours = Math.floor(totalMinutes / 60);
@@ -1468,7 +1638,7 @@ async function createPrInRepo(task, branchName, repoDir, vcs, subtasks, protoRef
   }
   const bodyPath = resolve2("/tmp", `mr-auto-pr-${randomUUID()}.md`);
   const body = buildAutomaticPrBody(task, branchName, vcs, subtasks, protoRefs, feedbackUpdates, existingResources, skillRefs);
-  writeFileSync4(bodyPath, `${body}
+  writeFileSync3(bodyPath, `${body}
 `, "utf-8");
   const createCommand2 = vcs === "gitlab" ? `glab mr create --source-branch ${JSON.stringify(branchName)} --title ${JSON.stringify(task.title)} --description-file ${JSON.stringify(bodyPath)} --yes` : `gh pr create --head ${JSON.stringify(branchName)} --title ${JSON.stringify(task.title)} --body-file ${JSON.stringify(bodyPath)}`;
   try {
@@ -1615,7 +1785,7 @@ function buildPrototypeSection(protoRefs, workingDir) {
       const safeProtoId = proto.id.slice(0, 8);
       const tmpPath = resolve2(tmpDir, `.mr-proto-${safeProtoId}-v${selected[i] ?? i}.html`);
       try {
-        writeFileSync4(tmpPath, file.content, "utf-8");
+        writeFileSync3(tmpPath, file.content, "utf-8");
         sections.push(`#### ${variantLabel}: ${file.name}`);
         sections.push(`File: \`${tmpPath}\` \u2014 read this file to see the full HTML content.`);
       } catch {
@@ -1721,13 +1891,15 @@ function buildFeaturesSection(repoDir) {
     ``
   ].join("\n");
 }
-function buildExecutionPrompt(task, repoDir, subtasks, vcs = "github", protoRefs = [], feedbackUpdates = [], existingResources = [], skillRefs = [], executionDir, startWithoutWorktree = false) {
+function buildExecutionPrompt(task, repoDir, subtasks, vcs = "github", protoRefs = [], feedbackUpdates = [], existingResources = [], skillRefs = [], executionDir, startWithoutWorktree = false, preparedBranchName) {
   const slug = slugify(task.title);
   const owner = ownerPrefix(task);
-  const branchName = `${owner}/${slug}`;
+  const generatedBranchName = `${owner}/${slug}`;
+  const branchName = taskBranchName(task);
   const wtPath = worktreePath(`${owner}-${slug}`);
   const workingDir = executionDir ?? repoDir;
   const prBodyPath = "/tmp/mr-pr-body.md";
+  const hasAttachedBranch = !!task.attachedBranch?.trim();
   const notes = task.prdContent ? `
 
 ## PRD (Product Requirements Document)
@@ -1766,10 +1938,11 @@ ${task.notes}` : "";
     ``,
     `1. **Gather project context first.** Run \`mr context\` to get the project description, current task list, and the last 10 completed tasks. Use this to understand what's already been built, recent decisions, and the overall project direction before you start coding.`,
     ``,
-    ...executionDir && executionDir !== repoDir ? [
-      `2. Your isolated git worktree is already prepared and this session starts inside it.`,
+    ...preparedBranchName ? [
+      `2. Your git working tree is already prepared and this session starts inside it.`,
       `   - Current working directory: ${executionDir}`,
-      `   - Branch checked out in this worktree: ${branchName}`,
+      `   - Branch checked out for this task: ${preparedBranchName}`,
+      ...hasAttachedBranch ? [`   - This task is attached to an existing branch, so agent work should stay on that branch instead of creating ${generatedBranchName}.`] : [],
       `   - If the task spans additional repos, create matching worktrees there as needed.`
     ] : hasFeedback ? [
       `2. Set up your working environment:`,
@@ -1844,7 +2017,7 @@ ${task.notes}` : "";
   if (isRevision) {
     const prdTmpPath = resolve2(repoDir, ".mr-existing-prd.md");
     try {
-      writeFileSync4(prdTmpPath, existingPrd, "utf-8");
+      writeFileSync3(prdTmpPath, existingPrd, "utf-8");
     } catch {
     }
     const prdSummaryLines = [];
@@ -2066,7 +2239,7 @@ function buildRefinementPrompt(proto, parentFiles, repoDir) {
     const f = parentFiles[i];
     const tmpPath = resolve2(repoDir, `.mr-parent-variant-${i + 1}.html`);
     try {
-      writeFileSync4(tmpPath, f.content, "utf-8");
+      writeFileSync3(tmpPath, f.content, "utf-8");
       existingVariantLines.push(`### Previous Variant ${i + 1} (${f.name})`);
       existingVariantLines.push(`File: \`${tmpPath}\` \u2014 read this file to see the full HTML content.`);
     } catch {
@@ -2329,6 +2502,8 @@ var watchCommand = new Command8("watch").description(
   const failed = /* @__PURE__ */ new Map();
   const queued = /* @__PURE__ */ new Set();
   const finishing = /* @__PURE__ */ new Set();
+  const networkPaused = /* @__PURE__ */ new Map();
+  let networkOffline = false;
   let pollRunning = false;
   const approvalQueue = [];
   let approvalRunning = false;
@@ -2382,11 +2557,85 @@ var watchCommand = new Command8("watch").description(
     } catch {
     }
   }
+  async function isApiReachable() {
+    try {
+      await api.get("/api/tasks?status=queued");
+      return true;
+    } catch (err) {
+      return !isLikelyNetworkError(err);
+    }
+  }
+  function pauseTaskForNetwork(taskId, reason) {
+    const activeEntry = active.get(taskId);
+    if (networkPaused.has(taskId)) return;
+    networkPaused.set(taskId, {
+      pausedAt: Date.now(),
+      reason,
+      resumeSession: activeEntry?.currentAgent === "claude"
+    });
+    failed.delete(taskId);
+    queued.delete(taskId);
+    finishing.delete(taskId);
+    if (activeEntry) {
+      activeEntry.terminatedForError = true;
+      activeEntry.process.kill("SIGTERM");
+      active.delete(taskId);
+    }
+  }
+  function handleNetworkLoss(reason) {
+    if (!networkOffline) {
+      networkOffline = true;
+      logWarn(watchTag(), `Network unavailable \u2014 pausing active tasks until connectivity returns (${reason})`);
+    }
+    for (const taskId of active.keys()) {
+      const nonTaskPrefixes = ["proto-", "repo-", "scan-", "idea-", "test-"];
+      if (nonTaskPrefixes.some((prefix) => taskId.startsWith(prefix))) continue;
+      pauseTaskForNetwork(taskId, reason);
+    }
+  }
+  async function resumeNetworkPausedTasks() {
+    if (networkPaused.size === 0) {
+      if (networkOffline) {
+        networkOffline = false;
+        logSuccess(watchTag(), "Network connection restored");
+      }
+      return true;
+    }
+    const pausedIds = [...networkPaused.keys()];
+    for (const taskId of pausedIds) {
+      try {
+        const task = await api.get(`/api/tasks/${taskId}`);
+        if (task.status === "delegated") {
+          await api.patch(`/api/tasks/${taskId}`, { status: "queued" });
+        }
+        await postTaskUpdate(taskId, "Network connection restored \u2014 resuming task", "system");
+        networkPaused.delete(taskId);
+      } catch (err) {
+        if (isLikelyNetworkError(err)) {
+          handleNetworkLoss(err.message);
+          return false;
+        }
+        logError(taskTag(shortId(taskId)), `Failed to resume paused task: ${err.message}`);
+        networkPaused.delete(taskId);
+      }
+    }
+    if (networkOffline) {
+      networkOffline = false;
+      logSuccess(watchTag(), "Network connection restored \u2014 paused tasks re-queued");
+    }
+    return true;
+  }
+  async function shouldPauseForNetwork(failureDetail) {
+    if (networkOffline || isLikelyNetworkFailureDetail(failureDetail)) {
+      return true;
+    }
+    return !await isApiReachable();
+  }
   async function dispatchTask(task, repoDir) {
     const sid = shortId(task.id);
     const slug = slugify(task.title);
     const owner = ownerPrefix(task);
-    const branchName = `${owner}/${slug}`;
+    const branchName = taskBranchName(task);
     const legacyBranchName = `mr/${sid}/${slug}`;
     const prefix = taskTag(sid);
     const vcs = detectVcs(repoDir)?.provider ?? "github";
@@ -2446,7 +2695,8 @@ var watchCommand = new Command8("watch").description(
       const worktree = createWorktree(
         repoDir,
         branchName,
-        worktreeNameFromPath(desiredWorktreePath)
+        worktreeNameFromPath(desiredWorktreePath),
+        { syncRemoteBranch: !!task.attachedBranch?.trim() }
       );
       executionDir = worktree.path;
       cleanupWorktreePath = worktree.created ? executionDir : void 0;
@@ -2455,7 +2705,7 @@ var watchCommand = new Command8("watch").description(
         worktree.reusedBranchWorktree ? `Reusing existing worktree ${paint("cyan", executionDir)} for branch ${paint("dim", branchName)}` : `Prepared worktree ${paint("cyan", executionDir)}`
       );
     }
-    const prompt2 = buildExecutionPrompt(task, repoDir, subtasks, vcs, protoRefs, feedbackUpdates, existingResources, skillRefs, executionDir, startWithoutWorktree);
+    const prompt2 = buildExecutionPrompt(task, repoDir, subtasks, vcs, protoRefs, feedbackUpdates, existingResources, skillRefs, executionDir, startWithoutWorktree, !startWithoutWorktree && isGitRepo(repoDir) ? branchName : void 0);
     const activeEntry = {
       process: void 0,
       title: task.title,
@@ -2481,7 +2731,8 @@ var watchCommand = new Command8("watch").description(
     let attemptIndex = 0;
     const launchAttempt = async (attemptAgent) => {
       let spawnFailureReason = null;
-      const shouldResumeClaudeSession = attemptAgent === "claude" && hasFeedback && !!task.claudeSessionId;
+      const pausedForNetwork = networkPaused.get(task.id);
+      const shouldResumeClaudeSession = attemptAgent === "claude" && !!task.claudeSessionId && (hasFeedback || pausedForNetwork?.resumeSession === true);
       const sessionId = attemptAgent === "claude" ? task.claudeSessionId ?? randomUUID() : void 0;
       const executionSystemPrompt = composeSystemPrompt(EXECUTION_SYSTEM_SECTIONS);
       const child = spawnAgent(
@@ -2501,6 +2752,7 @@ var watchCommand = new Command8("watch").description(
       activeEntry.process = child;
       activeEntry.currentAgent = attemptAgent;
       active.set(task.id, activeEntry);
+      networkPaused.delete(task.id);
       if (attemptAgent === "claude" && sessionId) {
         api.patch(`/api/tasks/${task.id}`, { claudeSessionId: sessionId }).catch(() => {
         });
@@ -2518,9 +2770,15 @@ var watchCommand = new Command8("watch").description(
         }
         const failedAttempt = code !== 0 || spawnFailureReason !== null;
         if (failedAttempt && !activeEntry.terminatedForError) {
+          const failureDetail = spawnFailureReason ?? `exit code ${code}`;
+          if (await shouldPauseForNetwork(failureDetail)) {
+            pauseTaskForNetwork(task.id, failureDetail);
+            handleNetworkLoss(failureDetail);
+            logWarn(prefix, `${attemptAgent} paused after network loss (${failureDetail})`);
+            return;
+          }
           const nextAgent = attemptOrder[attemptIndex + 1];
           if (nextAgent) {
-            const failureDetail = spawnFailureReason ?? `exit code ${code}`;
             logWarn(prefix, `${attemptAgent} failed (${failureDetail}) \u2014 retrying with ${nextAgent}`);
             await postTaskUpdate(
               task.id,
@@ -2571,7 +2829,7 @@ var watchCommand = new Command8("watch").description(
               let prUrl = null;
               if (!noMrRequested) {
                 prUrl = await findPrUrlAcrossRepos(branchName, repoDir, vcs);
-                if (!prUrl) {
+                if (!prUrl && !task.attachedBranch?.trim()) {
                   prUrl = await findPrUrlAcrossRepos(legacyBranchName, repoDir, vcs);
                 }
                 if (!prUrl) {
@@ -2592,7 +2850,7 @@ var watchCommand = new Command8("watch").description(
                     existingResources,
                     skillRefs
                   );
-                  if (!prUrl) {
+                  if (!prUrl && !task.attachedBranch?.trim()) {
                     prUrl = await createPrAcrossRepos(
                       task,
                       legacyBranchName,
@@ -2627,6 +2885,16 @@ var watchCommand = new Command8("watch").description(
                 await postTaskUpdate(task.id, `No ${prLabel} required: ${noMrDescription}`, "system");
               }
             } catch (err) {
+              if (isLikelyNetworkError(err)) {
+                networkPaused.set(task.id, {
+                  pausedAt: Date.now(),
+                  reason: err.message,
+                  resumeSession: false
+                });
+                handleNetworkLoss(err.message);
+                logWarn(prefix, `Task finalization paused after network loss (${err.message})`);
+                return;
+              }
               logError(prefix, `Failed to update task: ${err.message}`);
             }
           } else if (!activeEntry.terminatedForError) {
@@ -2636,7 +2904,7 @@ var watchCommand = new Command8("watch").description(
             await moveTaskToError(task, prefix, reason);
           }
         } finally {
-          if (activeEntry.cleanupRepoDir && activeEntry.cleanupWorktreePath) {
+          if (!networkPaused.has(task.id) && activeEntry.cleanupRepoDir && activeEntry.cleanupWorktreePath) {
             removeWorktree(activeEntry.cleanupRepoDir, activeEntry.cleanupWorktreePath);
           }
           queued.delete(task.id);
@@ -3260,18 +3528,29 @@ ${divider}`);
     if (pollRunning) return;
     pollRunning = true;
     try {
+      if (networkOffline) {
+        const reachable = await isApiReachable();
+        if (!reachable) return;
+        const resumed = await resumeNetworkPausedTasks();
+        if (!resumed) return;
+      }
       let queuedTasks;
       let delegatedTasks;
       try {
         queuedTasks = await api.get("/api/tasks?status=queued");
         delegatedTasks = await api.get("/api/tasks?status=delegated");
       } catch (err) {
+        if (isLikelyNetworkError(err)) {
+          handleNetworkLoss(err.message);
+          return;
+        }
         logError(watchTag(), `Failed to fetch tasks: ${err.message}`);
         return;
       }
       const nonTestQueued = queuedTasks.filter((t) => t.mode !== "testing");
       const nonTestDelegated = delegatedTasks.filter((t) => t.mode !== "testing");
       const staleDelegatedTasks = nonTestDelegated.filter((task) => {
+        if (networkPaused.has(task.id)) return false;
         if (!task.inProgressSince) return false;
         return Date.now() - new Date(task.inProgressSince).getTime() >= hungTaskTimeoutMs;
       });
@@ -3301,6 +3580,7 @@ ${divider}`);
         const sid = shortId(task.id);
         const prefix = taskTag(sid);
         const activeEntry = active.get(task.id);
+        if (networkPaused.has(task.id)) continue;
         const idleMs = activeEntry ? Date.now() - activeEntry.lastActivityAt : null;
         const delegatedAtMs = task.inProgressSince ? Date.now() - new Date(task.inProgressSince).getTime() : null;
         const exceededIdleTimeout = idleMs !== null && idleMs >= taskStallTimeoutMs;
@@ -3350,12 +3630,17 @@ ${divider}`);
         if (failed.has(task.id)) continue;
         const sid = shortId(task.id);
         const prefix = taskTag(sid);
-        const repoDir = findDirectoryForProject(config, task.projectId, rootDir);
+        let repoDir = findDirectoryForProject(config, task.projectId, rootDir);
         if (!repoDir) {
-          const reason = `no linked directory found under ${rootDir}`;
-          logError(prefix, `"${task.title}": ${reason} \u2014 will not retry`);
-          failed.set(task.id, reason);
-          continue;
+          if (taskLikelyDoesNotNeedCodeChanges(task)) {
+            repoDir = rootDir;
+            logInfo(prefix, `No linked directory \u2014 using root dir for no-code task`);
+          } else {
+            const reason = `no linked directory found under ${rootDir}`;
+            logError(prefix, `"${task.title}": ${reason} \u2014 will not retry`);
+            failed.set(task.id, reason);
+            continue;
+          }
         }
         if (!existsSync7(repoDir)) {
           const reason = `linked directory "${repoDir}" does not exist`;
@@ -3529,6 +3814,16 @@ ${divider}`);
                   await api.post(`/api/tasks/${task.id}/updates`, {
                     message,
                     imageUrl: uploadData.url,
+                    media: [
+                      {
+                        kind: "screenshot",
+                        url: uploadData.url,
+                        mimeType: "image/png",
+                        label: "Test screenshot",
+                        captureContext: "watch-completion",
+                        uploadState: "uploaded"
+                      }
+                    ],
                     source: "system"
                   });
                   return uploadData.url;
@@ -3536,10 +3831,34 @@ ${divider}`);
                   return null;
                 }
               },
-              postUpdate: async (message, imageUrl) => {
-                await postTaskUpdate(task.id, message);
+              uploadVideo: async (videoPath) => {
+                try {
+                  const { readFileSync: readFileSync13 } = await import("fs");
+                  const cfg = loadConfig();
+                  const videoBuffer = readFileSync13(videoPath);
+                  const fileName = videoPath.split("/").pop() || "proof-recording.webm";
+                  const isMp4 = fileName.endsWith(".mp4");
+                  const formData = new FormData();
+                  const blob = new Blob([videoBuffer], { type: isMp4 ? "video/mp4" : "video/webm" });
+                  formData.append("file", blob, fileName);
+                  formData.append("prefix", "test-recordings");
+                  const uploadRes = await fetch(`${cfg.apiUrl}/api/upload`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${cfg.apiKey}` },
+                    body: formData
+                  });
+                  if (!uploadRes.ok) return null;
+                  const uploadData = await uploadRes.json();
+                  return uploadData.url;
+                } catch {
+                  return null;
+                }
               },
-              onProgress: (msg) => logInfo(prefix, msg)
+              postUpdate: async (payload) => {
+                await postTaskUpdate(task.id, payload);
+              },
+              onProgress: (msg) => logInfo(prefix, msg),
+              recordingContext: "watch-completion"
             });
             await api.patch(`/api/tasks/${task.id}`, { status: "completed", testResult: result.status });
             logSuccess(prefix, result.summary);
@@ -4525,8 +4844,8 @@ var resumeCommand = new Command17("resume").description("Resume an interactive C
 
 // cli/commands/browse.ts
 import { Command as Command18 } from "commander";
-import { execSync as execSync5, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { execSync as execSync4, spawn as spawn6 } from "child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { join as join8 } from "path";
 var BROWSE_DIR2 = join8(import.meta.dirname, "..", "..", "browse");
 function isProcessAlive(pid) {
@@ -4573,7 +4892,7 @@ async function ensureDevServer() {
     env: { ...process.env }
   });
   devProc.unref();
-  writeFileSync5(
+  writeFileSync4(
     devStateFile,
     JSON.stringify({ pid: devProc.pid, port, startedAt: (/* @__PURE__ */ new Date()).toISOString() }),
     { mode: 384 }
@@ -4601,7 +4920,7 @@ var browseCommand = new Command18("browse").description("Control a headless brow
     if (command === "setup") {
       console.log("[browse] Running browse daemon setup...");
       try {
-        execSync5("./setup", { cwd: BROWSE_DIR2, stdio: "inherit" });
+        execSync4("./setup", { cwd: BROWSE_DIR2, stdio: "inherit" });
       } catch {
         console.error("[browse] Setup failed");
         process.exit(1);
@@ -4694,7 +5013,7 @@ var setPathCommand = new Command19("set-path").description("Set or update the lo
 // cli/commands/test.ts
 import { Command as Command20 } from "commander";
 import { readFileSync as readFileSync8, existsSync as existsSync11 } from "fs";
-var testCommand = new Command20("test").description("Run automated browser test for a task's MR/PR").argument("<task-id>", "Task ID to test").option("--plan <file>", "Path to a custom test plan JSON file").action(async (taskId, opts) => {
+var testCommand = new Command20("test").description("Run automated browser test for a task's MR/PR").argument("<task-id>", "Task ID to test").option("--plan <file>", "Path to a custom test plan JSON file").option("--no-recording", "Disable proof recording for this run").action(async (taskId, opts) => {
   const config = loadConfig();
   console.log("[test] Fetching task...");
   let task;
@@ -4742,7 +5061,7 @@ var testCommand = new Command20("test").description("Run automated browser test
     }
   }
   try {
-    await api.patch(`/api/tasks/${taskId}`, { testStatus: "running" });
+    await api.patch(`/api/tasks/${taskId}`, { status: "delegated", testResult: null });
   } catch {
   }
   console.log(`[test] Starting test for "${task.title}"...`);
@@ -4772,6 +5091,16 @@ var testCommand = new Command20("test").description("Run automated browser test
         await api.post(`/api/tasks/${taskId}/updates`, {
           message,
           imageUrl: uploadData.url,
+          media: [
+            {
+              kind: "screenshot",
+              url: uploadData.url,
+              mimeType: "image/png",
+              label: "Test screenshot",
+              captureContext: "test-run",
+              uploadState: "uploaded"
+            }
+          ],
           source: "system"
         });
         return uploadData.url;
@@ -4779,20 +5108,52 @@ var testCommand = new Command20("test").description("Run automated browser test
         return null;
       }
     },
-    postUpdate: async (message, imageUrl) => {
+    uploadVideo: async (videoPath) => {
+      try {
+        const videoBuffer = readFileSync8(videoPath);
+        const fileName = videoPath.split("/").pop() || "proof-recording.webm";
+        const isMp4 = fileName.endsWith(".mp4");
+        const formData = new FormData();
+        const blob = new Blob([videoBuffer], { type: isMp4 ? "video/mp4" : "video/webm" });
+        formData.append("file", blob, fileName);
+        formData.append("prefix", "test-recordings");
+        const uploadRes = await fetch(`${config.apiUrl}/api/upload`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${config.apiKey}` },
+          body: formData
+        });
+        if (!uploadRes.ok) return null;
+        const uploadData = await uploadRes.json();
+        return uploadData.url;
+      } catch {
+        return null;
+      }
+    },
+    postUpdate: async ({
+      message,
+      imageUrl,
+      media,
+      proofState,
+      proofDetails
+    }) => {
       try {
         await api.post(`/api/tasks/${taskId}/updates`, {
           message,
           imageUrl,
+          media,
+          proofState,
+          proofDetails,
           source: "system"
         });
       } catch {
       }
     },
-    onProgress: (msg) => console.log(`[test] ${msg}`)
+    onProgress: (msg) => console.log(`[test] ${msg}`),
+    recordingEnabled: opts.recording !== false,
+    recordingContext: "test-run"
   });
   try {
-    await api.patch(`/api/tasks/${taskId}`, { testStatus: result.status });
+    await api.patch(`/api/tasks/${taskId}`, { status: "completed", testResult: result.status });
   } catch {
   }
   console.log(`
@@ -4815,7 +5176,7 @@ var testCommand = new Command20("test").description("Run automated browser test
 
 // cli/commands/features.ts
 import { Command as Command21 } from "commander";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync12 } from "fs";
 import { resolve as resolve5, sep as sep2 } from "path";
 var FEATURES_FILE3 = ".mr-features.md";
 var c7 = {
@@ -4856,13 +5217,13 @@ var featuresCommand = new Command21("features").description("View or update the
   if (opts.file) {
     const content2 = readFileSync9(resolve5(opts.file), "utf-8");
     const featuresPath = getFeaturesPath();
-    writeFileSync6(featuresPath, content2);
+    writeFileSync5(featuresPath, content2);
     console.log(`${paint7("green", "\u2713")} Updated ${paint7("cyan", featuresPath)} from ${paint7("cyan", opts.file)}`);
     return;
   }
   if (opts.update) {
     const featuresPath = getFeaturesPath();
-    writeFileSync6(featuresPath, opts.update);
+    writeFileSync5(featuresPath, opts.update);
     console.log(`${paint7("green", "\u2713")} Updated ${paint7("cyan", featuresPath)}`);
     return;
   }
@@ -4877,12 +5238,12 @@ var featuresCommand = new Command21("features").description("View or update the
 
 // cli/commands/no-mr.ts
 import { Command as Command22 } from "commander";
-import { writeFileSync as writeFileSync7 } from "fs";
+import { writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve6 } from "path";
 var NO_MR_FILE = ".mr-no-mr";
 var noMrCommand = new Command22("no-mr").description("Signal that a task does not require a merge/pull request and describe what was done instead").argument("<task-id>", "Task ID").argument("<description>", "Description of what was done instead of creating an MR/PR").action(async (taskId, description) => {
   const filePath = resolve6(process.cwd(), NO_MR_FILE);
-  writeFileSync7(filePath, description, "utf-8");
+  writeFileSync6(filePath, description, "utf-8");
   await api.post(`/api/tasks/${taskId}/updates`, {
     message: `No MR/PR needed \u2014 ${description}`,
     source: "agent"
@@ -4964,7 +5325,7 @@ async function authenticateBrowseSession(magicUrl, runBrowse) {
 // lib/scanner/codebase-analysis.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync11, existsSync as existsSync14 } from "fs";
 import { join as join10, relative } from "path";
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 function resolveDir(projectPath, candidates) {
   for (const candidate of candidates) {
     const dir = join10(projectPath, candidate);
@@ -5090,7 +5451,7 @@ function extractInternalLinks(projectPath) {
 }
 function getRecentCommits(projectPath, count = 20) {
   try {
-    const output = execSync6(
+    const output = execSync5(
       `git log --oneline -${count} --no-decorate`,
       { cwd: projectPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunnewold-labs/mr-manager",
-  "version": "0.4.14",
+  "version": "0.4.16",
   "description": "Mr. Manager - Task and project management CLI",
   "bin": {
     "mr": "./dist/index.mjs"