@schoolai/shipyard 1.0.0 → 1.1.0

package/dist/index.js

@@ -6,27 +6,31 @@ import {
   BRANCH_NAME_PATTERN,
   CollabCreateRequestSchema,
   CollabCreateResponseSchema,
+  CollabRoomConnection,
   ErrorResponseSchema,
   HealthResponseSchema,
   PermissionModeSchema,
   PersonalRoomConnection,
   ROUTES,
   ValidationErrorResponseSchema
-} from "./chunk-FNYWUFGS.js";
+} from "./chunk-4IVLSSKL.js";
 import {
   createChildLogger,
   logger
-} from "./chunk-ERDY7OVK.js";
+} from "./chunk-FY3DRRGT.js";
 import {
   __export,
+  external_exports,
   getShipyardHome,
   validateEnv
 } from "./chunk-HS57GMAL.js";
 
 // src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
 import { mkdir as mkdir4 } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
 import { parseArgs } from "util";
 
 // ../../node_modules/.pnpm/@loro-extended+change@6.0.0-beta.0_loro-crdt@1.10.6/node_modules/@loro-extended/change/dist/index.js
@@ -11759,8 +11763,15 @@ function nanoid(size2 = 21) {
 }
 
 // ../../packages/loro-schema/dist/index.js
-var DEFAULT_EPOCH = 4;
-var DOCUMENT_PREFIXES = ["task-meta", "task-conv", "task-review", "room", "epoch"];
+var DEFAULT_EPOCH = 5;
+var DOCUMENT_PREFIXES = [
+  "task-meta",
+  "task-conv",
+  "task-review",
+  "room",
+  "epoch",
+  "user-prefs"
+];
 function buildDocumentId(prefix, key, epoch) {
   if (!prefix || !key) {
     throw new Error(`Document ID prefix and key must be non-empty: prefix="${prefix}", key="${key}"`);
@@ -11782,6 +11793,9 @@ function buildTaskConvDocId(taskId, epoch) {
 function buildTaskReviewDocId(taskId, epoch) {
   return buildDocumentId("task-review", taskId, epoch);
 }
+function buildRoomDocId(userId, epoch) {
+  return buildDocumentId("room", userId, epoch);
+}
 var DOCUMENT_PREFIX_SET = new Set(DOCUMENT_PREFIXES);
 function isDocumentPrefix(value) {
   return DOCUMENT_PREFIX_SET.has(value);
@@ -11802,7 +11816,6 @@ function parseDocumentId(id) {
     return null;
   return { prefix, key, epoch };
 }
-var LOCAL_USER_ID = "local-user";
 function generateTaskId() {
   return nanoid();
 }
@@ -11821,6 +11834,8 @@ function prefixMutability(prefix, role) {
       return false;
     case "epoch":
       return false;
+    case "user-prefs":
+      return false;
     default:
       return assertNever(prefix);
   }
@@ -11956,6 +11971,66 @@ var DiffFileShape = Shape.plain.struct({
   path: Shape.plain.string(),
   status: Shape.plain.string()
 });
+var PR_STATES = ["open", "closed", "merged", "draft"];
+var PR_REVIEW_STATES = [
+  "pending",
+  "approved",
+  "changes_requested",
+  "commented",
+  "dismissed"
+];
+var CI_CHECK_STATUSES = [
+  "success",
+  "failure",
+  "pending",
+  "neutral",
+  "skipped",
+  "cancelled"
+];
+var CICheckShape = Shape.plain.struct({
+  name: Shape.plain.string(),
+  status: Shape.plain.string(...CI_CHECK_STATUSES),
+  conclusion: Shape.plain.string().nullable(),
+  url: Shape.plain.string().nullable(),
+  startedAt: Shape.plain.number().nullable(),
+  completedAt: Shape.plain.number().nullable()
+});
+var PRReviewerShape = Shape.plain.struct({
+  login: Shape.plain.string(),
+  state: Shape.plain.string(...PR_REVIEW_STATES),
+  avatarUrl: Shape.plain.string().nullable(),
+  submittedAt: Shape.plain.number().nullable()
+});
+var PRCommentShape = Shape.plain.struct({
+  id: Shape.plain.string(),
+  author: Shape.plain.string(),
+  body: Shape.plain.string(),
+  createdAt: Shape.plain.number(),
+  updatedAt: Shape.plain.number().nullable(),
+  path: Shape.plain.string().nullable(),
+  line: Shape.plain.number().nullable(),
+  side: Shape.plain.string().nullable(),
+  isReviewComment: Shape.plain.boolean()
+});
+var PRDataShape = Shape.plain.struct({
+  number: Shape.plain.number(),
+  title: Shape.plain.string(),
+  state: Shape.plain.string(...PR_STATES),
+  author: Shape.plain.string(),
+  url: Shape.plain.string(),
+  baseRef: Shape.plain.string(),
+  headRef: Shape.plain.string(),
+  body: Shape.plain.string(),
+  isDraft: Shape.plain.boolean(),
+  additions: Shape.plain.number(),
+  deletions: Shape.plain.number(),
+  changedFiles: Shape.plain.number(),
+  createdAt: Shape.plain.number(),
+  updatedAt: Shape.plain.number(),
+  checks: Shape.plain.array(CICheckShape),
+  reviewers: Shape.plain.array(PRReviewerShape),
+  comments: Shape.plain.array(PRCommentShape)
+});
 var DiffStateShape = Shape.struct({
   unstaged: Shape.plain.string(),
   staged: Shape.plain.string(),
@@ -11967,7 +12042,13 @@ var DiffStateShape = Shape.struct({
   branchUpdatedAt: Shape.plain.number(),
   lastTurnDiff: Shape.plain.string(),
   lastTurnFiles: Shape.list(DiffFileShape),
-  lastTurnUpdatedAt: Shape.plain.number()
+  lastTurnUpdatedAt: Shape.plain.number(),
+  currentBranchPRNumber: Shape.plain.number(),
+  prData: Shape.plain.array(PRDataShape),
+  prDiff: Shape.plain.string(),
+  prFiles: Shape.list(DiffFileShape),
+  prUpdatedAt: Shape.plain.number(),
+  prAvailable: Shape.plain.boolean()
 });
 var SessionEntryShape = Shape.plain.struct({
   sessionId: Shape.plain.string(),
@@ -12004,7 +12085,7 @@ var PlanVersionShape = Shape.plain.struct({
   ...ATTRIBUTION_FIELDS
 });
 var DIFF_COMMENT_SIDES = ["old", "new"];
-var DIFF_COMMENT_SCOPES = ["working-tree", "last-turn"];
+var DIFF_COMMENT_SCOPES = ["working-tree", "last-turn", "pr"];
 var DiffCommentShape = Shape.plain.struct({
   commentId: Shape.plain.string(),
   filePath: Shape.plain.string(),
@@ -12072,6 +12153,16 @@ var TaskReviewDocumentSchema = Shape.doc({
   deliveredCommentIds: Shape.list(Shape.plain.string()),
   todoItems: Shape.list(TodoItemShape)
 }, { mergeable: true });
+var PinnedEntryShape = Shape.plain.struct({
+  pinnedAt: Shape.plain.number()
+});
+var AcknowledgedEntryShape = Shape.plain.struct({
+  at: Shape.plain.number()
+});
+var UserPreferencesDocumentSchema = Shape.doc({
+  pinnedTaskIds: Shape.record(PinnedEntryShape),
+  acknowledgedTasks: Shape.record(AcknowledgedEntryShape)
+}, { mergeable: true });
 var TERMINAL_TASK_STATES = ["completed", "failed", "canceled"];
 var TOOL_RISK_LEVELS = ["low", "medium", "high"];
 var PERMISSION_DECISIONS = ["approved", "denied"];
@@ -12117,6 +12208,7 @@ var TaskIndexEntryShape = Shape.struct({
   todoTotal: Shape.plain.number(),
   currentActivity: Shape.plain.string().nullable()
 });
+var KEEP_AWAKE_GRACE_PERIOD_MS = 15 * 60 * 1e3;
 var WORKTREE_SETUP_STATUSES = ["running", "done", "failed"];
 var WorktreeSetupStatusShape = Shape.plain.struct({
   status: Shape.plain.string(...WORKTREE_SETUP_STATUSES),
@@ -12212,6 +12304,18 @@ var AnthropicLoginResponseEphemeral = Shape.plain.struct({
   loginUrl: Shape.plain.string().nullable(),
   error: Shape.plain.string().nullable()
 });
+var TERMINAL_SESSION_STATUSES = ["running", "exited"];
+var TERMINAL_CONTROL_PREFIX = "\0
\0";
+var FILE_IO_CONTROL_PREFIX = "\0\0";
+var TerminalSessionEphemeral = Shape.plain.struct({
+  terminalId: Shape.plain.string(),
+  taskId: Shape.plain.string(),
+  machineId: Shape.plain.string(),
+  cwd: Shape.plain.string(),
+  status: Shape.plain.string(...TERMINAL_SESSION_STATUSES),
+  exitCode: Shape.plain.number().nullable(),
+  createdAt: Shape.plain.number()
+});
 var ROOM_EPHEMERAL_DECLARATIONS = {
   capabilities: MachineCapabilitiesEphemeral,
   enhancePromptReqs: EnhancePromptRequestEphemeral,
@@ -12220,7 +12324,8 @@ var ROOM_EPHEMERAL_DECLARATIONS = {
   worktreeCreateResps: WorktreeCreateResponseEphemeral,
   worktreeSetupResps: WorktreeSetupResultEphemeral,
   anthropicLoginReqs: AnthropicLoginRequestEphemeral,
-  anthropicLoginResps: AnthropicLoginResponseEphemeral
+  anthropicLoginResps: AnthropicLoginResponseEphemeral,
+  terminalSessions: TerminalSessionEphemeral
 };
 var TASK_CONV_EPHEMERAL_DECLARATIONS = {
   permReqs: PermissionRequestEphemeral,
@@ -12297,8 +12402,8 @@ var FileStorageAdapter = class extends StorageAdapter {
     return join(this.#dataDir, ...sanitized);
   }
   #pathToKey(filePath) {
-    const relative = filePath.slice(this.#dataDir.length + 1);
-    return relative.split(sep).map((part) => decodeURIComponent(part));
+    const relative2 = filePath.slice(this.#dataDir.length + 1);
+    return relative2.split(sep).map((part) => decodeURIComponent(part));
   }
   #isPrefix(prefix, key) {
     if (prefix.length > key.length) return false;
@@ -12358,24 +12463,11 @@ var LifecycleManager = class {
       { signal: "SIGINT", handler: intHandler }
     ];
     const exceptionHandler = (error2) => {
-      try {
-        logger.error({ error: error2 }, "Uncaught exception \u2014 initiating shutdown");
-      } catch {
-      }
+      logger.error({ err: error2 }, "Uncaught exception \u2014 initiating shutdown");
       void this.#shutdown("uncaughtException");
     };
     const rejectionHandler = (reason) => {
-      try {
-        let jsonStr;
-        try {
-          jsonStr = JSON.stringify(reason);
-        } catch {
-          jsonStr = "(not serializable)";
-        }
-        const detail = reason instanceof Error ? { message: reason.message, stack: reason.stack } : { inspected: `${String(reason)} ${jsonStr}` };
-        logger.error(detail, "Unhandled rejection (non-fatal)");
-      } catch {
-      }
+      logger.error({ err: reason }, "Unhandled rejection (non-fatal)");
     };
     process.on("uncaughtException", exceptionHandler);
     process.on("unhandledRejection", rejectionHandler);
@@ -12453,7 +12545,7 @@ var LifecycleManager = class {
   async #shutdown(signal) {
     if (this.#isShuttingDown) return;
     this.#isShuttingDown = true;
-    logger.info({ signal }, "Shutdown signal received");
+    logger.info({ signal, pid: process.pid, ppid: process.ppid }, "Shutdown signal received");
     const HARD_KILL_MS = 15e3;
     const forceExit = setTimeout(() => {
       logger.error("Graceful shutdown timed out, forcing exit");
@@ -12478,7 +12570,7 @@ var LifecycleManager = class {
           })
         ]).finally(() => clearTimeout(timeoutId));
       } catch (error2) {
-        logger.error({ error: error2 }, "Error during shutdown callback");
+        logger.error({ err: error2 }, "Error during shutdown callback");
       }
     }
     await this.#removePidFile();
@@ -12491,9 +12583,10 @@ var LifecycleManager = class {
 
 // src/serve.ts
 import { spawn as spawn4 } from "child_process";
-import { mkdir as mkdir3 } from "fs/promises";
+import { existsSync, statSync } from "fs";
+import { mkdir as mkdir3, readFile as readFile5, stat as stat2 } from "fs/promises";
 import { homedir as homedir2, hostname as hostname2 } from "os";
-import { resolve as resolve2 } from "path";
+import { isAbsolute as isAbsolute3, relative, resolve as resolve2 } from "path";
 
 // ../../node_modules/.pnpm/@levischuck+tiny-cbor@0.3.2/node_modules/@levischuck/tiny-cbor/esm/cbor/cbor_internal.js
 function decodeLength(data, argument, index) {
@@ -14328,7 +14421,7 @@ function runWithTimeout(command2, args, cwd, timeoutMs) {
     execFile(
       command2,
       args,
-      { timeout: timeoutMs, cwd, maxBuffer: 2 * 1024 * 1024 },
+      { timeout: timeoutMs, cwd, maxBuffer: 10 * 1024 * 1024 },
       (error2, stdout) => {
         if (error2) {
           reject(error2);
@@ -14341,6 +14434,19 @@ function runWithTimeout(command2, args, cwd, timeoutMs) {
 }
 var DIFF_TIMEOUT_MS = 15e3;
 var MAX_DIFF_SIZE = 2e5;
+var gitRepoCache = /* @__PURE__ */ new Map();
+async function isGitRepo(cwd) {
+  const cached = gitRepoCache.get(cwd);
+  if (cached !== void 0) return cached;
+  try {
+    await runWithTimeout("git", ["rev-parse", "--git-dir"], cwd, TIMEOUT_MS);
+    gitRepoCache.set(cwd, true);
+    return true;
+  } catch {
+    gitRepoCache.set(cwd, false);
+    return false;
+  }
+}
 async function withIntentToAdd(cwd, fn) {
   let added = false;
   try {
@@ -14362,29 +14468,46 @@ async function withIntentToAdd(cwd, fn) {
     }
   }
 }
-async function getUnstagedDiff(cwd) {
-  const result = await withIntentToAdd(
-    cwd,
-    () => runWithTimeout("git", ["diff", "--no-color"], cwd, DIFF_TIMEOUT_MS)
-  );
+function isMaxBufferError(err) {
+  return err instanceof Error && err.message.includes("maxBuffer");
+}
+var BUFFER_OVERFLOW_MSG = "... diff too large (exceeded buffer limit) ...\n";
+function truncateDiff(result) {
   return result.length > MAX_DIFF_SIZE ? `${result.slice(0, MAX_DIFF_SIZE)}
 
-... diff truncated (exceeds 1MB) ...
+... diff truncated (exceeds 200KB) ...
 ` : result;
 }
+async function getUnstagedDiff(cwd) {
+  if (!await isGitRepo(cwd)) return "";
+  try {
+    const result = await withIntentToAdd(
+      cwd,
+      () => runWithTimeout("git", ["diff", "--no-color"], cwd, DIFF_TIMEOUT_MS)
+    );
+    return truncateDiff(result);
+  } catch (err) {
+    if (isMaxBufferError(err)) return BUFFER_OVERFLOW_MSG;
+    throw err;
+  }
+}
 async function getStagedDiff(cwd) {
-  const result = await runWithTimeout(
-    "git",
-    ["diff", "--cached", "--no-color"],
-    cwd,
-    DIFF_TIMEOUT_MS
-  );
-  return result.length > MAX_DIFF_SIZE ? `${result.slice(0, MAX_DIFF_SIZE)}
-
-... diff truncated (exceeds 1MB) ...
-` : result;
+  if (!await isGitRepo(cwd)) return "";
+  try {
+    const result = await runWithTimeout(
+      "git",
+      ["diff", "--cached", "--no-color"],
+      cwd,
+      DIFF_TIMEOUT_MS
+    );
+    return truncateDiff(result);
+  } catch (err) {
+    if (isMaxBufferError(err)) return BUFFER_OVERFLOW_MSG;
+    throw err;
+  }
 }
 async function getChangedFiles(cwd) {
+  if (!await isGitRepo(cwd)) return [];
   const out = await runWithTimeout("git", ["status", "--porcelain"], cwd, DIFF_TIMEOUT_MS);
   if (!out) return [];
   return out.split("\n").filter(Boolean).map((line) => ({
@@ -14430,11 +14553,9 @@ async function getBranchDiff(cwd, baseBranch) {
       cwd,
       BRANCH_DIFF_TIMEOUT_MS
     );
-    return result.length > MAX_DIFF_SIZE ? `${result.slice(0, MAX_DIFF_SIZE)}
-
-... diff truncated (exceeds 1MB) ...
-` : result;
-  } catch {
+    return truncateDiff(result);
+  } catch (err) {
+    if (isMaxBufferError(err)) return BUFFER_OVERFLOW_MSG;
     return "";
   }
 }
@@ -14477,11 +14598,9 @@ async function getSnapshotDiff(cwd, fromRef, toRef) {
       cwd,
       DIFF_TIMEOUT_MS
     );
-    return result.length > MAX_DIFF_SIZE ? `${result.slice(0, MAX_DIFF_SIZE)}
-
-... diff truncated (exceeds 1MB) ...
-` : result;
-  } catch {
+    return truncateDiff(result);
+  } catch (err) {
+    if (isMaxBufferError(err)) return BUFFER_OVERFLOW_MSG;
     return "";
   }
 }
@@ -14625,6 +14744,265 @@ async function getRepoMetadata(repoPath) {
     return null;
   }
 }
+var GH_PR_JSON_FIELDS = "number,title,state,author,url,baseRefName,headRefName,body,isDraft,additions,deletions,changedFiles,createdAt,updatedAt,statusCheckRollup,reviews,reviewRequests,comments";
+var GH_STATE_MAP = {
+  OPEN: "open",
+  CLOSED: "closed",
+  MERGED: "merged"
+};
+var GhPRResponseSchema = external_exports.object({
+  number: external_exports.number().optional(),
+  title: external_exports.string().optional(),
+  state: external_exports.string().optional(),
+  author: external_exports.object({ login: external_exports.string() }).passthrough().optional(),
+  url: external_exports.string().optional(),
+  baseRefName: external_exports.string().optional(),
+  headRefName: external_exports.string().optional(),
+  body: external_exports.string().optional(),
+  isDraft: external_exports.boolean().optional(),
+  additions: external_exports.number().optional(),
+  deletions: external_exports.number().optional(),
+  changedFiles: external_exports.number().optional(),
+  createdAt: external_exports.string().optional(),
+  updatedAt: external_exports.string().optional(),
+  statusCheckRollup: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).optional(),
+  reviews: external_exports.union([
+    external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())),
+    external_exports.object({ nodes: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())) }).passthrough()
+  ]).optional(),
+  comments: external_exports.union([
+    external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())),
+    external_exports.object({ nodes: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())) }).passthrough()
+  ]).optional()
+}).passthrough();
+var GhPRListResponseSchema = external_exports.array(GhPRResponseSchema);
+function parseTimestamp(value) {
+  if (typeof value === "string") {
+    const parsed = new Date(value).getTime();
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  if (typeof value === "number") return value;
+  return 0;
+}
+function field(obj, key) {
+  if (typeof obj === "object" && obj !== null && key in obj) {
+    return obj[key];
+  }
+  return void 0;
+}
+function toRecord(value) {
+  if (typeof value === "object" && value !== null) return value;
+  return {};
+}
+function extractLogin(obj) {
+  const login = field(obj, "login");
+  return typeof login === "string" ? login : "";
+}
+function extractStringField(obj, f) {
+  const val = field(obj, f);
+  return typeof val === "string" ? val : null;
+}
+function extractArrayOrNodes(value) {
+  if (Array.isArray(value)) return value;
+  const nodes = field(value, "nodes");
+  if (Array.isArray(nodes)) return nodes;
+  return [];
+}
+function mapCheckStatus(check) {
+  const state = typeof check.state === "string" ? check.state.toLowerCase() : "";
+  const conclusion = typeof check.conclusion === "string" ? check.conclusion.toLowerCase() : "";
+  if (conclusion === "success") return "success";
+  if (conclusion === "failure" || conclusion === "timed_out" || conclusion === "action_required")
+    return "failure";
+  if (conclusion === "neutral") return "neutral";
+  if (conclusion === "skipped") return "skipped";
+  if (conclusion === "cancelled") return "cancelled";
+  if (state === "success") return "success";
+  if (state === "failure" || state === "error") return "failure";
+  if (state === "pending" || state === "queued" || state === "in_progress") return "pending";
+  return "pending";
+}
+function mapReviewState(value) {
+  if (typeof value !== "string") return "pending";
+  const upper = value.toUpperCase();
+  if (upper === "APPROVED") return "approved";
+  if (upper === "CHANGES_REQUESTED") return "changes_requested";
+  if (upper === "COMMENTED") return "commented";
+  if (upper === "DISMISSED") return "dismissed";
+  return "pending";
+}
+function mapGhCheck(c) {
+  const name = typeof c.name === "string" ? c.name : typeof c.context === "string" ? c.context : "";
+  const url = typeof c.targetUrl === "string" ? c.targetUrl : typeof c.detailsUrl === "string" ? c.detailsUrl : null;
+  return {
+    name,
+    status: mapCheckStatus(c),
+    conclusion: typeof c.conclusion === "string" ? c.conclusion.toLowerCase() : null,
+    url,
+    startedAt: parseTimestamp(c.startedAt),
+    completedAt: parseTimestamp(c.completedAt)
+  };
+}
+function mapGhReviewer(r) {
+  return {
+    login: extractLogin(r.author),
+    state: mapReviewState(r.state),
+    avatarUrl: extractStringField(r.author, "avatarUrl"),
+    submittedAt: parseTimestamp(r.submittedAt)
+  };
+}
+function mapGhComment(c) {
+  return {
+    id: typeof c.id === "string" ? c.id : String(c.id ?? ""),
+    author: extractLogin(c.author),
+    body: typeof c.body === "string" ? c.body : "",
+    createdAt: parseTimestamp(c.createdAt),
+    updatedAt: typeof c.updatedAt === "string" ? parseTimestamp(c.updatedAt) : null,
+    path: typeof c.path === "string" ? c.path : null,
+    line: typeof c.line === "number" ? c.line : null,
+    side: typeof c.side === "string" ? c.side : null,
+    isReviewComment: c.pullRequestReview !== void 0 && c.pullRequestReview !== null
+  };
+}
+function mapGhPRToPRData(raw) {
+  const isDraft2 = raw.isDraft === true;
+  const ghState = typeof raw.state === "string" ? raw.state.toUpperCase() : "";
+  const state = isDraft2 ? "draft" : GH_STATE_MAP[ghState] ?? "open";
+  const rawChecks = Array.isArray(raw.statusCheckRollup) ? raw.statusCheckRollup : [];
+  const checks = rawChecks.map(mapGhCheck);
+  const reviewers = extractArrayOrNodes(raw.reviews).map(
+    (r) => mapGhReviewer(toRecord(r))
+  );
+  const comments = extractArrayOrNodes(raw.comments).map(
+    (c) => mapGhComment(toRecord(c))
+  );
+  return {
+    number: typeof raw.number === "number" ? raw.number : 0,
+    title: typeof raw.title === "string" ? raw.title : "",
+    state,
+    author: extractLogin(raw.author),
+    url: typeof raw.url === "string" ? raw.url : "",
+    baseRef: typeof raw.baseRefName === "string" ? raw.baseRefName : "",
+    headRef: typeof raw.headRefName === "string" ? raw.headRefName : "",
+    body: typeof raw.body === "string" ? raw.body : "",
+    isDraft: isDraft2,
+    additions: typeof raw.additions === "number" ? raw.additions : 0,
+    deletions: typeof raw.deletions === "number" ? raw.deletions : 0,
+    changedFiles: typeof raw.changedFiles === "number" ? raw.changedFiles : 0,
+    createdAt: parseTimestamp(raw.createdAt),
+    updatedAt: parseTimestamp(raw.updatedAt),
+    checks,
+    reviewers,
+    comments
+  };
+}
+async function isGhAvailable() {
+  try {
+    await run("which", ["gh"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getPRForCurrentBranch(cwd) {
+  try {
+    const stdout = await runWithTimeout(
+      "gh",
+      ["pr", "view", "--json", GH_PR_JSON_FIELDS],
+      cwd,
+      15e3
+    );
+    const parseResult = GhPRResponseSchema.safeParse(JSON.parse(stdout));
+    if (!parseResult.success) {
+      return null;
+    }
+    return mapGhPRToPRData(parseResult.data);
+  } catch {
+    return null;
+  }
+}
+async function getPRDiff(cwd, prNumber) {
+  try {
+    const result = await runWithTimeout(
+      "gh",
+      ["pr", "diff", String(prNumber), "--color=never"],
+      cwd,
+      15e3
+    );
+    return truncateDiff(result);
+  } catch (err) {
+    if (isMaxBufferError(err)) return BUFFER_OVERFLOW_MSG;
+    return "";
+  }
+}
+async function getPRFiles(cwd, prNumber) {
+  try {
+    const stdout = await runWithTimeout(
+      "gh",
+      ["pr", "view", String(prNumber), "--json", "files"],
+      cwd,
+      15e3
+    );
+    const parsed = JSON.parse(stdout);
+    if (!Array.isArray(parsed.files)) return [];
+    return parsed.files.map((f) => ({
+      path: typeof f.path === "string" ? f.path : "",
+      status: f.additions !== void 0 || f.deletions !== void 0 ? "M" : "U"
+    }));
+  } catch {
+    return [];
+  }
+}
+async function getAssignedReviews(cwd) {
+  try {
+    const stdout = await runWithTimeout(
+      "gh",
+      [
+        "pr",
+        "list",
+        "--search",
+        "is:open review-requested:@me",
+        "--json",
+        GH_PR_JSON_FIELDS,
+        "--limit",
+        "10"
+      ],
+      cwd,
+      15e3
+    );
+    const parseResult = GhPRListResponseSchema.safeParse(JSON.parse(stdout));
+    if (!parseResult.success) return [];
+    return parseResult.data.map(mapGhPRToPRData);
+  } catch {
+    return [];
+  }
+}
+async function getUserPRs(cwd) {
+  try {
+    const stdout = await runWithTimeout(
+      "gh",
+      [
+        "pr",
+        "list",
+        "--author",
+        "@me",
+        "--state",
+        "open",
+        "--json",
+        GH_PR_JSON_FIELDS,
+        "--limit",
+        "10"
+      ],
+      cwd,
+      15e3
+    );
+    const parseResult = GhPRListResponseSchema.safeParse(JSON.parse(stdout));
+    if (!parseResult.success) return [];
+    return parseResult.data.map(mapGhPRToPRData);
+  } catch {
+    return [];
+  }
+}
 async function detectEnvironments() {
   const repoPaths = await findGitRepos(homedir());
   const repoInfos = await Promise.all(repoPaths.map(getRepoMetadata));
@@ -14783,6 +15161,664 @@ function createBranchWatcher(options) {
   };
 }
 
+// src/backpressure-send.ts
+var DEFAULT_BACKPRESSURE_THRESHOLD = 64 * 1024;
+var DEFAULT_MAX_QUEUE_BYTES = 1024 * 1024;
+var BUFFERED_AMOUNT_LOW_EVENT = "bufferedamountlow";
+function byteLength(data) {
+  if (typeof data === "string") {
+    return Buffer.byteLength(data);
+  }
+  return data.byteLength;
+}
+function createBackpressureSender(channel, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_BACKPRESSURE_THRESHOLD;
+  const maxQueueBytes = options.maxQueueBytes ?? DEFAULT_MAX_QUEUE_BYTES;
+  const dropOldest = options.dropOldest ?? false;
+  const queue = [];
+  let totalQueuedBytes = 0;
+  let isPaused = false;
+  function trySend(data) {
+    try {
+      channel.send(data);
+    } catch {
+    }
+  }
+  function drain() {
+    while (queue.length > 0) {
+      const buffered = channel.bufferedAmount;
+      if (buffered !== void 0 && buffered > threshold) {
+        return;
+      }
+      const entry = queue.shift();
+      if (!entry) break;
+      totalQueuedBytes -= entry.bytes;
+      trySend(entry.data);
+    }
+    if (queue.length === 0) {
+      isPaused = false;
+      channel.removeEventListener?.(BUFFERED_AMOUNT_LOW_EVENT, drain);
+    }
+  }
+  function evictOldest(requiredBytes) {
+    let droppedBytes = 0;
+    while (queue.length > 0 && totalQueuedBytes + requiredBytes > maxQueueBytes) {
+      const oldest = queue.shift();
+      if (!oldest) break;
+      totalQueuedBytes -= oldest.bytes;
+      droppedBytes += oldest.bytes;
+    }
+    if (droppedBytes > 0) {
+      options.onDrop?.(droppedBytes);
+    }
+  }
+  function enqueue(data) {
+    const bytes = byteLength(data);
+    if (totalQueuedBytes + bytes > maxQueueBytes) {
+      if (dropOldest) {
+        evictOldest(bytes);
+      } else {
+        options.onOverflow?.();
+        return;
+      }
+    }
+    queue.push({ data, bytes });
+    totalQueuedBytes += bytes;
+  }
+  function startPause() {
+    if (isPaused) return;
+    isPaused = true;
+    if (channel.addEventListener) {
+      if (channel.bufferedAmountLowThreshold !== void 0) {
+        channel.bufferedAmountLowThreshold = threshold;
+      }
+      channel.addEventListener(BUFFERED_AMOUNT_LOW_EVENT, drain);
+    }
+  }
+  return {
+    send(data) {
+      if (channel.bufferedAmount === void 0) {
+        trySend(data);
+        return true;
+      }
+      if (!isPaused && channel.bufferedAmount <= threshold) {
+        trySend(data);
+        return true;
+      }
+      startPause();
+      enqueue(data);
+      return !isPaused || queue.length > 0;
+    },
+    dispose() {
+      channel.removeEventListener?.(BUFFERED_AMOUNT_LOW_EVENT, drain);
+      queue.length = 0;
+      totalQueuedBytes = 0;
+      isPaused = false;
+    },
+    get paused() {
+      return isPaused;
+    },
+    get queuedBytes() {
+      return totalQueuedBytes;
+    }
+  };
+}
+
+// src/channel-buffer.ts
+function createChannelBuffer(channel, options) {
+  const log = createChildLogger({ mode: options.logPrefix ?? "channel-buffer" });
+  let open = channel.readyState === "open";
+  const pending = [];
+  let pendingBytes = 0;
+  let sender = null;
+  function getSender() {
+    if (!sender) {
+      sender = createBackpressureSender(channel, {
+        threshold: options.backpressureThreshold,
+        maxQueueBytes: options.maxBytes,
+        dropOldest: options.dropOldest,
+        onOverflow: options.onOverflow,
+        onDrop: (bytes) => {
+          log.debug({ droppedBytes: bytes }, "Backpressure dropped oldest data");
+        }
+      });
+    }
+    return sender;
+  }
+  return {
+    get isOpen() {
+      return open;
+    },
+    markOpen() {
+      open = true;
+    },
+    sendOrBuffer(data) {
+      if (open) {
+        return getSender().send(data);
+      }
+      const byteLen = Buffer.byteLength(data);
+      if (pendingBytes + byteLen > options.maxBytes) {
+        log.warn({ pendingBytes, newBytes: byteLen, max: options.maxBytes }, "Buffer overflow");
+        options.onOverflow?.();
+        return false;
+      }
+      pending.push(data);
+      pendingBytes += byteLen;
+      return true;
+    },
+    flush() {
+      const bp = getSender();
+      for (const chunk of pending) {
+        bp.send(chunk);
+      }
+      pending.length = 0;
+      pendingBytes = 0;
+    },
+    reset() {
+      pending.length = 0;
+      pendingBytes = 0;
+      open = false;
+      sender?.dispose();
+      sender = null;
+    },
+    dispose() {
+      sender?.dispose();
+      sender = null;
+    }
+  };
+}
+
+// src/peer-manager.ts
+var ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
+function machineIdToPeerId(machineId) {
+  return machineId;
+}
+async function loadDefaultFactory() {
+  const { RTCPeerConnection } = await import("node-datachannel/polyfill");
+  return () => {
+    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
+    return pc;
+  };
+}
+function parseTerminalChannelLabel(label) {
+  if (!label.startsWith("terminal-io:")) return null;
+  const suffix = label.slice("terminal-io:".length);
+  const colonIdx = suffix.indexOf(":");
+  const taskId = colonIdx === -1 ? suffix : suffix.slice(0, colonIdx);
+  if (!taskId) return null;
+  const terminalId = colonIdx === -1 || suffix.slice(colonIdx + 1) === "" ? crypto.randomUUID() : suffix.slice(colonIdx + 1);
+  return { taskId, terminalId };
+}
+function guardLoroChannelSend(dc) {
+  if (!dc.send) return;
+  const originalSend = dc.send.bind(dc);
+  dc.send = (data) => {
+    try {
+      originalSend(data);
+    } catch {
+    }
+  };
+}
+function parseFileChannelLabel(label) {
+  if (!label.startsWith("file-io:")) return null;
+  const channelId = label.slice("file-io:".length);
+  return channelId || null;
+}
+function createPeerManager(config2) {
+  const peers = /* @__PURE__ */ new Map();
+  const pendingCreates = /* @__PURE__ */ new Map();
+  let factoryPromise = null;
+  async function getFactory() {
+    if (config2.createPeerConnection) {
+      return config2.createPeerConnection;
+    }
+    if (!factoryPromise) {
+      factoryPromise = loadDefaultFactory();
+    }
+    return factoryPromise;
+  }
+  function setupPeerHandlers(machineId, pc) {
+    pc.onicecandidate = (event) => {
+      if (event.candidate) {
+        config2.onIceCandidate(machineId, {
+          candidate: event.candidate.candidate,
+          sdpMid: event.candidate.sdpMid,
+          sdpMLineIndex: event.candidate.sdpMLineIndex
+        });
+      }
+    };
+    pc.ondatachannel = (event) => {
+      const channel = event.channel;
+      const label = channel.label ?? "";
+      const terminalParsed = parseTerminalChannelLabel(label);
+      if (terminalParsed) {
+        logger.debug(
+          { machineId, taskId: terminalParsed.taskId, terminalId: terminalParsed.terminalId },
+          "Terminal data channel received"
+        );
+        config2.onTerminalChannel?.(
+          machineId,
+          event.channel,
+          terminalParsed.taskId,
+          terminalParsed.terminalId
+        );
+        return;
+      }
+      if (label.startsWith("terminal-io:")) {
+        logger.warn({ machineId, label }, "Terminal channel with empty taskId");
+        return;
+      }
+      const fileChannelId = parseFileChannelLabel(label);
+      if (fileChannelId) {
+        logger.info({ machineId, channelId: fileChannelId }, "File I/O data channel received");
+        config2.onFileChannel?.(machineId, event.channel, fileChannelId);
+        return;
+      }
+      if (label.startsWith("file-io:")) {
+        logger.warn({ machineId }, "File channel with empty id, ignoring");
+        return;
+      }
+      logger.info({ machineId }, "Data channel received from browser");
+      const rawChannel = event.channel;
+      guardLoroChannelSend(rawChannel);
+      config2.webrtcAdapter.attachDataChannel(machineIdToPeerId(machineId), event.channel);
+      logger.info({ machineId }, "Data channel attached to Loro adapter");
+    };
+    pc.onconnectionstatechange = () => {
+      const state = pc.connectionState;
+      logger.info({ machineId, state }, "Peer connection state changed");
+      if (state === "failed" || state === "closed") {
+        config2.webrtcAdapter.detachDataChannel(machineIdToPeerId(machineId));
+        peers.delete(machineId);
+        pc.close();
+      }
+    };
+    pc.onsignalingstatechange = () => {
+      const sigState = pc.signalingState;
+      logger.info({ machineId, signalingState: sigState }, "Signaling state changed");
+    };
+    pc.onicegatheringstatechange = () => {
+      const iceState = pc.iceGatheringState;
+      logger.info({ machineId, iceGatheringState: iceState }, "ICE gathering state changed");
+    };
+  }
+  return {
+    async handleOffer(fromMachineId, offer) {
+      logger.info({ fromMachineId }, "Handling WebRTC offer");
+      const existing = peers.get(fromMachineId);
+      if (existing) {
+        logger.debug({ fromMachineId }, "Closing existing peer connection");
+        existing.close();
+        peers.delete(fromMachineId);
+      }
+      const promise = (async () => {
+        const factory = await getFactory();
+        const pc = factory();
+        logger.debug({ fromMachineId }, "Created peer connection");
+        setupPeerHandlers(fromMachineId, pc);
+        logger.debug({ fromMachineId }, "Setting remote description (offer)");
+        await pc.setRemoteDescription(offer);
+        logger.debug({ fromMachineId }, "Creating answer");
+        const answer = await pc.createAnswer();
+        logger.debug(
+          { fromMachineId, hasAnswerSdp: !!answer.sdp },
+          "Setting local description (answer)"
+        );
+        await pc.setLocalDescription(answer);
+        peers.set(fromMachineId, pc);
+        pendingCreates.delete(fromMachineId);
+        logger.info({ fromMachineId }, "Sending WebRTC answer");
+        config2.onAnswer(fromMachineId, { type: "answer", sdp: answer.sdp });
+        return pc;
+      })();
+      pendingCreates.set(fromMachineId, promise);
+      const HANDSHAKE_TIMEOUT_MS = 3e4;
+      setTimeout(() => {
+        if (pendingCreates.get(fromMachineId) === promise) {
+          pendingCreates.delete(fromMachineId);
+          logger.warn({ fromMachineId }, "WebRTC handshake timed out");
+        }
+      }, HANDSHAKE_TIMEOUT_MS);
+      await promise;
+    },
+    async initiateOffer(targetMachineId) {
+      logger.info({ targetMachineId }, "Initiating WebRTC offer");
+      const existing = peers.get(targetMachineId);
+      if (existing) {
+        logger.debug({ targetMachineId }, "Closing existing peer connection");
+        existing.close();
+        peers.delete(targetMachineId);
+      }
+      const promise = (async () => {
+        const factory = await getFactory();
+        const pc = factory();
+        logger.debug({ targetMachineId }, "Created peer connection");
+        setupPeerHandlers(targetMachineId, pc);
+        if (!pc.createDataChannel) {
+          throw new Error("PeerConnection does not support createDataChannel");
+        }
+        if (!pc.createOffer) {
+          throw new Error("PeerConnection does not support createOffer");
+        }
+        logger.debug({ targetMachineId }, "Creating loro-sync data channel");
+        const channel = pc.createDataChannel("loro-sync", { ordered: true });
+        const rawChannel = channel;
+        guardLoroChannelSend(rawChannel);
+        rawChannel.onopen = () => {
+          config2.webrtcAdapter.attachDataChannel(
+            machineIdToPeerId(targetMachineId),
+            channel
+          );
+          logger.debug({ targetMachineId }, "Data channel attached to Loro adapter");
+        };
+        logger.debug({ targetMachineId }, "Creating offer");
+        const offer = await pc.createOffer();
+        logger.debug(
+          { targetMachineId, hasOfferSdp: !!offer.sdp },
+          "Setting local description (offer)"
+        );
+        await pc.setLocalDescription(offer);
+        peers.set(targetMachineId, pc);
+        pendingCreates.delete(targetMachineId);
+        logger.info({ targetMachineId }, "Sending WebRTC offer");
+        config2.onOffer?.(targetMachineId, { type: "offer", sdp: offer.sdp });
+        return pc;
+      })();
+      pendingCreates.set(targetMachineId, promise);
+      const HANDSHAKE_TIMEOUT_MS = 3e4;
+      setTimeout(() => {
+        if (pendingCreates.get(targetMachineId) === promise) {
+          pendingCreates.delete(targetMachineId);
+          logger.warn({ targetMachineId }, "WebRTC handshake timed out (initiator)");
+        }
+      }, HANDSHAKE_TIMEOUT_MS);
+      await promise;
+    },
+    async handleAnswer(fromMachineId, answer) {
+      logger.debug({ fromMachineId }, "Handling WebRTC answer");
+      let pc = peers.get(fromMachineId);
+      if (!pc) {
+        const pending = pendingCreates.get(fromMachineId);
+        if (pending) {
+          pc = await pending;
+        } else {
+          logger.warn({ fromMachineId }, "Received answer for unknown peer");
+          return;
+        }
+      }
+      await pc.setRemoteDescription(answer);
+      logger.debug({ fromMachineId }, "Remote description (answer) set");
+    },
+    async handleIce(fromMachineId, candidate) {
+      logger.debug({ fromMachineId }, "Handling WebRTC ICE candidate");
+      let pc = peers.get(fromMachineId);
+      if (!pc) {
+        const pending = pendingCreates.get(fromMachineId);
+        if (pending) {
+          pc = await pending;
+        } else {
+          logger.debug({ fromMachineId }, "Received ICE candidate for unknown peer");
+          return;
+        }
+      }
+      await pc.addIceCandidate(candidate);
+      logger.debug({ fromMachineId }, "ICE candidate added");
+    },
+    closePeer(targetId) {
+      const pc = peers.get(targetId);
+      if (pc) {
+        config2.webrtcAdapter.detachDataChannel(machineIdToPeerId(targetId));
+        pc.close();
+        peers.delete(targetId);
+      }
+    },
+    destroy() {
+      for (const [machineId, pc] of peers) {
+        config2.webrtcAdapter.detachDataChannel(machineIdToPeerId(machineId));
+        pc.close();
+      }
+      peers.clear();
+      pendingCreates.clear();
+    }
+  };
+}
+
+// src/collab-room-manager.ts
+function assertNever2(x) {
+  throw new Error(`Unhandled message type: ${JSON.stringify(x)}`);
+}
+function namespacePeerId(roomId, remoteUserId) {
+  return `collab:${roomId}:${remoteUserId}`;
+}
+function stripPeerIdNamespace(roomId, namespacedId) {
+  const prefix = `collab:${roomId}:`;
+  if (!namespacedId.startsWith(prefix)) {
+    throw new Error(`Expected namespaced peer ID with prefix "${prefix}", got "${namespacedId}"`);
+  }
+  return namespacedId.slice(prefix.length);
+}
+function handleAuthenticated(room, msg) {
+  room.myUserId = msg.userId;
+  room.log.info({ roomId: room.roomId, userId: msg.userId }, "Authenticated in collab room");
+}
+function maybeInitiateOffer(room, remoteUserId, context) {
+  if (!room.myUserId) return;
+  room.knownPeers.add(remoteUserId);
+  const shouldInitiate = room.myUserId < remoteUserId;
+  if (!shouldInitiate) return;
+  room.log.info({ roomId: room.roomId, targetUserId: remoteUserId }, context);
+  const namespacedPeerId = namespacePeerId(room.roomId, remoteUserId);
+  room.peerManager.initiateOffer(namespacedPeerId).catch((err) => {
+    room.log.error(
+      { roomId: room.roomId, targetUserId: remoteUserId, err },
+      "Failed to initiate offer"
+    );
+  });
+}
+function handleParticipantsList(room, msg) {
+  if (!room.myUserId) {
+    room.log.warn({ roomId: room.roomId }, "Received participants-list before authentication");
+    return;
+  }
+  for (const participant of msg.participants) {
+    if (participant.userId === room.myUserId) continue;
+    if (room.knownPeers.has(participant.userId)) continue;
+    maybeInitiateOffer(room, participant.userId, "Initiating WebRTC offer to existing participant");
+  }
+}
+function handleParticipantJoined(room, msg) {
+  if (!room.myUserId) return;
+  if (msg.participant.userId === room.myUserId) return;
+  maybeInitiateOffer(room, msg.participant.userId, "Initiating WebRTC offer to new participant");
+}
+function handleWebrtcOffer(room, msg) {
+  room.log.info({ roomId: room.roomId, fromUserId: msg.targetUserId }, "Received WebRTC offer");
+  const offer = msg.offer;
+  const namespacedPeerId = namespacePeerId(room.roomId, msg.targetUserId);
+  room.peerManager.handleOffer(namespacedPeerId, offer).catch((err) => {
+    room.log.error(
+      { roomId: room.roomId, fromUserId: msg.targetUserId, err },
+      "Failed to handle WebRTC offer"
+    );
+  });
+}
+function handleWebrtcAnswer(room, msg) {
+  room.log.info({ roomId: room.roomId, fromUserId: msg.targetUserId }, "Received WebRTC answer");
+  const answer = msg.answer;
+  const namespacedPeerId = namespacePeerId(room.roomId, msg.targetUserId);
+  room.peerManager.handleAnswer(namespacedPeerId, answer).catch((err) => {
+    room.log.error(
+      { roomId: room.roomId, fromUserId: msg.targetUserId, err },
+      "Failed to handle WebRTC answer"
+    );
+  });
+}
+function handleWebrtcIce(room, msg) {
+  room.log.debug({ roomId: room.roomId, fromUserId: msg.targetUserId }, "Received ICE candidate");
+  const candidate = msg.candidate;
+  const namespacedPeerId = namespacePeerId(room.roomId, msg.targetUserId);
+  room.peerManager.handleIce(namespacedPeerId, candidate).catch((err) => {
+    room.log.error(
+      { roomId: room.roomId, fromUserId: msg.targetUserId, err },
+      "Failed to handle ICE candidate"
+    );
+  });
+}
+function handleCollabRoomMessage(room, msg) {
+  switch (msg.type) {
+    case "authenticated":
+      handleAuthenticated(room, msg);
+      break;
+    case "participants-list":
+      handleParticipantsList(room, msg);
+      break;
+    case "participant-joined":
+      handleParticipantJoined(room, msg);
+      break;
+    case "participant-left":
+      room.knownPeers.delete(msg.userId);
+      room.peerManager.closePeer(namespacePeerId(room.roomId, msg.userId));
+      room.log.info({ roomId: room.roomId, userId: msg.userId }, "Participant left collab room");
+      break;
+    case "webrtc-offer":
+      handleWebrtcOffer(room, msg);
+      break;
+    case "webrtc-answer":
+      handleWebrtcAnswer(room, msg);
+      break;
+    case "webrtc-ice":
+      handleWebrtcIce(room, msg);
+      break;
+    case "error":
+      room.log.error({ roomId: room.roomId, message: msg.message }, "Collab room error");
+      break;
+    default:
+      assertNever2(msg);
+  }
+}
+function createRoomPeerManager(roomId, connection, webrtcAdapter) {
+  return createPeerManager({
+    webrtcAdapter,
+    onAnswer(namespacedId, answer) {
+      const targetUserId = stripPeerIdNamespace(roomId, namespacedId);
+      connection.send({
+        type: "webrtc-answer",
+        targetUserId,
+        // eslint-disable-next-line no-restricted-syntax -- SDP is opaque over signaling
+        answer
+      });
+    },
+    onOffer(namespacedId, offer) {
+      const targetUserId = stripPeerIdNamespace(roomId, namespacedId);
+      connection.send({
+        type: "webrtc-offer",
+        targetUserId,
+        // eslint-disable-next-line no-restricted-syntax -- SDP is opaque over signaling
+        offer
+      });
+    },
+    onIceCandidate(namespacedId, candidate) {
+      const targetUserId = stripPeerIdNamespace(roomId, namespacedId);
+      connection.send({
+        type: "webrtc-ice",
+        targetUserId,
+        // eslint-disable-next-line no-restricted-syntax -- ICE candidate is opaque over signaling
+        candidate
+      });
+    }
+  });
+}
+function createCollabRoomManager() {
+  const rooms = /* @__PURE__ */ new Map();
+  function leaveRoom(roomId) {
+    const room = rooms.get(roomId);
+    if (!room) return;
+    room.log.info({ roomId: room.roomId }, "Leaving collab room");
+    clearTimeout(room.expiryTimer);
+    room.unsubMessage();
+    room.unsubState();
+    room.peerManager.destroy();
+    room.connection.disconnect();
+    rooms.delete(roomId);
+  }
+  return {
+    join(config2) {
+      const { roomId, taskId, token, expiresAt, signalingBaseUrl, userToken, machineId, log } = config2;
+      if (rooms.has(roomId)) {
+        log.info({ roomId }, "Already joined collab room, replacing connection");
+        leaveRoom(roomId);
+      }
+      const wsUrl = new URL(signalingBaseUrl);
+      wsUrl.pathname = ROUTES.WS_COLLAB.replace(":roomId", roomId);
+      wsUrl.searchParams.set("token", token);
+      wsUrl.searchParams.set("userToken", userToken);
+      wsUrl.searchParams.set("clientType", "agent");
+      wsUrl.searchParams.set("machineId", machineId);
+      const connection = new CollabRoomConnection({
+        url: wsUrl.toString(),
+        maxRetries: -1,
+        initialDelayMs: 1e3,
+        maxDelayMs: 3e4,
+        backoffMultiplier: 2
+      });
+      const peerManager = createRoomPeerManager(roomId, connection, config2.webrtcAdapter);
+      const handle = {
+        roomId,
+        taskId,
+        destroy() {
+          leaveRoom(roomId);
+        }
+      };
+      const delayMs = expiresAt - Date.now();
+      if (delayMs <= 0 || !Number.isFinite(delayMs)) {
+        log.warn({ expiresAt }, "Collab room already expired or invalid expiresAt");
+        return handle;
+      }
+      const room = {
+        roomId,
+        taskId,
+        connection,
+        peerManager,
+        myUserId: null,
+        knownPeers: /* @__PURE__ */ new Set(),
+        expiryTimer: setTimeout(() => {
+          log.info({ roomId }, "Collab room token expired, leaving");
+          leaveRoom(roomId);
+        }, delayMs),
+        unsubMessage: () => {
+        },
+        unsubState: () => {
+        },
+        log
+      };
+      rooms.set(roomId, room);
+      room.unsubMessage = connection.onMessage((msg) => {
+        handleCollabRoomMessage(room, msg);
+      });
+      room.unsubState = connection.onStateChange((state) => {
+        log.info({ roomId, state }, "Collab room connection state changed");
+        if (state === "disconnected" || state === "error") {
+          room.peerManager.destroy();
+          room.peerManager = createRoomPeerManager(roomId, connection, config2.webrtcAdapter);
+          room.myUserId = null;
+          room.knownPeers.clear();
+        }
+      });
+      connection.connect();
+      log.info({ roomId, taskId, url: `${wsUrl.origin}${wsUrl.pathname}` }, "Joining collab room");
+      return handle;
+    },
+    leave(roomId) {
+      leaveRoom(roomId);
+    },
+    destroy() {
+      for (const roomId of [...rooms.keys()]) {
+        leaveRoom(roomId);
+      }
+    }
+  };
+}
+
 // src/crash-recovery.ts
 function recoverOrphanedTask(taskDocs, log) {
   const metaJson = taskDocs.meta.toJSON();
@@ -14811,10 +15847,10 @@ function recoverOrphanedTask(taskDocs, log) {
     });
   }
   change(taskDocs.meta, (draft) => {
-    draft.meta.status.set("failed");
+    draft.meta.status.set("input-required");
     draft.meta.updatedAt.set(Date.now());
   });
-  log.info({ previousStatus: status }, "Recovered orphaned task after daemon crash");
+  log.info({ previousStatus: status }, "Recovered orphaned task after daemon crash (resumable)");
   return true;
 }
 
@@ -14910,15 +15946,52 @@ async function runEnhanceQuery(prompt, systemPrompt, abortController, callbacks,
   );
 }
 
+// src/file-lister.ts
+import { execFile as execFile2 } from "child_process";
+var TIMEOUT_MS2 = 1e4;
+var MAX_BUFFER = 5 * 1024 * 1024;
+function listWorkspaceFiles(repoPath) {
+  return new Promise((resolve4, reject) => {
+    execFile2(
+      "git",
+      ["ls-files", "--cached", "--others", "--exclude-standard"],
+      { timeout: TIMEOUT_MS2, maxBuffer: MAX_BUFFER, cwd: repoPath },
+      (error2, stdout) => {
+        if (error2) {
+          reject(error2);
+          return;
+        }
+        const lines = stdout.split("\n").filter(Boolean);
+        if (lines.length === 0) {
+          resolve4([]);
+          return;
+        }
+        const dirSet = /* @__PURE__ */ new Set();
+        const files = [];
+        for (const line of lines) {
+          files.push({ path: line, isDirectory: false });
+          const segments = line.split("/");
+          for (let i = 1; i < segments.length; i++) {
+            dirSet.add(segments.slice(0, i).join("/"));
+          }
+        }
+        const dirs = [...dirSet].sort((a, b) => a.localeCompare(b)).map((p) => ({ path: p, isDirectory: true }));
+        const sortedFiles = files.sort((a, b) => a.path.localeCompare(b.path));
+        resolve4([...dirs, ...sortedFiles]);
+      }
+    );
+  });
+}
+
 // src/keep-awake.ts
 import { spawn } from "child_process";
 var darwinStrategy = {
-  spawn: () => spawn("caffeinate", ["-i"], { stdio: ["ignore", "ignore", "ignore"] })
+  spawn: () => spawn("caffeinate", ["-di"], { stdio: ["ignore", "ignore", "ignore"] })
 };
 var linuxStrategy = {
   spawn: () => spawn(
     "systemd-inhibit",
-    ["--what=idle", "--why=Shipyard agent tasks running", "sleep", "infinity"],
+    ["--what=idle:sleep", "--why=Shipyard agent tasks running", "sleep", "infinity"],
     { stdio: ["ignore", "ignore", "ignore"] }
   )
 };
@@ -14928,7 +16001,7 @@ var win32Strategy = {
     [
       "-NoProfile",
       "-Command",
-      "[System.Runtime.InteropServices.Marshal]::SetThreadExecutionState(0x80000001); Start-Sleep -Seconds 2147483"
+      "[System.Runtime.InteropServices.Marshal]::SetThreadExecutionState(0x80000003); Start-Sleep -Seconds 2147483"
     ],
     { stdio: ["ignore", "ignore", "ignore"] }
   )
@@ -14953,9 +16026,12 @@ var KeepAwakeManager = class {
   #shouldBeRunning = false;
   #restartAttempts = 0;
   #log;
-  constructor(log) {
+  #graceTimer = null;
+  #gracePeriodMs;
+  constructor(log, gracePeriodMs = KEEP_AWAKE_GRACE_PERIOD_MS) {
     this.#strategy = createKeepAwakeStrategy();
     this.#log = log;
+    this.#gracePeriodMs = gracePeriodMs;
     if (!this.#strategy) {
       log.info({ platform: process.platform }, "Keep-awake not supported on this platform");
     }
@@ -14963,20 +16039,50 @@ var KeepAwakeManager = class {
   get running() {
     return this.#child !== null;
   }
+  get graceActive() {
+    return this.#graceTimer !== null;
+  }
   update(enabled, hasActiveTasks) {
     const shouldRun = enabled && hasActiveTasks;
-    this.#shouldBeRunning = shouldRun;
     this.#restartAttempts = 0;
-    if (shouldRun && !this.#child) {
-      this.#start();
-    } else if (!shouldRun && this.#child) {
+    if (shouldRun) {
+      this.#cancelGrace();
+      this.#shouldBeRunning = true;
+      if (!this.#child) {
+        this.#start();
+      }
+    } else if (this.#graceTimer && enabled && !hasActiveTasks) {
+      return;
+    } else if (this.#shouldBeRunning && enabled && !hasActiveTasks) {
+      this.#shouldBeRunning = false;
+      this.#startGrace();
+    } else if (!shouldRun) {
+      this.#shouldBeRunning = false;
+      this.#cancelGrace();
       this.#stop();
     }
   }
   shutdown() {
     this.#shouldBeRunning = false;
+    this.#cancelGrace();
     this.#stop();
   }
+  #startGrace() {
+    if (this.#graceTimer) return;
+    this.#log.info({ gracePeriodMs: this.#gracePeriodMs }, "Keep-awake grace period started");
+    this.#graceTimer = setTimeout(() => {
+      this.#graceTimer = null;
+      this.#log.info("Keep-awake grace period expired");
+      this.#stop();
+    }, this.#gracePeriodMs);
+    this.#graceTimer.unref();
+  }
+  #cancelGrace() {
+    if (!this.#graceTimer) return;
+    clearTimeout(this.#graceTimer);
+    this.#graceTimer = null;
+    this.#log.info("Keep-awake grace period cancelled (new task started)");
+  }
   #start() {
     if (!this.#strategy || this.#child) return;
     try {
@@ -15003,7 +16109,7 @@ var KeepAwakeManager = class {
     }
   }
   #scheduleRestart() {
-    if (!this.#shouldBeRunning) return;
+    if (!this.#shouldBeRunning && !this.#graceTimer) return;
     this.#restartAttempts++;
     if (this.#restartAttempts > MAX_RESTART_ATTEMPTS) {
       this.#log.warn(
@@ -15018,7 +16124,7 @@ var KeepAwakeManager = class {
       "Scheduling keep-awake restart"
     );
     const timer = setTimeout(() => {
-      if (this.#shouldBeRunning && !this.#child) {
+      if ((this.#shouldBeRunning || this.#graceTimer) && !this.#child) {
         this.#start();
       }
     }, delay);
@@ -15036,158 +16142,6 @@ var KeepAwakeManager = class {
   }
 };
 
-// src/peer-manager.ts
-var ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
-function machineIdToPeerId(machineId) {
-  return machineId;
-}
-async function loadDefaultFactory() {
-  const { RTCPeerConnection } = await import("node-datachannel/polyfill");
-  return () => {
-    const pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
-    return pc;
-  };
-}
-function createPeerManager(config2) {
-  const peers = /* @__PURE__ */ new Map();
-  const pendingCreates = /* @__PURE__ */ new Map();
-  let factoryPromise = null;
-  async function getFactory() {
-    if (config2.createPeerConnection) {
-      return config2.createPeerConnection;
-    }
-    if (!factoryPromise) {
-      factoryPromise = loadDefaultFactory();
-    }
-    return factoryPromise;
-  }
-  function setupPeerHandlers(machineId, pc) {
-    pc.onicecandidate = (event) => {
-      if (event.candidate) {
-        config2.onIceCandidate(machineId, {
-          candidate: event.candidate.candidate,
-          sdpMid: event.candidate.sdpMid,
-          sdpMLineIndex: event.candidate.sdpMLineIndex
-        });
-      }
-    };
-    pc.ondatachannel = (event) => {
-      const channel = event.channel;
-      if (channel.label?.startsWith("terminal-io:")) {
-        const taskId = channel.label.slice("terminal-io:".length);
-        if (!taskId) {
-          logger.warn({ machineId }, "Terminal channel with empty taskId, ignoring");
-          return;
-        }
-        logger.info({ machineId, taskId }, "Terminal data channel received");
-        config2.onTerminalChannel?.(machineId, event.channel, taskId);
-      } else {
-        logger.info({ machineId }, "Data channel received from browser");
-        config2.webrtcAdapter.attachDataChannel(
-          machineIdToPeerId(machineId),
-          event.channel
-        );
-        logger.info({ machineId }, "Data channel attached to Loro adapter");
-      }
-    };
-    pc.onconnectionstatechange = () => {
-      const state = pc.connectionState;
-      logger.info({ machineId, state }, "Peer connection state changed");
-      if (state === "failed" || state === "closed") {
-        config2.webrtcAdapter.detachDataChannel(machineIdToPeerId(machineId));
-        peers.delete(machineId);
-        pc.close();
-      }
-    };
-    pc.onsignalingstatechange = () => {
-      const sigState = pc.signalingState;
-      logger.info({ machineId, signalingState: sigState }, "Signaling state changed");
-    };
-    pc.onicegatheringstatechange = () => {
-      const iceState = pc.iceGatheringState;
-      logger.info({ machineId, iceGatheringState: iceState }, "ICE gathering state changed");
-    };
-  }
-  return {
-    async handleOffer(fromMachineId, offer) {
-      logger.info({ fromMachineId }, "Handling WebRTC offer");
-      const existing = peers.get(fromMachineId);
-      if (existing) {
-        logger.debug({ fromMachineId }, "Closing existing peer connection");
-        existing.close();
-        peers.delete(fromMachineId);
-      }
-      const promise = (async () => {
-        const factory = await getFactory();
-        const pc = factory();
-        logger.debug({ fromMachineId }, "Created peer connection");
-        setupPeerHandlers(fromMachineId, pc);
-        logger.debug({ fromMachineId }, "Setting remote description (offer)");
-        await pc.setRemoteDescription(offer);
-        logger.debug({ fromMachineId }, "Creating answer");
-        const answer = await pc.createAnswer();
-        logger.debug(
-          { fromMachineId, hasAnswerSdp: !!answer.sdp },
-          "Setting local description (answer)"
-        );
-        await pc.setLocalDescription(answer);
-        peers.set(fromMachineId, pc);
-        pendingCreates.delete(fromMachineId);
-        logger.info({ fromMachineId }, "Sending WebRTC answer");
-        config2.onAnswer(fromMachineId, { type: "answer", sdp: answer.sdp });
-        return pc;
-      })();
-      pendingCreates.set(fromMachineId, promise);
-      const HANDSHAKE_TIMEOUT_MS = 3e4;
-      setTimeout(() => {
-        if (pendingCreates.get(fromMachineId) === promise) {
-          pendingCreates.delete(fromMachineId);
-          logger.warn({ fromMachineId }, "WebRTC handshake timed out");
-        }
-      }, HANDSHAKE_TIMEOUT_MS);
-      await promise;
-    },
-    async handleAnswer(fromMachineId, answer) {
-      logger.debug({ fromMachineId }, "Handling WebRTC answer");
-      let pc = peers.get(fromMachineId);
-      if (!pc) {
-        const pending = pendingCreates.get(fromMachineId);
-        if (pending) {
-          pc = await pending;
-        } else {
-          logger.warn({ fromMachineId }, "Received answer for unknown peer");
-          return;
-        }
-      }
-      await pc.setRemoteDescription(answer);
-      logger.debug({ fromMachineId }, "Remote description (answer) set");
-    },
-    async handleIce(fromMachineId, candidate) {
-      logger.debug({ fromMachineId }, "Handling WebRTC ICE candidate");
-      let pc = peers.get(fromMachineId);
-      if (!pc) {
-        const pending = pendingCreates.get(fromMachineId);
-        if (pending) {
-          pc = await pending;
-        } else {
-          logger.warn({ fromMachineId }, "Received ICE candidate for unknown peer");
-          return;
-        }
-      }
-      await pc.addIceCandidate(candidate);
-      logger.debug({ fromMachineId }, "ICE candidate added");
-    },
-    destroy() {
-      for (const [machineId, pc] of peers) {
-        config2.webrtcAdapter.detachDataChannel(machineIdToPeerId(machineId));
-        pc.close();
-      }
-      peers.clear();
-      pendingCreates.clear();
-    }
-  };
-}
-
 // src/plan-editor/format-diff-feedback.ts
 function formatDiffFeedbackForClaudeCode(comments, generalFeedback) {
   const sections = [];
@@ -21261,8 +22215,8 @@ var EditorState = class _EditorState {
       throw new RangeError("Applying a mismatched transaction");
     let newInstance = new _EditorState(this.config), fields = this.config.fields;
     for (let i = 0; i < fields.length; i++) {
-      let field = fields[i];
-      newInstance[field.name] = field.apply(tr2, this[field.name], this, newInstance);
+      let field2 = fields[i];
+      newInstance[field2.name] = field2.apply(tr2, this[field2.name], this, newInstance);
     }
     return newInstance;
   }
@@ -21334,24 +22288,24 @@ var EditorState = class _EditorState {
       throw new RangeError("Required config field 'schema' missing");
     let $config = new Configuration(config2.schema, config2.plugins);
     let instance = new _EditorState($config);
-    $config.fields.forEach((field) => {
-      if (field.name == "doc") {
+    $config.fields.forEach((field2) => {
+      if (field2.name == "doc") {
         instance.doc = Node.fromJSON(config2.schema, json.doc);
-      } else if (field.name == "selection") {
+      } else if (field2.name == "selection") {
         instance.selection = Selection.fromJSON(instance.doc, json.selection);
-      } else if (field.name == "storedMarks") {
+      } else if (field2.name == "storedMarks") {
         if (json.storedMarks)
           instance.storedMarks = json.storedMarks.map(config2.schema.markFromJSON);
       } else {
         if (pluginFields)
           for (let prop in pluginFields) {
             let plugin = pluginFields[prop], state = plugin.spec.state;
-            if (plugin.key == field.name && state && state.fromJSON && Object.prototype.hasOwnProperty.call(json, prop)) {
-              instance[field.name] = state.fromJSON.call(plugin, config2, json[prop], instance);
+            if (plugin.key == field2.name && state && state.fromJSON && Object.prototype.hasOwnProperty.call(json, prop)) {
+              instance[field2.name] = state.fromJSON.call(plugin, config2, json[prop], instance);
               return;
             }
           }
-        instance[field.name] = field.init(config2, instance);
+        instance[field2.name] = field2.init(config2, instance);
       }
     });
     return instance;
@@ -29057,18 +30011,18 @@ function findParentNodeClosestToPos($pos, predicate) {
 function findParentNode(predicate) {
   return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
 }
-function getExtensionField(extension, field, context) {
-  if (extension.config[field] === void 0 && extension.parent) {
-    return getExtensionField(extension.parent, field, context);
+function getExtensionField(extension, field2, context) {
+  if (extension.config[field2] === void 0 && extension.parent) {
+    return getExtensionField(extension.parent, field2, context);
   }
-  if (typeof extension.config[field] === "function") {
-    const value = extension.config[field].bind({
+  if (typeof extension.config[field2] === "function") {
+    const value = extension.config[field2].bind({
       ...context,
-      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null
+      parent: extension.parent ? getExtensionField(extension.parent, field2, context) : null
     });
     return value;
   }
-  return extension.config[field];
+  return extension.config[field2];
 }
 function flattenExtensions(extensions) {
   return extensions.map((extension) => {
@@ -43619,7 +44573,7 @@ function initPlanEditorDoc(loroDoc, planId, markdown) {
     loroDoc.commit();
     return true;
   } catch (error2) {
-    logger.warn({ planId, error: error2 }, "initPlanEditorDoc failed");
+    logger.warn({ planId, err: error2 }, "initPlanEditorDoc failed");
     return false;
   }
 }
@@ -43681,6 +44635,7 @@ ensureSpawnHelperExecutable();
 var KILL_TIMEOUT_MS = 5e3;
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
+var SCROLLBACK_MAX_BYTES = 5e4;
 function createPtyManager() {
   const log = createChildLogger({ mode: "pty" });
   let process2 = null;
@@ -43688,6 +44643,10 @@ function createPtyManager() {
   let killTimer = null;
   const dataCallbacks = [];
   const exitCallbacks = [];
+  let dataSink = null;
+  let exitSink = null;
+  const scrollbackChunks = [];
+  let scrollbackBytes = 0;
   function getDefaultShell() {
     return globalThis.process.env.SHELL ?? "/bin/zsh";
   }
@@ -43718,6 +44677,8 @@ function createPtyManager() {
     }
     isAlive = true;
     process2.onData((data) => {
+      appendScrollback(data);
+      if (dataSink) dataSink(data);
       for (const cb of dataCallbacks) {
         cb(data);
       }
@@ -43726,6 +44687,7 @@ function createPtyManager() {
       log.info({ exitCode: exitCode3, signal, pid: process2?.pid }, "PTY exited");
       isAlive = false;
       clearKillTimer();
+      if (exitSink) exitSink(exitCode3, signal);
       for (const cb of exitCallbacks) {
         cb(exitCode3, signal);
       }
@@ -43769,10 +44731,33 @@ function createPtyManager() {
       }
     }, KILL_TIMEOUT_MS);
   }
+  function appendScrollback(data) {
+    const byteLen = Buffer.byteLength(data);
+    scrollbackChunks.push(data);
+    scrollbackBytes += byteLen;
+    while (scrollbackBytes > SCROLLBACK_MAX_BYTES && scrollbackChunks.length > 1) {
+      const removed = scrollbackChunks.shift();
+      if (!removed) break;
+      scrollbackBytes -= Buffer.byteLength(removed);
+    }
+  }
+  function setDataSink(callback) {
+    dataSink = callback;
+  }
+  function setExitSink(callback) {
+    exitSink = callback;
+  }
+  function getScrollback() {
+    return scrollbackChunks.join("");
+  }
   function dispose() {
     kill();
     dataCallbacks.length = 0;
     exitCallbacks.length = 0;
+    dataSink = null;
+    exitSink = null;
+    scrollbackChunks.length = 0;
+    scrollbackBytes = 0;
     process2 = null;
     isAlive = false;
   }
@@ -43788,6 +44773,9 @@ function createPtyManager() {
     resize,
     onData,
     onExit,
+    setDataSink,
+    setExitSink,
+    getScrollback,
     kill,
     dispose
   };
@@ -43918,7 +44906,7 @@ function toSdkContent(blocks) {
   }
   return result;
 }
-function extractStringField(message, key, fallback) {
+function extractStringField2(message, key, fallback) {
   const value = message[key];
   return typeof value === "string" ? value : fallback;
 }
@@ -44024,6 +45012,7 @@ var SessionManager = class {
   #reviewDoc;
   #onStatusChange;
   #onBackgroundAgent;
+  #onTodoProgress;
   #userId;
   #userName;
   #currentModel = null;
@@ -44032,7 +45021,7 @@ var SessionManager = class {
   #inputController = null;
   #activeQuery = null;
   #knownSkills = /* @__PURE__ */ new Set();
-  constructor(taskDocs, userId, userName, onStatusChange, onBackgroundAgent) {
+  constructor(taskDocs, userId, userName, onStatusChange, onBackgroundAgent, onTodoProgress) {
     this.#metaDoc = taskDocs.meta;
     this.#convDoc = taskDocs.conv;
     this.#reviewDoc = taskDocs.review;
@@ -44040,6 +45029,7 @@ var SessionManager = class {
     this.#userName = userName;
     this.#onStatusChange = onStatusChange;
     this.#onBackgroundAgent = onBackgroundAgent;
+    this.#onTodoProgress = onTodoProgress;
   }
   #buildAttribution() {
     return {
@@ -44055,6 +45045,18 @@ var SessionManager = class {
   #notifyStatusChange(status) {
     this.#onStatusChange?.(status);
   }
+  #notifyTodoProgress(items) {
+    if (!this.#onTodoProgress) return;
+    let completed = 0;
+    let currentActivity = null;
+    for (const item of items) {
+      if (item.status === "completed") completed++;
+      if (item.status === "in_progress" && !currentActivity) {
+        currentActivity = item.activeForm ?? null;
+      }
+    }
+    this.#onTodoProgress({ todoCompleted: completed, todoTotal: items.length, currentActivity });
+  }
   /**
    * Extract the latest user message text from the conversation.
    * Walks backwards from the end to find the most recent user turn,
@@ -44206,17 +45208,19 @@ var SessionManager = class {
     this.#activeQuery = null;
   }
   async #fetchKnownSkills(response) {
-    const TIMEOUT_MS2 = 5e3;
+    const TIMEOUT_MS3 = 1e4;
     try {
       const commands = await Promise.race([
         response.supportedCommands(),
         new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("supportedCommands timed out")), TIMEOUT_MS2)
+          (_, reject) => setTimeout(() => reject(new Error("supportedCommands timed out")), TIMEOUT_MS3)
         )
       ]);
       return new Set(commands.map((c) => c.name));
     } catch {
-      logger.warn("Failed to fetch supportedCommands, all slash-prefixed messages will be escaped");
+      logger.debug(
+        "Failed to fetch supportedCommands, all slash-prefixed messages will be escaped"
+      );
       return /* @__PURE__ */ new Set();
     }
   }
@@ -44434,9 +45438,9 @@ var SessionManager = class {
   }
   #handleTaskStarted(message) {
     const msg = message;
-    const taskId = extractStringField(msg, "task_id", "");
-    const toolUseId = extractStringField(msg, "tool_use_id", "") || taskId;
-    const description = extractStringField(msg, "description", "");
+    const taskId = extractStringField2(msg, "task_id", "");
+    const toolUseId = extractStringField2(msg, "tool_use_id", "") || taskId;
+    const description = extractStringField2(msg, "description", "");
     if (!toolUseId) {
       logger.warn("Received task_started with no tool_use_id or task_id, skipping");
       return;
@@ -44461,11 +45465,11 @@ var SessionManager = class {
   }
   #handleTaskNotification(message) {
     const msg = message;
-    const taskId = extractStringField(msg, "task_id", "unknown");
-    const toolUseId = extractStringField(msg, "tool_use_id", "") || taskId;
-    const msgStatus = extractStringField(msg, "status", "unknown");
-    const summary = extractStringField(msg, "summary", "");
-    const outputFile = extractStringField(msg, "output_file", "");
+    const taskId = extractStringField2(msg, "task_id", "unknown");
+    const toolUseId = extractStringField2(msg, "tool_use_id", "") || taskId;
+    const msgStatus = extractStringField2(msg, "status", "unknown");
+    const summary = extractStringField2(msg, "summary", "");
+    const outputFile = extractStringField2(msg, "output_file", "");
     logger.info(
       { taskId, toolUseId, status: msgStatus, summary },
       "Received task_notification from subagent"
@@ -44673,6 +45677,7 @@ var SessionManager = class {
         { toolUseId: block2.toolUseId, count: enrichedItems.length },
         "Updated todoItems from TodoWrite tool call"
       );
+      this.#notifyTodoProgress(enrichedItems);
     }
   }
   #handleResult(message, sessionId, agentSessionId) {
@@ -44711,6 +45716,7 @@ var SessionManager = class {
   }
   #handleProcessError(error2, sessionId, agentSessionId, idleTimedOut, abortController) {
     if (idleTimedOut) {
+      logger.info({ sessionId, cause: "idle-timeout" }, "Session error: idle timeout");
       this.#markInterrupted(sessionId);
       return {
         sessionId,
@@ -44720,10 +45726,15 @@ var SessionManager = class {
       };
     }
     if (abortController?.signal.aborted) {
+      logger.info({ sessionId, cause: "abort-signal" }, "Session error: abort signal");
       this.#markInterrupted(sessionId);
       return { sessionId, agentSessionId, status: "interrupted" };
     }
     const errorMsg = error2 instanceof Error ? error2.message : String(error2);
+    logger.info(
+      { sessionId, cause: "process-error", error: errorMsg },
+      "Session error: process threw"
+    );
     this.#markFailed(sessionId, errorMsg);
     return { sessionId, agentSessionId, status: "failed", error: errorMsg };
   }
@@ -44769,11 +45780,13 @@ var SessionManager = class {
 };
 
 // src/signaling-setup.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { hostname } from "os";
+import { dirname as dirname3, join as join6 } from "path";
 
 // src/signaling.ts
 function createDaemonSignaling(config2) {
-  const agentId = nanoid();
+  const agentId = config2.agentId ?? nanoid();
   function send(msg) {
     config2.connection.send(msg);
   }
@@ -44807,7 +45820,22 @@ function createDaemonSignaling(config2) {
 }
 
 // src/signaling-setup.ts
-async function createSignalingHandle(env, log) {
+function getOrCreateAgentId(shipyardHome) {
+  const filePath = join6(shipyardHome, "agent-id");
+  try {
+    const existing = readFileSync(filePath, "utf-8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  const id = crypto.randomUUID();
+  try {
+    mkdirSync(dirname3(filePath), { recursive: true });
+    writeFileSync(filePath, id, { mode: 384 });
+  } catch {
+  }
+  return id;
+}
+async function createSignalingHandle(env, log, shipyardHome) {
   if (!env.SHIPYARD_SIGNALING_URL) {
     return null;
   }
@@ -44840,11 +45868,14 @@ async function createSignalingHandle(env, log) {
     maxDelayMs: 3e4,
     backoffMultiplier: 2
   });
+  const agentId = getOrCreateAgentId(shipyardHome);
+  log.info({ agentId }, "Using persisted agent ID");
   const signaling = createDaemonSignaling({
     connection,
     machineId,
     machineName,
-    agentType: "daemon"
+    agentType: "daemon",
+    agentId
   });
   connection.onStateChange((state) => {
     if (state === "connected") {
@@ -44924,21 +45955,21 @@ function cleanupStaleSetupEntries(roomDoc, localMachineId, log) {
 }
 
 // src/worktree-command.ts
-import { execFile as execFile2, spawn as spawn3 } from "child_process";
+import { execFile as execFile3, spawn as spawn3 } from "child_process";
 import { closeSync, openSync } from "fs";
 import { access, chmod, constants as constants2, copyFile, mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join6 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join7 } from "path";
 var GIT_TIMEOUT_MS = 3e4;
 function isErrnoException(err) {
   return err instanceof Error && "code" in err;
 }
-var MAX_BUFFER = 10 * 1024 * 1024;
+var MAX_BUFFER2 = 10 * 1024 * 1024;
 function runGit(args, cwd) {
   return new Promise((resolve4, reject) => {
-    execFile2(
+    execFile3(
       "git",
       args,
-      { timeout: GIT_TIMEOUT_MS, cwd, maxBuffer: MAX_BUFFER },
+      { timeout: GIT_TIMEOUT_MS, cwd, maxBuffer: MAX_BUFFER2 },
       (error2, stdout) => {
         if (error2) reject(error2);
         else resolve4(stdout.trim());
@@ -45017,9 +46048,9 @@ async function copyIgnoredFiles(sourceRepoPath, worktreePath) {
   const files = ignoredOutput.split("\n").filter((f) => f && !shouldExclude(f));
   for (const file of files) {
     try {
-      const destPath = join6(worktreePath, file);
-      await mkdir2(dirname3(destPath), { recursive: true });
-      await copyFile(join6(sourceRepoPath, file), destPath);
+      const destPath = join7(worktreePath, file);
+      await mkdir2(dirname4(destPath), { recursive: true });
+      await copyFile(join7(sourceRepoPath, file), destPath);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       warnings.push(`Failed to copy ${file}: ${msg}`);
@@ -45029,9 +46060,9 @@ async function copyIgnoredFiles(sourceRepoPath, worktreePath) {
 }
 async function launchSetupScript(worktreePath, setupScript) {
   if (!setupScript) return null;
-  const shipyardDir = join6(worktreePath, ".shipyard");
-  const scriptPath = join6(shipyardDir, "worktree-setup.sh");
-  const logPath = join6(shipyardDir, "worktree-setup.log");
+  const shipyardDir = join7(worktreePath, ".shipyard");
+  const scriptPath = join7(shipyardDir, "worktree-setup.sh");
+  const logPath = join7(shipyardDir, "worktree-setup.log");
   let fullScript;
   if (setupScript.startsWith("#!")) {
     const firstNewline = setupScript.indexOf("\n");
@@ -45063,7 +46094,7 @@ async function createWorktree(opts) {
   const { sourceRepoPath, branchName, baseRef, setupScript, onProgress } = opts;
   validateWorktreeInputs(sourceRepoPath, branchName, baseRef);
   const worktreeParent = `${sourceRepoPath}-wt`;
-  const worktreePath = join6(worktreeParent, branchName);
+  const worktreePath = join7(worktreeParent, branchName);
   onProgress("creating-worktree", `Creating worktree at ${worktreePath}`);
   await mkdir2(worktreeParent, { recursive: true });
   await assertWorktreeNotExists(worktreePath);
@@ -45119,7 +46150,7 @@ function validateWorktreeInputs(sourceRepoPath, branchName, baseRef) {
 }
 
 // src/serve.ts
-function assertNever2(x) {
+function assertNever3(x) {
   throw new Error(`Unhandled message type: ${JSON.stringify(x)}`);
 }
 var processedRequestIds = /* @__PURE__ */ new Set();
@@ -45131,10 +46162,71 @@ function scheduleEphemeralCleanup(fn, delayMs) {
   }, delayMs);
   pendingCleanupTimers.add(timer);
 }
-var CONTROL_PREFIX = "\0
\0";
+function parseFileChannelMessage(raw) {
+  if (!raw.startsWith(FILE_IO_CONTROL_PREFIX)) return null;
+  try {
+    const msg = JSON.parse(raw.slice(FILE_IO_CONTROL_PREFIX.length));
+    if (typeof msg.type !== "string" || typeof msg.requestId !== "string") {
+      return null;
+    }
+    if (msg.type === "read") {
+      if (typeof msg.path !== "string") return null;
+      return {
+        type: "read",
+        requestId: msg.requestId,
+        path: msg.path,
+        envPath: typeof msg.envPath === "string" ? msg.envPath : null
+      };
+    }
+    if (msg.type === "list-dir") {
+      return {
+        type: "list-dir",
+        requestId: msg.requestId,
+        envPath: typeof msg.envPath === "string" ? msg.envPath : null
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 var TERMINAL_BUFFER_MAX_BYTES = 1048576;
 var TERMINAL_OPEN_TIMEOUT_MS = 1e4;
 var TERMINAL_CWD_TIMEOUT_MS = 5e3;
+var TERMINAL_MAX_PTYS = 20;
+function handleTerminalInput(event, ptyMgr, termLog) {
+  const raw = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
+  if (raw.startsWith(TERMINAL_CONTROL_PREFIX)) {
+    try {
+      const ctrl = JSON.parse(raw.slice(TERMINAL_CONTROL_PREFIX.length));
+      if (ctrl.type === "resize" && typeof ctrl.cols === "number" && typeof ctrl.rows === "number") {
+        ptyMgr.resize(ctrl.cols, ctrl.rows);
+      }
+    } catch {
+      termLog.warn("Invalid control message");
+    }
+  } else {
+    try {
+      ptyMgr.write(raw);
+    } catch {
+    }
+  }
+}
+function sweepDeadPtys(ptys, roomHandle) {
+  let cleaned = 0;
+  for (const [key, pty2] of ptys) {
+    if (!pty2.alive) {
+      pty2.dispose();
+      ptys.delete(key);
+      try {
+        sync(roomHandle).terminalSessions.delete(key);
+      } catch {
+      }
+      cleaned++;
+    }
+  }
+  return cleaned;
+}
 var TERMINAL_STATUSES = new Set(TERMINAL_TASK_STATES);
 async function rehydrateTaskDocuments(roomHandle, roomDoc, repo, log) {
   try {
@@ -45168,7 +46260,7 @@ async function rehydrateTaskDocuments(roomHandle, roomDoc, repo, log) {
         review: reviewHandle
       };
       if (recoverOrphanedTask(taskDocs, createChildLogger({ mode: "rehydrate", taskId }))) {
-        updateTaskInIndex(roomDoc, taskId, { status: "failed", updatedAt: Date.now() });
+        updateTaskInIndex(roomDoc, taskId, { status: "input-required", updatedAt: Date.now() });
       }
       log.debug({ taskId }, "Task documents rehydrated");
     } catch (err) {
@@ -45182,6 +46274,9 @@ async function serve(env) {
     logger.error("SHIPYARD_SIGNALING_URL is required for serve mode");
     process.exit(1);
   }
+  if (!env.SHIPYARD_USER_ID) {
+    throw new Error("SHIPYARD_USER_ID is required. Run `shipyard login` first.");
+  }
   const log = createChildLogger({ mode: "serve" });
   if (env.SHIPYARD_USER_TOKEN && env.SHIPYARD_SIGNALING_URL) {
     const client = new SignalingClient(env.SHIPYARD_SIGNALING_URL);
@@ -45200,7 +46295,7 @@ async function serve(env) {
   }
   const lifecycle = new LifecycleManager();
   await lifecycle.acquirePidFile(getShipyardHome());
-  const handle = await createSignalingHandle(env, log);
+  const handle = await createSignalingHandle(env, log, getShipyardHome());
   if (!handle) {
     logger.error("SHIPYARD_SIGNALING_URL is required for serve mode");
     process.exit(1);
@@ -45223,6 +46318,8 @@ async function serve(env) {
   });
   const keepAwakeManager = new KeepAwakeManager(log);
   const terminalPtys = /* @__PURE__ */ new Map();
+  const FILE_MAX_SIZE = 2e5;
+  const collabRoomManager = createCollabRoomManager();
   const peerManager = createPeerManager({
     webrtcAdapter,
     onAnswer(targetMachineId, answer) {
@@ -45239,22 +46336,144 @@ async function serve(env) {
         candidate
       });
     },
-    onTerminalChannel(fromMachineId, rawChannel, taskId) {
+    onTerminalChannel(fromMachineId, rawChannel, taskId, terminalId) {
       const channel = rawChannel;
-      const terminalKey = `${fromMachineId}:${taskId}`;
-      const termLog = createChildLogger({ mode: `terminal:${fromMachineId}:${taskId}` });
+      const terminalKey = `${fromMachineId}:${taskId}:${terminalId}`;
+      const termLog = createChildLogger({
+        mode: `terminal:${fromMachineId}:${taskId}:${terminalId}`
+      });
+      function publishTerminalSession(cwd, status, exitCode3) {
+        try {
+          sync(roomHandle).terminalSessions.set(terminalKey, {
+            terminalId,
+            taskId,
+            machineId,
+            cwd,
+            status,
+            exitCode: exitCode3,
+            createdAt: Date.now()
+          });
+        } catch {
+          termLog.warn("Failed to publish terminal session to ephemeral");
+        }
+      }
+      function deleteTerminalSession() {
+        try {
+          sync(roomHandle).terminalSessions.delete(terminalKey);
+        } catch {
+        }
+      }
       const existingPty = terminalPtys.get(terminalKey);
-      if (existingPty) {
-        termLog.info("Disposing existing PTY for reconnecting machine");
+      if (existingPty?.alive) {
+        termLog.info({ pid: existingPty.pid }, "Reattaching channel to existing PTY");
+        const buf2 = createChannelBuffer(channel, {
+          maxBytes: TERMINAL_BUFFER_MAX_BYTES,
+          logPrefix: `terminal-reattach:${taskId}`
+        });
+        const openTimeout2 = setTimeout(() => {
+          if (!buf2.isOpen) {
+            termLog.warn("Reattach channel did not open within timeout");
+            existingPty.setDataSink(null);
+            existingPty.setExitSink(null);
+            if (channel.readyState !== "closed") channel.close();
+          }
+        }, TERMINAL_OPEN_TIMEOUT_MS);
+        const scrollbackSnapshot = existingPty.getScrollback();
+        const dcAsEventTarget2 = rawChannel;
+        dcAsEventTarget2.addEventListener("open", () => {
+          termLog.info("Reattach channel open, replaying scrollback");
+          buf2.markOpen();
+          clearTimeout(openTimeout2);
+          if (scrollbackSnapshot) {
+            buf2.sendOrBuffer(scrollbackSnapshot);
+          }
+          buf2.flush();
+        });
+        existingPty.setDataSink((data) => buf2.sendOrBuffer(data));
+        const existingCwd = (() => {
+          try {
+            const all = sync(roomHandle).terminalSessions.getAll();
+            return all.get(terminalKey)?.cwd ?? "";
+          } catch {
+            return "";
+          }
+        })();
+        existingPty.setExitSink((exitCode3, signal) => {
+          termLog.info({ exitCode: exitCode3, signal }, "PTY exited (reattached)");
+          publishTerminalSession(existingCwd, "exited", exitCode3);
+          if (buf2.isOpen) {
+            buf2.sendOrBuffer(
+              TERMINAL_CONTROL_PREFIX + JSON.stringify({ type: "exited", exitCode: exitCode3, signal })
+            );
+          }
+        });
+        channel.onmessage = (event) => {
+          handleTerminalInput(event, existingPty, termLog);
+        };
+        channel.onclose = () => {
+          termLog.info("Reattached channel closed, detaching sink (PTY persists)");
+          buf2.reset();
+          clearTimeout(openTimeout2);
+          existingPty.setDataSink(null);
+          existingPty.setExitSink((exitCode3, signal) => {
+            termLog.info({ exitCode: exitCode3, signal }, "PTY exited while detached (reattach)");
+            publishTerminalSession(existingCwd, "exited", exitCode3);
+          });
+        };
+        return;
+      }
+      if (existingPty && !existingPty.alive) {
+        termLog.info("Cleaning up exited PTY for key");
         existingPty.dispose();
         terminalPtys.delete(terminalKey);
+        deleteTerminalSession();
+      }
+      if (terminalPtys.size >= TERMINAL_MAX_PTYS) {
+        sweepDeadPtys(terminalPtys, roomHandle);
+      }
+      if (terminalPtys.size >= TERMINAL_MAX_PTYS) {
+        termLog.info(
+          { limit: TERMINAL_MAX_PTYS, current: terminalPtys.size },
+          "PTY limit reached, rejecting channel"
+        );
+        const reject = () => {
+          try {
+            channel.send(
+              TERMINAL_CONTROL_PREFIX + JSON.stringify({ type: "error", reason: "pty_limit_reached" })
+            );
+          } catch {
+          }
+          channel.close();
+        };
+        if (channel.readyState === "open") {
+          reject();
+        } else {
+          const dcTarget = rawChannel;
+          const rejectTimer = setTimeout(() => {
+            if (channel.readyState !== "open" && channel.readyState !== "closed") {
+              channel.close();
+            }
+          }, TERMINAL_OPEN_TIMEOUT_MS);
+          dcTarget.addEventListener(
+            "open",
+            () => {
+              clearTimeout(rejectTimer);
+              reject();
+            },
+            { once: true }
+          );
+        }
+        return;
       }
       const ptyManager = createPtyManager();
       terminalPtys.set(terminalKey, ptyManager);
       let ptySpawned = false;
-      let channelOpen = channel.readyState === "open";
-      const pendingBuffer = [];
-      let pendingBufferBytes = 0;
+      let terminalCwd = "";
+      const buf = createChannelBuffer(channel, {
+        maxBytes: TERMINAL_BUFFER_MAX_BYTES,
+        logPrefix: `terminal-new:${taskId}`,
+        onOverflow: () => disposeAndClose("Pending buffer exceeded max size")
+      });
       const preSpawnInputBuffer = [];
       function disposeAndClose(reason) {
         termLog.warn({ reason }, "Disposing terminal");
@@ -45262,51 +46481,36 @@ async function serve(env) {
         clearTimeout(cwdTimeout);
         ptyManager.dispose();
         terminalPtys.delete(terminalKey);
+        deleteTerminalSession();
         if (channel.readyState === "open") {
           channel.close();
         }
       }
-      function flushPendingBuffer() {
-        for (const chunk of pendingBuffer) {
-          try {
-            channel.send(chunk);
-          } catch {
-          }
-        }
-        pendingBuffer.length = 0;
-        pendingBufferBytes = 0;
-      }
-      function sendOrBuffer(data) {
-        if (channelOpen) {
-          try {
-            channel.send(data);
-          } catch {
-          }
-        } else {
-          const byteLen = Buffer.byteLength(data);
-          if (pendingBufferBytes + byteLen > TERMINAL_BUFFER_MAX_BYTES) {
-            disposeAndClose("Pending buffer exceeded max size");
-            return;
-          }
-          pendingBuffer.push(data);
-          pendingBufferBytes += byteLen;
-        }
-      }
       const openTimeout = setTimeout(() => {
-        if (!channelOpen) {
+        if (!buf.isOpen) {
           disposeAndClose("Data channel did not open within timeout");
         }
       }, TERMINAL_OPEN_TIMEOUT_MS);
       const dcAsEventTarget = rawChannel;
       dcAsEventTarget.addEventListener("open", () => {
         termLog.info("Terminal data channel now open, flushing buffered output");
-        channelOpen = true;
+        buf.markOpen();
         clearTimeout(openTimeout);
-        flushPendingBuffer();
+        buf.flush();
       });
+      function validateCwd(path) {
+        try {
+          if (!existsSync(path)) return null;
+          if (!statSync(path).isDirectory()) return null;
+          return path;
+        } catch {
+          return null;
+        }
+      }
       function spawnPty(cwd) {
         if (ptySpawned) return;
         ptySpawned = true;
+        terminalCwd = cwd;
         clearTimeout(cwdTimeout);
         try {
           ptyManager.spawn({ cwd });
@@ -45316,15 +46520,16 @@ async function serve(env) {
           terminalPtys.delete(terminalKey);
           return;
         }
-        ptyManager.onData((data) => {
-          sendOrBuffer(data);
-        });
-        ptyManager.onExit((exitCode3, signal) => {
+        publishTerminalSession(cwd, "running", null);
+        ptyManager.setDataSink((data) => buf.sendOrBuffer(data));
+        ptyManager.setExitSink((exitCode3, signal) => {
           termLog.info({ exitCode: exitCode3, signal }, "Terminal PTY exited");
-          if (channel.readyState === "open") {
-            channel.close();
+          publishTerminalSession(cwd, "exited", exitCode3);
+          if (buf.isOpen) {
+            buf.sendOrBuffer(
+              TERMINAL_CONTROL_PREFIX + JSON.stringify({ type: "exited", exitCode: exitCode3, signal })
+            );
           }
-          terminalPtys.delete(terminalKey);
         });
         for (const input of preSpawnInputBuffer) {
           try {
@@ -45334,7 +46539,7 @@ async function serve(env) {
         }
         preSpawnInputBuffer.length = 0;
         termLog.info(
-          { cwd, pid: ptyManager.pid, channelReady: channelOpen },
+          { cwd, pid: ptyManager.pid, channelReady: buf.isOpen },
           "Terminal PTY wired to data channel"
         );
       }
@@ -45349,7 +46554,13 @@ async function serve(env) {
         try {
           const ctrl = JSON.parse(payload);
           if (ctrl.type === "cwd" && typeof ctrl.path === "string") {
-            spawnPty(ctrl.path);
+            const validCwd = validateCwd(ctrl.path);
+            if (validCwd) {
+              spawnPty(validCwd);
+            } else {
+              termLog.warn({ path: ctrl.path }, "Invalid cwd path, falling back to $HOME");
+              spawnPty(process.env.HOME ?? process.cwd());
+            }
           } else if (ctrl.type === "resize" && typeof ctrl.cols === "number" && typeof ctrl.rows === "number" && ptySpawned) {
             ptyManager.resize(ctrl.cols, ctrl.rows);
           }
@@ -45369,25 +46580,73 @@ async function serve(env) {
       }
       channel.onmessage = (event) => {
         const raw = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
-        if (raw.startsWith(CONTROL_PREFIX)) {
-          handleControlMessage(raw.slice(CONTROL_PREFIX.length));
+        if (raw.startsWith(TERMINAL_CONTROL_PREFIX)) {
+          handleControlMessage(raw.slice(TERMINAL_CONTROL_PREFIX.length));
         } else {
           handleDataInput(raw);
         }
       };
       channel.onclose = () => {
-        termLog.info("Terminal data channel closed");
-        channelOpen = false;
+        termLog.info("Terminal data channel closed, detaching sink (PTY persists)");
+        buf.reset();
         clearTimeout(openTimeout);
         clearTimeout(cwdTimeout);
-        ptyManager.dispose();
-        if (terminalPtys.get(terminalKey) === ptyManager) {
-          terminalPtys.delete(terminalKey);
+        ptyManager.setDataSink(null);
+        ptyManager.setExitSink((exitCode3, signal) => {
+          termLog.info({ exitCode: exitCode3, signal }, "PTY exited while detached");
+          publishTerminalSession(terminalCwd, "exited", exitCode3);
+        });
+      };
+    },
+    onFileChannel(_fromMachineId, rawChannel, _channelId) {
+      const channel = rawChannel;
+      const fileLog = createChildLogger({ mode: "file-channel" });
+      const FILE_CHANNEL_BUFFER_MAX_BYTES = 5 * 1024 * 1024;
+      const buf = createChannelBuffer(channel, {
+        maxBytes: FILE_CHANNEL_BUFFER_MAX_BYTES,
+        logPrefix: "file-channel"
+      });
+      if (channel.readyState === "open") {
+        buf.markOpen();
+      } else {
+        const dcAsEventTarget = rawChannel;
+        dcAsEventTarget.addEventListener("open", () => {
+          fileLog.info("File I/O data channel now open");
+          buf.markOpen();
+          buf.flush();
+        });
+      }
+      const bufferedChannel = {
+        send(data) {
+          buf.sendOrBuffer(data);
+        }
+      };
+      channel.onclose = () => {
+        fileLog.info("File I/O channel closed");
+      };
+      channel.onmessage = (event) => {
+        const raw = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
+        try {
+          const msg = parseFileChannelMessage(raw);
+          if (!msg) return;
+          if (msg.type === "read") {
+            handleFileRead(msg.requestId, msg.path, msg.envPath, bufferedChannel).catch((err) => {
+              fileLog.warn({ err }, "Unhandled error in handleFileRead");
+            });
+          } else if (msg.type === "list-dir") {
+            handleListDir(msg.requestId, msg.envPath, bufferedChannel).catch((err) => {
+              fileLog.warn({ err }, "Unhandled error in handleListDir");
+            });
+          } else {
+            assertNever3(msg);
+          }
+        } catch (err) {
+          fileLog.warn({ err }, "File channel message handling failed");
         }
       };
     }
   });
-  const roomDocId = buildDocumentId("room", LOCAL_USER_ID, DEFAULT_EPOCH);
+  const roomDocId = buildRoomDocId(env.SHIPYARD_USER_ID, DEFAULT_EPOCH);
   const roomHandle = repo.get(roomDocId, TaskIndexDocumentSchema, ROOM_EPHEMERAL_DECLARATIONS);
   function publishCapabilities(caps) {
     const value = {
@@ -45410,6 +46669,128 @@ async function serve(env) {
     sync(roomHandle).capabilities.set(machineId, value);
     log.info({ machineId }, "Published capabilities to room ephemeral");
   }
+  async function handleFileRead(requestId, filePath, envPath, channel) {
+    function sendResponse(payload) {
+      try {
+        channel.send(FILE_IO_CONTROL_PREFIX + JSON.stringify(payload));
+      } catch (err) {
+        log.warn(
+          { err, payload: { type: payload.type, requestId: payload.requestId } },
+          "Failed to send file-io response"
+        );
+      }
+    }
+    const workspaceRoot = envPath ?? capabilities.environments[0]?.path ?? process.cwd();
+    const absolutePath = resolve2(workspaceRoot, filePath);
+    const relativePath = relative(workspaceRoot, absolutePath);
+    if (relativePath.startsWith("..") || isAbsolute3(relativePath)) {
+      sendResponse({ type: "error", requestId, path: filePath, error: "Path traversal denied" });
+      return;
+    }
+    try {
+      const fileStat = await stat2(absolutePath);
+      if (fileStat.size > FILE_MAX_SIZE) {
+        sendResponse({
+          type: "error",
+          requestId,
+          path: filePath,
+          error: `File too large (${(fileStat.size / 1024).toFixed(0)}KB, limit 200KB)`
+        });
+        return;
+      }
+      const buffer = await readFile5(absolutePath);
+      if (buffer.subarray(0, 8192).includes(0)) {
+        sendResponse({
+          type: "error",
+          requestId,
+          path: filePath,
+          error: "Binary file \u2014 cannot display"
+        });
+        return;
+      }
+      sendResponse({
+        type: "content",
+        requestId,
+        path: filePath,
+        content: buffer.toString("utf-8")
+      });
+    } catch (err) {
+      sendResponse({
+        type: "error",
+        requestId,
+        path: filePath,
+        error: `Read failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async function handleListDir(requestId, envPath, channel) {
+    function sendResponse(payload) {
+      try {
+        channel.send(FILE_IO_CONTROL_PREFIX + JSON.stringify(payload));
+      } catch (err) {
+        log.warn(
+          { err, payload: { type: payload.type, requestId: payload.requestId } },
+          "Failed to send file-io response"
+        );
+      }
+    }
+    const resolvedPath = envPath ?? capabilities.environments[0]?.path;
+    if (!resolvedPath) {
+      sendResponse({ type: "error", requestId, error: "No environment path" });
+      return;
+    }
+    const validPaths = new Set(capabilities.environments.map((e) => e.path));
+    if (!validPaths.has(resolvedPath)) {
+      sendResponse({ type: "error", requestId, error: "Invalid environment path" });
+      return;
+    }
+    try {
+      const files = await listWorkspaceFiles(resolvedPath);
+      sendDirContentsResponse(requestId, files, channel);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      sendResponse({ type: "error", requestId, error: msg });
+    }
+  }
+  const MAX_CHUNK_FILES = 500;
+  function sendDirContentsResponse(requestId, files, channel) {
+    if (files.length <= MAX_CHUNK_FILES) {
+      const serialized = JSON.stringify({ type: "dir-contents", requestId, files });
+      if (serialized.length > 2e5) {
+        log.debug({ requestId, size: serialized.length }, "dir-contents response exceeds 200KB");
+      }
+      try {
+        channel.send(FILE_IO_CONTROL_PREFIX + serialized);
+      } catch (err) {
+        log.warn(
+          { err, payload: { type: "dir-contents", requestId } },
+          "Failed to send file-io response"
+        );
+      }
+      return;
+    }
+    const totalChunks = Math.ceil(files.length / MAX_CHUNK_FILES);
+    log.debug(
+      { requestId, fileCount: files.length, totalChunks },
+      "Chunking dir-contents response"
+    );
+    for (let i = 0; i < totalChunks; i++) {
+      const chunk = files.slice(i * MAX_CHUNK_FILES, (i + 1) * MAX_CHUNK_FILES);
+      const serialized = JSON.stringify({
+        type: "dir-contents-chunk",
+        requestId,
+        files: chunk,
+        chunkIndex: i,
+        totalChunks
+      });
+      try {
+        channel.send(FILE_IO_CONTROL_PREFIX + serialized);
+      } catch (err) {
+        log.warn({ requestId, chunkIndex: i, err }, "Failed to send dir-contents chunk");
+        break;
+      }
+    }
+  }
   publishCapabilities(capabilities);
   const branchWatcher = createBranchWatcher({
     environments: capabilities.environments,
@@ -45431,6 +46812,7 @@ async function serve(env) {
       keepAwakeManager.update(keepAwakeEnabled, activeTasks.size > 0);
     }
   });
+  keepAwakeManager.update(keepAwakeEnabled, activeTasks.size > 0);
   sync(typedRoomHandle).enhancePromptReqs.subscribe(({ key: requestId, value, source }) => {
     if (source !== "remote") return;
     if (!value) return;
@@ -45588,7 +46970,10 @@ async function serve(env) {
     });
   });
   connection.onStateChange((state) => {
-    log.info({ state }, "Connection state changed");
+    log.info(
+      { state, activeTaskCount: activeTasks.size, activeTasks: [...activeTasks.keys()] },
+      "Signaling connection state changed"
+    );
   });
   const dispatchingTasks = /* @__PURE__ */ new Set();
   connection.onMessage((msg) => {
@@ -45612,10 +46997,19 @@ async function serve(env) {
       publishCapabilities,
       branchWatcher,
       keepAwakeManager,
-      getKeepAwakeEnabled: () => keepAwakeEnabled
+      getKeepAwakeEnabled: () => keepAwakeEnabled,
+      collabRoomManager,
+      webrtcAdapter
     });
   });
   connection.connect();
+  const DEAD_PTY_SWEEP_MS = 3e4;
+  const deadPtySweep = setInterval(() => {
+    const cleaned = sweepDeadPtys(terminalPtys, roomHandle);
+    if (cleaned > 0) {
+      log.info({ cleaned, remaining: terminalPtys.size }, "Dead PTY sweep completed");
+    }
+  }, DEAD_PTY_SWEEP_MS);
   log.info("Daemon running in serve mode, waiting for tasks...");
   lifecycle.onShutdown(async () => {
     log.info("Shutting down serve mode...");
@@ -45628,14 +47022,8 @@ async function serve(env) {
     }
     activeTasks.clear();
     dispatchingTasks.clear();
-    for (const timer of diffDebounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    diffDebounceTimers.clear();
-    for (const timer of branchDiffTimers.values()) {
-      clearTimeout(timer);
-    }
-    branchDiffTimers.clear();
+    clearAllTimers(diffDebounceTimers, branchDiffTimers, prPollTimers);
+    prPollLastActivity.clear();
     for (const unsub of watchedTasks.values()) {
       unsub();
     }
@@ -45644,10 +47032,16 @@ async function serve(env) {
     lastProcessedConvLen.clear();
     for (const timer of pendingCleanupTimers) clearTimeout(timer);
     pendingCleanupTimers.clear();
+    clearInterval(deadPtySweep);
     for (const [id, ptyMgr] of terminalPtys) {
       ptyMgr.dispose();
-      terminalPtys.delete(id);
+      try {
+        sync(roomHandle).terminalSessions.delete(id);
+      } catch {
+      }
     }
+    terminalPtys.clear();
+    collabRoomManager.destroy();
     peerManager.destroy();
     signaling.unregister();
     await new Promise((resolve4) => setTimeout(resolve4, 200));
@@ -45660,8 +47054,12 @@ async function serve(env) {
 }
 var DIFF_DEBOUNCE_MS = 2e3;
 var BRANCH_DIFF_DEBOUNCE_MS = 1e4;
+var PR_POLL_INTERVAL_MS = 3e4;
+var PR_POLL_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
 var diffDebounceTimers = /* @__PURE__ */ new Map();
 var branchDiffTimers = /* @__PURE__ */ new Map();
+var prPollTimers = /* @__PURE__ */ new Map();
+var prPollLastActivity = /* @__PURE__ */ new Map();
 function debouncedDiffCapture(taskId, cwd, taskHandle, log) {
   const existing = diffDebounceTimers.get(taskId);
   if (existing) clearTimeout(existing);
@@ -45732,6 +47130,100 @@ async function captureBranchDiffState(cwd, taskHandle, log) {
   });
   log.debug({ baseBranch, fileCount: branchFiles.length }, "Branch diff state captured");
 }
+async function capturePRState(cwd, taskHandle, log) {
+  const available = await isGhAvailable();
+  change(taskHandle.conv, (draft) => {
+    draft.diffState.prAvailable.set(available);
+  });
+  if (!available) return;
+  const [currentPR, assignedReviews, userPRs] = await Promise.allSettled([
+    getPRForCurrentBranch(cwd),
+    getAssignedReviews(cwd),
+    getUserPRs(cwd)
+  ]);
+  const allPRs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const currentBranchPR = currentPR.status === "fulfilled" ? currentPR.value : null;
+  if (currentBranchPR) {
+    allPRs.push(currentBranchPR);
+    seen.add(currentBranchPR.number);
+  }
+  for (const pr of assignedReviews.status === "fulfilled" ? assignedReviews.value : []) {
+    if (!seen.has(pr.number)) {
+      allPRs.push(pr);
+      seen.add(pr.number);
+    }
+  }
+  for (const pr of userPRs.status === "fulfilled" ? userPRs.value : []) {
+    if (!seen.has(pr.number)) {
+      allPRs.push(pr);
+      seen.add(pr.number);
+    }
+  }
+  let prDiff = "";
+  let prFiles = [];
+  if (currentBranchPR) {
+    [prDiff, prFiles] = await Promise.all([
+      getPRDiff(cwd, currentBranchPR.number),
+      getPRFiles(cwd, currentBranchPR.number)
+    ]);
+  }
+  change(taskHandle.conv, (draft) => {
+    draft.diffState.currentBranchPRNumber.set(currentBranchPR?.number ?? 0);
+    draft.diffState.prData.set(allPRs);
+    draft.diffState.prDiff.set(prDiff);
+    const fileList = draft.diffState.prFiles;
+    if (fileList.length > 0) {
+      fileList.delete(0, fileList.length);
+    }
+    for (const file of prFiles) {
+      fileList.push(file);
+    }
+    draft.diffState.prUpdatedAt.set(Date.now());
+  });
+  log.debug({ prCount: allPRs.length, hasBranchPR: !!currentBranchPR }, "PR state captured");
+}
+function getLatestCwd(taskHandle) {
+  const convJson = taskHandle.conv.toJSON();
+  const lastUserMsg = [...convJson.conversation].reverse().find((m) => m.role === "user");
+  return lastUserMsg?.cwd ?? process.cwd();
+}
+function refreshPRPoll(taskId, taskHandle, taskLog) {
+  const cwd = getLatestCwd(taskHandle);
+  prPollLastActivity.set(taskId, Date.now());
+  capturePRState(cwd, taskHandle, taskLog).catch((err) => {
+    taskLog.warn({ err }, "PR refresh on re-notify failed");
+  });
+  if (!prPollTimers.has(taskId)) {
+    const convHandle = taskHandle.conv;
+    const initialCwd = cwd;
+    prPollTimers.set(
+      taskId,
+      setInterval(() => {
+        try {
+          const lastActivity = prPollLastActivity.get(taskId) ?? 0;
+          if (Date.now() - lastActivity > PR_POLL_IDLE_TIMEOUT_MS) {
+            const timer = prPollTimers.get(taskId);
+            if (timer) clearInterval(timer);
+            prPollTimers.delete(taskId);
+            prPollLastActivity.delete(taskId);
+            taskLog.info("PR poll stopped after idle timeout");
+            return;
+          }
+          const convJson = convHandle.toJSON();
+          const latestUserMsg = [...convJson.conversation].reverse().find((m) => m.role === "user");
+          const pollCwd = latestUserMsg?.cwd ?? initialCwd;
+          capturePRState(pollCwd, taskHandle, taskLog).catch((err) => {
+            taskLog.warn({ err }, "PR poll failed");
+          });
+        } catch (err) {
+          taskLog.warn({ err }, "PR poll tick failed");
+        }
+      }, PR_POLL_INTERVAL_MS)
+    );
+    taskLog.info("PR poll timer restarted after idle");
+  }
+}
 async function captureTurnDiff(cwd, turnStartRef, taskHandle, log) {
   const turnEndRef = await captureTreeSnapshot(cwd);
   if (!turnStartRef || !turnEndRef) {
@@ -45817,21 +47309,55 @@ function handleMessage(msg, ctx) {
       ctx.log.debug({ type: msg.type }, "Worktree create echo");
       break;
     case "cancel-task":
+      ctx.log.info(
+        { taskId: msg.taskId, requestId: msg.requestId, machineId: msg.machineId },
+        "Received cancel-task from browser"
+      );
       handleCancelTask(msg, ctx);
       break;
     case "control-ack":
       ctx.log.debug({ type: msg.type }, "Control ack echo");
       break;
     case "authenticated":
+      ctx.log.info({ type: msg.type }, "Server notification: authenticated");
+      break;
     case "agent-joined":
     case "agent-left":
     case "agent-status-changed":
+      ctx.log.info({ type: msg.type }, "Server notification: agent change");
+      break;
     case "error":
-      ctx.log.debug({ type: msg.type }, "Server notification");
+      ctx.log.warn({ type: msg.type, code: msg.code, message: msg.message }, "Server error");
+      break;
+    case "notify-collab-room":
+      handleNotifyCollabRoom(msg, ctx);
       break;
     default:
-      assertNever2(msg);
+      assertNever3(msg);
+  }
+}
+function handleNotifyCollabRoom(msg, ctx) {
+  const collabLog = createChildLogger({ mode: `collab:${msg.roomId}`, taskId: msg.taskId });
+  if (!ctx.env.SHIPYARD_SIGNALING_URL) {
+    collabLog.warn("No signaling URL configured, cannot join collab room");
+    return;
   }
+  if (!ctx.env.SHIPYARD_USER_TOKEN) {
+    collabLog.warn("No user token configured, cannot join collab room");
+    return;
+  }
+  collabLog.info("Joining collab room");
+  ctx.collabRoomManager.join({
+    roomId: msg.roomId,
+    taskId: msg.taskId,
+    token: msg.token,
+    expiresAt: msg.expiresAt,
+    signalingBaseUrl: ctx.env.SHIPYARD_SIGNALING_URL,
+    userToken: ctx.env.SHIPYARD_USER_TOKEN,
+    machineId: ctx.machineId,
+    webrtcAdapter: ctx.webrtcAdapter,
+    log: collabLog
+  });
 }
 function handleNotifyTask(msg, ctx) {
   const { taskId, requestId } = msg;
@@ -45858,6 +47384,7 @@ function handleNotifyTask(msg, ctx) {
     const taskHandle = ctx.taskHandles.get(taskId);
     if (taskHandle) {
       onTaskDocChanged(taskId, taskHandle, taskLog, ctx);
+      refreshPRPoll(taskId, taskHandle, taskLog);
     }
     return;
   }
@@ -45889,7 +47416,7 @@ function handleCancelTask(msg, ctx) {
     });
     return;
   }
-  taskLog.info("Canceling active task");
+  taskLog.info({ requestId, machineId: msg.machineId }, "Canceling active task");
   activeTask.abortController.abort();
   ctx.connection.send({
     type: "control-ack",
@@ -46384,7 +47911,7 @@ async function watchTaskDocument(taskId, taskLog, ctx) {
     review: reviewHandle
   };
   if (recoverOrphanedTask(taskDocs, taskLog)) {
-    updateTaskInIndex(ctx.roomDoc, taskId, { status: "failed", updatedAt: Date.now() });
+    updateTaskInIndex(ctx.roomDoc, taskId, { status: "input-required", updatedAt: Date.now() });
   }
   const convJson = convHandle.toJSON();
   const lastUserMsg = [...convJson.conversation].reverse().find((m) => m.role === "user");
@@ -46392,6 +47919,36 @@ async function watchTaskDocument(taskId, taskLog, ctx) {
   captureBranchDiffState(initialCwd, taskHandle, taskLog).catch((err) => {
     taskLog.warn({ err }, "Failed to capture initial branch diff");
   });
+  capturePRState(initialCwd, taskHandle, taskLog).catch((err) => {
+    taskLog.warn({ err }, "Initial PR capture failed");
+  });
+  const existingPrTimer = prPollTimers.get(taskId);
+  if (existingPrTimer) clearInterval(existingPrTimer);
+  prPollLastActivity.set(taskId, Date.now());
+  prPollTimers.set(
+    taskId,
+    setInterval(() => {
+      try {
+        const lastActivity = prPollLastActivity.get(taskId) ?? 0;
+        if (Date.now() - lastActivity > PR_POLL_IDLE_TIMEOUT_MS) {
+          const timer = prPollTimers.get(taskId);
+          if (timer) clearInterval(timer);
+          prPollTimers.delete(taskId);
+          prPollLastActivity.delete(taskId);
+          taskLog.info("PR poll stopped after idle timeout");
+          return;
+        }
+        const convJson2 = convHandle.toJSON();
+        const latestUserMsg = [...convJson2.conversation].reverse().find((m) => m.role === "user");
+        const cwd = latestUserMsg?.cwd ?? initialCwd;
+        capturePRState(cwd, taskHandle, taskLog).catch((err) => {
+          taskLog.warn({ err }, "PR poll failed");
+        });
+      } catch (err) {
+        taskLog.warn({ err }, "PR poll tick failed");
+      }
+    }, PR_POLL_INTERVAL_MS)
+  );
   const opCountBefore = loro(convHandle).opCount();
   taskLog.info({ convDocId, opCount: opCountBefore }, "Doc state before subscribe");
   const unsubscribe = subscribe(convHandle, (event) => {
@@ -46582,7 +48139,17 @@ function onTaskDocChanged(taskId, taskHandle, taskLog, ctx) {
   };
   const userId = ctx.env.SHIPYARD_USER_ID ?? null;
   const userName = ctx.env.SHIPYARD_USER_DISPLAY_NAME ?? null;
-  const manager = new SessionManager(taskDocs, userId, userName, onStatusChange, onBackgroundAgent);
+  const onTodoProgress = (progress) => {
+    updateTaskInIndex(ctx.roomDoc, taskId, { ...progress, updatedAt: Date.now() });
+  };
+  const manager = new SessionManager(
+    taskDocs,
+    userId,
+    userName,
+    onStatusChange,
+    onBackgroundAgent,
+    onTodoProgress
+  );
   const activeTask = {
     taskId,
     abortController,
@@ -46644,6 +48211,7 @@ async function cleanupTaskRun(opts) {
   abortController.abort();
   clearDebouncedTimer(diffDebounceTimers, taskId);
   clearDebouncedTimer(branchDiffTimers, taskId);
+  prPollLastActivity.set(taskId, Date.now());
   try {
     await captureDiffState(cwd, taskHandle, taskLog);
   } catch (err) {
@@ -46654,6 +48222,11 @@ async function cleanupTaskRun(opts) {
   } catch (err) {
     taskLog.warn({ err }, "Failed to capture final branch diff state");
   }
+  try {
+    await capturePRState(cwd, taskHandle, taskLog);
+  } catch (err) {
+    taskLog.warn({ err }, "Failed to capture final PR state");
+  }
   try {
     const turnStartRef = await turnStartRefPromise;
     await captureTurnDiff(cwd, turnStartRef, taskHandle, taskLog);
@@ -46681,6 +48254,14 @@ function clearDebouncedTimer(timers, taskId) {
     timers.delete(taskId);
   }
 }
+function clearAllTimers(...timerMaps) {
+  for (const timers of timerMaps) {
+    for (const timer of timers.values()) {
+      clearTimeout(timer);
+    }
+    timers.clear();
+  }
+}
 function mapPermissionMode(mode) {
   switch (mode) {
     case "accept-edits":
@@ -47011,6 +48592,16 @@ async function runTask(opts) {
 }
 
 // src/index.ts
+function getVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const pkgPath = resolve3(thisFile, "../../package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
 function parseCliArgs() {
   const { values } = parseArgs({
     options: {
@@ -47021,23 +48612,29 @@ function parseCliArgs() {
       cwd: { type: "string" },
       model: { type: "string", short: "m" },
       serve: { type: "boolean", short: "s" },
+      version: { type: "boolean", short: "v" },
       help: { type: "boolean", short: "h" }
     },
     strict: true
   });
+  if (values.version) {
+    process.stdout.write(`${getVersion()}
+`);
+    process.exit(0);
+  }
   if (values.help) {
     logger.info(
       [
-        "shipyard-daemon - Claude Agent SDK + Loro CRDT sync",
+        `shipyard v${getVersion()} - Agent management hub for human-agent collaboration`,
         "",
         "Usage:",
         "  shipyard login              Authenticate with Shipyard",
         "  shipyard login --check      Check current auth status",
         "  shipyard logout             Clear stored credentials",
         "",
-        '  shipyard-daemon --prompt "Fix the bug in auth.ts" [options]',
-        '  shipyard-daemon --resume <session-id> --task-id <id> [--prompt "Continue"]',
-        "  shipyard-daemon --serve",
+        '  shipyard --prompt "Fix the bug in auth.ts" [options]',
+        '  shipyard --resume <session-id> --task-id <id> [--prompt "Continue"]',
+        "  shipyard --serve",
         "",
         "Options:",
         "  -p, --prompt <text>      Prompt for the agent",
@@ -47047,6 +48644,7 @@ function parseCliArgs() {
         "      --cwd <path>         Working directory for agent",
         "  -m, --model <name>       Model to use",
         "  -s, --serve              Run in serve mode (signaling + spawn-agent)",
+        "  -v, --version            Show version",
         "  -h, --help               Show this help",
         "",
         "Authentication:",
@@ -47077,8 +48675,8 @@ function parseCliArgs() {
     serve: values.serve
   };
 }
-async function setupSignaling(env, log) {
-  const handle = await createSignalingHandle(env, log);
+async function setupSignaling(env, log, shipyardHome) {
+  const handle = await createSignalingHandle(env, log, shipyardHome);
   if (handle) {
     handle.connection.connect();
   }
@@ -47171,13 +48769,13 @@ function handleResult(log, result, startTime) {
 async function handleSubcommand() {
   const subcommand = process.argv[2];
   if (subcommand === "login") {
-    const { loginCommand } = await import("./login-5RRT37UW.js");
+    const { loginCommand } = await import("./login-BS6C2BRS.js");
     const hasCheck = process.argv.includes("--check");
     await loginCommand({ check: hasCheck });
     return true;
   }
   if (subcommand === "logout") {
-    const { logoutCommand } = await import("./logout-NWYPFICH.js");
+    const { logoutCommand } = await import("./logout-XX5ULFHB.js");
     await logoutCommand();
     return true;
   }
@@ -47241,7 +48839,7 @@ async function main() {
   const repo = await setupRepo(dataDir);
   const lifecycle = new LifecycleManager();
   await lifecycle.acquirePidFile(getShipyardHome());
-  const signalingHandle = await setupSignaling(env, log);
+  const signalingHandle = await setupSignaling(env, log, getShipyardHome());
   const cleanup = createCleanup(signalingHandle, lifecycle, repo);
   lifecycle.onShutdown(async () => {
     log.info("Cleaning up...");