@4pm/cli 1.28.0-c → 1.30.0

package/dist/index.js

@@ -11606,7 +11606,7 @@ var require_react_reconciler_development = __commonJS({
           }
         }
         var assign = Object.assign;
-        function get2(key) {
+        function get3(key) {
           return key._reactInternals;
         }
         function set(key, value) {
@@ -11961,7 +11961,7 @@ var require_react_reconciler_development = __commonJS({
               instance._warnedAboutRefsInRender = true;
             }
           }
-          var fiber = get2(component);
+          var fiber = get3(component);
           if (!fiber) {
             return false;
           }
@@ -18301,7 +18301,7 @@ var require_react_reconciler_development = __commonJS({
         var classComponentUpdater = {
           isMounted,
           enqueueSetState: function(inst, payload, callback) {
-            var fiber = get2(inst);
+            var fiber = get3(inst);
             var eventTime = requestEventTime();
             var lane = requestUpdateLane(fiber);
             var update = createUpdate(eventTime, lane);
@@ -18322,7 +18322,7 @@ var require_react_reconciler_development = __commonJS({
             }
           },
           enqueueReplaceState: function(inst, payload, callback) {
-            var fiber = get2(inst);
+            var fiber = get3(inst);
             var eventTime = requestEventTime();
             var lane = requestUpdateLane(fiber);
             var update = createUpdate(eventTime, lane);
@@ -18344,7 +18344,7 @@ var require_react_reconciler_development = __commonJS({
             }
           },
           enqueueForceUpdate: function(inst, callback) {
-            var fiber = get2(inst);
+            var fiber = get3(inst);
             var eventTime = requestEventTime();
             var lane = requestUpdateLane(fiber);
             var update = createUpdate(eventTime, lane);
@@ -26201,7 +26201,7 @@ var require_react_reconciler_development = __commonJS({
           if (!parentComponent) {
             return emptyContextObject;
           }
-          var fiber = get2(parentComponent);
+          var fiber = get3(parentComponent);
           var parentContext = findCurrentUnmaskedContext(fiber);
           if (fiber.tag === ClassComponent) {
             var Component = fiber.type;
@@ -26212,7 +26212,7 @@ var require_react_reconciler_development = __commonJS({
           return parentContext;
         }
         function findHostInstance(component) {
-          var fiber = get2(component);
+          var fiber = get3(component);
           if (fiber === void 0) {
             if (typeof component.render === "function") {
               throw new Error("Unable to find node on an unmounted component.");
@@ -26229,7 +26229,7 @@ var require_react_reconciler_development = __commonJS({
         }
         function findHostInstanceWithWarning(component, methodName) {
           {
-            var fiber = get2(component);
+            var fiber = get3(component);
             if (fiber === void 0) {
               if (typeof component.render === "function") {
                 throw new Error("Unable to find node on an unmounted component.");
@@ -27177,7 +27177,7 @@ var require_stack_utils = __commonJS({
         const evalCol = Number(match[6]);
         let file = match[7];
         const lnum = match[8];
-        const col = match[9];
+        const col2 = match[9];
         const native = match[10] === "native";
         const closeParen = match[11] === ")";
         let method;
@@ -27185,8 +27185,8 @@ var require_stack_utils = __commonJS({
         if (lnum) {
           res.line = Number(lnum);
         }
-        if (col) {
-          res.column = Number(col);
+        if (col2) {
+          res.column = Number(col2);
         }
         if (closeParen && file) {
           let closes = 0;
@@ -28584,8 +28584,30 @@ function normalizeLocale(value) {
 
 // vendor/@4pm/constants/project-template.ts
 var PROJECT_TEMPLATE = {
-  version: "1.0.2",
+  version: "1.1.0",
   changelog: [
+    {
+      version: "1.1.0",
+      date: "2026-09-30",
+      summary: "Multi-worker autonomous books: multi-row AI_PROGRESS claims, QA-gated task Depends, attempts sidecar (ADR-0371).",
+      notes: [
+        "AI_PROGRESS.md holds one row per claimed task: | Started | ID | Worker | Claim | Attempt | Task description | (was a single | Started | ID | Task description | row). Convert an existing single row into the new columns (Worker/Claim empty, Attempt 1).",
+        "AI_TODO.md Depends may list QA-\u2026 ids (the task waits for that USER_QA answer); two or more TSK dependencies require their PRs to be merged into the base branch; Notes may carry size: S|M and from: <branch>.",
+        "USER_QA.md notes that a question raised while implementing a task is listed in that task's Depends.",
+        ".claude/AUTONOMOUS.md documents branches & claims; .claude/.autonomous.attempts.json (per-task attempts / split-pending) is committed with the books \u2014 make sure it is NOT gitignored."
+      ],
+      files: [
+        "AI_PROGRESS.md",
+        "AI_TODO.md",
+        "USER_QA.md",
+        ".claude/AUTONOMOUS.md",
+        ".claude/templates/AI_PROGRESS.empty.md",
+        ".claude/templates/AI_PROGRESS.sample.md",
+        ".claude/templates/AI_TODO.empty.md",
+        ".claude/templates/AI_TODO.sample.md",
+        ".claude/templates/USER_QA.empty.md"
+      ]
+    },
     {
       version: "1.0.2",
       date: "2026-09-16",
@@ -29550,7 +29572,7 @@ async function runLink(serverUrl, explicitProfile, token = null) {
 
 // src/commands/start.ts
 import { spawn as spawn11 } from "child_process";
-import { join as join38 } from "path";
+import { join as join42 } from "path";
 
 // src/core/update.ts
 import { execSync as execSync2 } from "child_process";
@@ -32769,8 +32791,8 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
 // src/core/ws-client.ts
 init_wrapper();
 import { randomUUID as randomUUID4 } from "crypto";
-import { basename as basename7, join as join33 } from "path";
-import { existsSync as existsSync18, mkdirSync as mkdirSync9 } from "fs";
+import { basename as basename7, join as join37 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync9 } from "fs";
 
 // vendor/@4pm/utils/helpers.ts
 function backoffJitterMs(attempt, baseMs = 500, maxMs = 1e4) {
@@ -37058,6 +37080,16 @@ var putGitCredentialRequestSchema = external_exports.object({
     ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["host"], message: "host is required for GitHub Enterprise" });
   }
 });
+function parseRepoUrl(url) {
+  const raw = url.trim();
+  const scp = /^[\w.-]+@([^:/\s]+):([^/\s]+)\/(.+?)(?:\.git)?\/?$/.exec(raw);
+  if (scp) return { protocol: "ssh", host: scp[1].toLowerCase(), owner: scp[2], name: scp[3] };
+  const std = /^(https?|ssh):\/\/(?:[^@/\s]+@)?([^/\s]+)\/([^/\s]+)\/(.+?)(?:\.git)?\/?$/.exec(raw);
+  if (std) {
+    return { protocol: std[1], host: std[2].toLowerCase(), owner: std[3], name: std[4] };
+  }
+  return null;
+}
 function githubHostKind(host) {
   const h = host.toLowerCase();
   if (h === "github.com") return "github";
@@ -37492,7 +37524,30 @@ var repoSpecSchema = external_exports.object({
    * worker clones with `-b <branch>` and the on-demand "update repos" action checks it out +
    * fast-forward pulls it.
    */
-  branch: external_exports.string().max(200).optional().default("")
+  branch: external_exports.string().max(200).optional().default(""),
+  /**
+   * Where `branch` is created from when it does not exist on the remote yet (ADR-0370): the default
+   * branch, another remote branch (`branch`, primary only), or `empty` — an orphan branch with no
+   * history. Absent ⇒ `default`.
+   */
+  base: external_exports.object({
+    kind: external_exports.enum(["default", "branch", "empty"]),
+    branch: external_exports.string().max(200).optional()
+  }).optional(),
+  /**
+   * Primary only (ADR-0370): reset the 4PM tracking files (AI_TODO / AI_DONE / AI_PROGRESS / USER_TODO /
+   * USER_QA) to the template's empty versions after the scaffold copy. Absent ⇒ reset only when the
+   * source already has a 4PM scaffold.
+   */
+  resetTracking: external_exports.boolean().optional()
+});
+var SCAFFOLD_TRACKING_FILES = ["AI_TODO.md", "AI_DONE.md", "AI_PROGRESS.md", "USER_TODO.md", "USER_QA.md"];
+var repoProbeRequestSchema = external_exports.object({
+  url: external_exports.string().max(500).regex(GIT_URL_RE, "must be an https or ssh git url"),
+  branch: external_exports.string().max(200).optional().default(""),
+  base: external_exports.object({ kind: external_exports.enum(["default", "branch", "empty"]), branch: external_exports.string().max(200).optional() }).optional(),
+  /** The declared submodules to probe too — existence + protection (ADR-0371). */
+  submodules: external_exports.array(external_exports.object({ subdir: external_exports.string().max(120), url: external_exports.string().max(500), branch: external_exports.string().max(200).optional().default("") })).max(20).optional()
 });
 function validateProjectRepos(repos, ctx, path = ["repos"]) {
   const list = repos ?? [];
@@ -37651,7 +37706,7 @@ var userCardsQuerySchema = external_exports.object({
 });
 
 // src/core/scaffold.ts
-import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { cp, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { execFile } from "child_process";
 import { tmpdir as tmpdir2 } from "os";
@@ -37670,65 +37725,82 @@ function submodulesOf(repos) {
   const primary = singleRepo(repos);
   return repos.filter((r) => r !== primary && !!r.url && !!(r.subdir ?? "").trim());
 }
-async function attachSubmodules(root, submodules, emit, createMissingBranch = false) {
-  if (submodules.length === 0) return;
-  if (!existsSync4(join6(root, ".git"))) return;
+async function isRegisteredSubmodule(root, dir2) {
+  if (existsSync4(join6(root, ".gitmodules"))) {
+    const paths = await gitOut(root, ["config", "-f", ".gitmodules", "--get-regexp", "^submodule\\..*\\.path$"]);
+    if (paths.split("\n").some((l) => l.split(" ").slice(1).join(" ") === dir2)) return true;
+  }
+  const staged = await gitOut(root, ["ls-files", "--stage", "--", dir2]);
+  return staged.split("\n").some((l) => l.startsWith("160000 "));
+}
+async function listFiles(abs, rel = "") {
+  const out = [];
+  for (const e of await readdir(join6(abs, rel), { withFileTypes: true }).catch(() => [])) {
+    if (e.name === ".git") continue;
+    const r = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isDirectory()) out.push(...await listFiles(abs, r));
+    else out.push(r);
+  }
+  return out;
+}
+async function prepareSubmodulePath(root, dir2, emit) {
+  const abs = join6(root, dir2);
+  const tracked = (await gitOut(root, ["ls-files", "--", dir2])).split("\n").filter(Boolean);
+  const onDisk = existsSync4(abs) ? await listFiles(abs) : [];
+  const trackedRel = new Set(tracked.map((f2) => f2.slice(dir2.length + 1)));
+  const foreign = onDisk.filter((f2) => !trackedRel.has(f2) && !f2.endsWith(".gitkeep"));
+  if (foreign.length > 0) {
+    throw new Error(`"${dir2}" already holds ${foreign.length} file(s) that are not part of the repo (e.g. ${foreign[0]}) \u2014 move them away, then retry.`);
+  }
+  if (tracked.length > 0) {
+    emit("submodule", `Untracking the placeholder files in ${dir2}\u2026`);
+    await run("git", ["rm", "-r", "-q", "--cached", "--", dir2], { cwd: root, timeout: 3e4 });
+  }
+  const modules = join6(root, ".git", "modules", dir2);
+  if (existsSync4(modules)) {
+    emit("submodule", `Cleaning up a half-attached ${dir2}\u2026`);
+    await rm(modules, { recursive: true, force: true });
+  }
+  if (existsSync4(abs)) await rm(abs, { recursive: true, force: true });
+}
+async function attachSubmodules(root, submodules, emit, opts = {}) {
+  const outcomes = [];
+  if (submodules.length === 0) return outcomes;
+  if (!existsSync4(join6(root, ".git"))) return outcomes;
   let added = 0;
   for (const sub of submodules) {
     const dir2 = (sub.subdir ?? "").trim();
     if (!dir2 || !sub.url) continue;
-    if (existsSync4(join6(root, dir2, ".git")) || existsSync4(join6(root, ".git", "modules", dir2))) {
-      emit("submodule", `Submodule ${dir2} already present \u2014 updating\u2026`);
-      try {
+    const b2 = (sub.branch ?? "").trim();
+    try {
+      if (await isRegisteredSubmodule(root, dir2)) {
+        emit("submodule", `Submodule ${dir2} already registered \u2014 updating\u2026`);
         await run("git", ["submodule", "update", "--init", "--", dir2], { cwd: root, timeout: 12e4 });
-      } catch {
+        outcomes.push({ dir: dir2, ok: true, error: null });
+        continue;
       }
-      continue;
-    }
-    const abs = join6(root, dir2);
-    if (existsSync4(abs)) {
-      emit("submodule", `Removing placeholder ${dir2} before attaching the submodule\u2026`);
-      await rm(abs, { recursive: true, force: true });
-    }
-    emit("submodule", `Adding submodule ${sub.url} \u2192 ${dir2}\u2026`);
-    const b2 = (sub.branch ?? "").trim();
-    if (b2 && createMissingBranch && !await ensureRemoteBranch(sub.url, b2, emit)) {
-      try {
-        await run("git", ["submodule", "add", sub.url, dir2], { cwd: root, timeout: 12e4 });
+      await prepareSubmodulePath(root, dir2, emit);
+      emit("submodule", `Adding submodule ${sub.url} \u2192 ${dir2}\u2026`);
+      const base = { kind: opts.base?.kind === "empty" ? "empty" : "default" };
+      const branchReady = !b2 || await remoteHasBranch(sub.url, b2) || !!opts.createMissingBranch && await ensureRemoteBranch(sub.url, b2, emit, base);
+      if (branchReady) {
+        await run("git", ["submodule", "add", ...b2 ? ["-b", b2] : [], sub.url, dir2], { cwd: root, timeout: 18e4 });
+      } else {
+        await run("git", ["submodule", "add", sub.url, dir2], { cwd: root, timeout: 18e4 });
         await run("git", ["config", "-f", ".gitmodules", `submodule.${dir2}.branch`, b2], { cwd: root, timeout: 3e4 });
-        try {
-          await run("git", ["checkout", "-b", b2], { cwd: join6(root, dir2), timeout: 3e4 });
-          await run("git", ["push", "-u", "origin", b2], { cwd: join6(root, dir2), timeout: 12e4 });
-        } catch (pushErr) {
-          const pmsg = pushErr instanceof Error ? pushErr.message : String(pushErr);
-          emit("git-branch-push-failed", `Submodule ${dir2}: branch "${b2}" created locally but the push failed: ${pmsg}`);
-        }
-        added++;
-        continue;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (!/already exists|already registered|in the index/i.test(msg)) {
-          throw new Error(`git submodule add ${dir2} failed: ${msg}`);
-        }
+        await run("git", ["checkout", "-b", b2], { cwd: join6(root, dir2), timeout: 3e4 });
+        emit("git-branch-push-failed", `Submodule ${dir2}: branch "${b2}" created locally only \u2014 push it when credentials are available.`);
       }
-    }
-    try {
-      await run("git", ["submodule", "add", ...b2 ? ["-b", b2] : [], sub.url, dir2], { cwd: root, timeout: 12e4 });
       added++;
+      outcomes.push({ dir: dir2, ok: true, error: null });
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      if (/already exists|already registered|in the index/i.test(msg)) {
-        try {
-          await run("git", ["submodule", "update", "--init", "--", dir2], { cwd: root, timeout: 12e4 });
-          added++;
-        } catch {
-        }
-      } else {
-        throw new Error(`git submodule add ${dir2} failed: ${msg}`);
-      }
+      const msg = errText(err);
+      emit("submodule-failed", `Submodule ${dir2} was not attached: ${msg}`);
+      outcomes.push({ dir: dir2, ok: false, error: msg });
     }
   }
-  if (added > 0) await commitAndPushSubmodules(root, submodules, emit);
+  if (added > 0 && opts.commit) await commitAndPushSubmodules(root, submodules, emit);
+  return outcomes;
 }
 async function commitAndPushSubmodules(root, submodules, emit) {
   const dirs = submodules.map((s3) => (s3.subdir ?? "").trim()).filter(Boolean);
@@ -37749,17 +37821,11 @@ async function commitAndPushSubmodules(root, submodules, emit) {
   }
   emit("submodule", "Pushing .gitmodules to the primary remote\u2026");
   try {
-    await run("git", ["push"], { cwd: root, timeout: 12e4 });
+    await run("git", ["push", "-u", "origin", "HEAD"], { cwd: root, timeout: 12e4 });
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    emit("submodule-push-failed", `Submodules committed locally but the push failed: ${msg}`);
+    emit("submodule-push-failed", `Submodules committed locally but the push failed: ${errText(err)}`);
   }
 }
-function providerSlug(url) {
-  const provider = /github\.com/i.test(url) ? "gh" : /gitlab\.com/i.test(url) ? "glab" : null;
-  const m2 = /(?:github|gitlab)\.com[/:]+([^/]+\/.+?)(?:\.git)?\/?$/i.exec(url);
-  return { provider, slug: m2?.[1] ?? "" };
-}
 function errText(err) {
   const e = err;
   const raw = (e?.stderr || e?.message || String(err)).trim();
@@ -37772,7 +37838,7 @@ async function gitOut(cwd2, args) {
     return "";
   }
 }
-async function commitAndOpenPr(root, repo, emit) {
+async function commitAndPush(root, repo, emit) {
   const result = { committed: false, pushed: false, branch: null, prUrl: null, step: null, error: null };
   const fail = (step, error) => {
     result.step = step;
@@ -37803,54 +37869,36 @@ async function commitAndOpenPr(root, repo, emit) {
   const head = await gitOut(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
   const branch = declared || (head && head !== "HEAD" ? head : "");
   result.branch = branch || null;
-  emit("push", "Pushing the scaffold branch\u2026");
+  emit("push", `Pushing the scaffold to ${branch || "the current branch"}\u2026`);
   try {
     await run("git", ["push", "-u", "origin", branch || "HEAD"], { cwd: root, timeout: 12e4 });
     result.pushed = true;
+    emit("push", `Pushed to ${branch || "the current branch"}.`);
   } catch (err) {
     const msg = errText(err);
     emit("push-failed", `Scaffold committed locally but the push failed: ${msg} \u2014 retry from the project page when credentials are available.`);
     return fail("push", msg);
   }
-  const remoteHead = (await gitOut(root, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"])).replace(/^origin\//, "");
-  if (branch && remoteHead && branch === remoteHead) {
-    emit("pr", `Pushed to the default branch (${branch}) \u2014 no pull request needed.`);
-    return result;
-  }
-  const url = (repo.url ?? "").trim() || await gitOut(root, ["remote", "get-url", "origin"]);
-  const { provider, slug } = providerSlug(url);
-  if (!provider) {
-    emit("pr", "Unknown git host \u2014 skipping the pull request.");
-    return result;
-  }
-  emit("pr", `Opening a pull request via ${provider}\u2026`);
-  try {
-    const args = provider === "glab" ? ["mr", "create", "--fill", "--yes", ...branch ? ["--source-branch", branch] : [], ...slug ? ["-R", slug] : []] : ["pr", "create", "--fill", ...branch ? ["--head", branch] : [], ...slug ? ["-R", slug] : []];
-    const { stdout } = await run(provider, args, { cwd: root, timeout: 12e4 });
-    const link2 = stdout.trim().split(/\s+/).find((x) => /^https?:\/\//.test(x)) ?? null;
-    result.prUrl = link2;
-    emit("pr", `Pull request opened${link2 ? `: ${link2}` : "."}`);
-    return result;
-  } catch (err) {
-    const msg = errText(err);
-    const existing = /already exists/i.test(msg) ? msg.match(/https?:\/\/\S+/)?.[0] ?? null : null;
-    if (existing) {
-      result.prUrl = existing;
-      emit("pr", `A pull request is already open: ${existing}`);
-      return result;
-    }
-    emit("pr-failed", `Could not open a pull request (${provider}): ${msg}`);
-    return fail("pr", msg);
-  }
+  return result;
 }
 async function publishScaffold(root, emit) {
-  let repo = {};
+  let repos = [];
   try {
     const spec = JSON.parse(await readFile(join6(root, "project.spec.json"), "utf8"));
-    repo = singleRepo(reposOf(spec)) ?? {};
+    repos = reposOf(spec);
   } catch {
   }
-  return commitAndOpenPr(root, repo, emit);
+  const repo = singleRepo(repos) ?? {};
+  const submodules = await attachSubmodules(root, submodulesOf(repos), emit, { createMissingBranch: true, base: repo.base });
+  return withSubmodules(await commitAndPush(root, repo, emit), submodules);
+}
+function withSubmodules(publish, submodules) {
+  const failed = submodules.filter((x) => !x.ok);
+  if (failed.length > 0 && !publish.step) {
+    publish.step = "submodule";
+    publish.error = failed.map((x) => `${x.dir}: ${x.error ?? "failed"}`).join("; ");
+  }
+  return { ...publish, submodules };
 }
 function cloneArgs(url, dest, branch) {
   const b2 = (branch ?? "").trim();
@@ -37864,18 +37912,27 @@ async function remoteHasBranch(url, branch) {
     return false;
   }
 }
-async function ensureRemoteBranch(url, branch, emit) {
+async function ensureRemoteBranch(url, branch, emit, base = {}) {
   if (await remoteHasBranch(url, branch)) return true;
   const tmp = await mkdtemp(join6(tmpdir2(), "4pm-branch-"));
   try {
-    emit("git", `Branch "${branch}" not found on ${url} \u2014 creating it from the default branch\u2026`);
-    await run("git", ["clone", "--depth", "1", url, tmp], { timeout: 12e4 });
-    await run("git", ["checkout", "-b", branch], { cwd: tmp, timeout: 3e4 });
+    if (base.kind === "empty") {
+      emit("git", `Branch "${branch}" not found on ${url} \u2014 creating it empty (no history)\u2026`);
+      await run("git", ["clone", "--no-checkout", "--depth", "1", url, tmp], { timeout: 12e4 });
+      await run("git", ["checkout", "--orphan", branch], { cwd: tmp, timeout: 3e4 });
+      await run("git", ["rm", "-r", "-q", "--cached", "--ignore-unmatch", "."], { cwd: tmp, timeout: 3e4 });
+      await run("git", ["clean", "-fdxq"], { cwd: tmp, timeout: 6e4 });
+      await run("git", ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", "commit", "--allow-empty", "-m", "chore: start branch (4PM)"], { cwd: tmp, timeout: 3e4 });
+    } else {
+      const from = base.kind === "branch" && base.branch ? base.branch : "";
+      emit("git", `Branch "${branch}" not found on ${url} \u2014 creating it from ${from || "the default branch"}\u2026`);
+      await run("git", ["clone", "--depth", "1", ...from ? ["-b", from] : [], url, tmp], { timeout: 12e4 });
+      await run("git", ["checkout", "-b", branch], { cwd: tmp, timeout: 3e4 });
+    }
     await run("git", ["push", "-u", "origin", branch], { cwd: tmp, timeout: 12e4 });
     return true;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    emit("git-branch-push-failed", `Could not create branch "${branch}" on ${url}: ${msg}`);
+    emit("git-branch-push-failed", `Could not create branch "${branch}" on ${url}: ${errText(err)}`);
     return false;
   } finally {
     await rm(tmp, { recursive: true, force: true });
@@ -37912,15 +37969,24 @@ async function provisionRepo(target, repo, emit, opts = {}) {
   }
   const b2 = (repo.branch ?? "").trim();
   if (b2 && opts.createMissingBranch && !await remoteHasBranch(repo.url, b2)) {
-    emit("git", `Cloning ${repo.url} (default branch) to create "${b2}"\u2026`);
-    await run("git", ["clone", repo.url, target], { timeout: 12e4 });
+    const kind = repo.base?.kind ?? "default";
+    const from = kind === "branch" ? (repo.base?.branch ?? "").trim() : "";
+    if (kind === "empty") {
+      emit("git", `Creating "${b2}" as an empty branch (no history) in ${repo.url}\u2026`);
+      await run("git", ["clone", "--no-checkout", repo.url, target], { timeout: 12e4 });
+      await run("git", ["checkout", "--orphan", b2], { cwd: target, timeout: 3e4 });
+      await run("git", ["rm", "-r", "-q", "--cached", "--ignore-unmatch", "."], { cwd: target, timeout: 3e4 });
+      await run("git", ["clean", "-fdxq"], { cwd: target, timeout: 6e4 });
+      return;
+    }
+    emit("git", `Cloning ${repo.url} (${from || "default branch"}) to create "${b2}"\u2026`);
+    await run("git", cloneArgs(repo.url, target, from || void 0), { timeout: 12e4 });
     await run("git", ["checkout", "-b", b2], { cwd: target, timeout: 3e4 });
     try {
       await run("git", ["push", "-u", "origin", b2], { cwd: target, timeout: 12e4 });
       emit("git", `Created and pushed branch "${b2}".`);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      emit("git-branch-push-failed", `Branch "${b2}" created locally but the push failed: ${msg} \u2014 push it when credentials are available.`);
+      emit("git-branch-push-failed", `Branch "${b2}" created locally but the push failed: ${errText(err)} \u2014 the publish step retries it.`);
     }
     return;
   }
@@ -37933,7 +37999,10 @@ async function ensureReposCloned(physicRoot, repos, emit) {
   if (!repo) return;
   const step = emit ?? (() => void 0);
   await provisionRepo(physicRoot, repo, step);
-  await attachSubmodules(physicRoot, submodulesOf(list), step);
+  await attachSubmodules(physicRoot, submodulesOf(list), step, { commit: true });
+}
+function projectSampleDir() {
+  return sampleDir();
 }
 function sampleDir() {
   if (process.env.SCAFFOLD_SAMPLE_DIR) return process.env.SCAFFOLD_SAMPLE_DIR;
@@ -37959,11 +38028,16 @@ async function scaffoldProject(payload, profileDir2, onProgress, ai2, applyGitAu
     if (payload.gitAuth !== void 0) applyGitAuth2?.(payload.gitAuth ?? null, payload.gitAuthHost ?? null);
     emit("git", "Cloning repository\u2026");
     await provisionRepo(target, repo, emit, { createMissingBranch: true });
+    const sourceHadScaffold = existsSync4(join6(target, ".4pm", ".4pm.json"));
     await scaffoldRepo(target, payload.projectName, payload.spec, emit, { resetClaude: true, ai: ai2 });
-    await attachSubmodules(target, submodulesOf(reposOf(payload.spec)), emit, true);
+    if (repo.resetTracking ?? sourceHadScaffold) await resetTrackingFiles(target, emit);
+    const submodules = await attachSubmodules(target, submodulesOf(reposOf(payload.spec)), emit, {
+      createMissingBranch: true,
+      base: repo.base
+    });
     emit("version", "Writing .4pm/.4pm.json\u2026");
     await writeTemplateMarker(target);
-    const publish = await commitAndOpenPr(target, repo, emit);
+    const publish = withSubmodules(await commitAndPush(target, repo, emit), submodules);
     onProgress?.({ projectId: payload.projectId, step: "done", message: "Scaffold complete.", done: true });
     return { ok: true, path: target, publish };
   } catch (err) {
@@ -37988,6 +38062,17 @@ async function resetTemplateManagedClaude(dir2, label, emit) {
   await rm(join6(claude, "settings.json"), { force: true });
   await rm(join6(claude, "skills"), { recursive: true, force: true });
 }
+async function resetTrackingFiles(target, emit) {
+  const templates = join6(sampleDir(), ".claude", "templates");
+  const reset = [];
+  for (const file of SCAFFOLD_TRACKING_FILES) {
+    const empty = join6(templates, file.replace(/\.md$/, ".empty.md"));
+    if (!existsSync4(empty)) continue;
+    await cp(empty, join6(target, file), { force: true });
+    reset.push(file);
+  }
+  if (reset.length > 0) emit("copy", `Reset the 4PM tracking files: ${reset.join(", ")}.`);
+}
 async function writeTemplateMarker(target) {
   const dir2 = join6(target, ".4pm");
   await mkdir(dir2, { recursive: true });
@@ -38088,7 +38173,9 @@ async function addProject(payload, profileDir2, onProgress, ai2) {
     if (payload.scaffoldRepos && payload.scaffoldRepos.length > 0) {
       await scaffoldRepo(target, payload.projectName, payload.spec, emit, { ai: ai2 });
     }
-    await attachSubmodules(target, submodulesOf(payload.repos ?? []), emit);
+    const outcomes = await attachSubmodules(target, submodulesOf(payload.repos ?? []), emit, { commit: true });
+    const failed = outcomes.filter((x) => !x.ok);
+    if (failed.length > 0) throw new Error(failed.map((x) => `submodule ${x.dir}: ${x.error ?? "failed"}`).join("; "));
     onProgress?.({ projectId: payload.projectId, step: "done", message: "Project added.", done: true });
     return { ok: true, path: target };
   } catch (err) {
@@ -38478,6 +38565,9 @@ var WsChannels = {
   // server → cli (reply): retry the scaffold commit → push → PR in the project folder (ADR-0368,
   // project-0074); the reply carries the new outcome, stored on `projects.scaffold_publish`.
   PROJECT_PUBLISH: "project.publish",
+  // server → cli (reply): probe a repo branch before creating a project (ADR-0370, project-0076) —
+  // branch existence, remote branches, and whether the source ref already holds a 4PM scaffold.
+  REPO_PROBE: "repo.probe",
   // server → cli: keep the physic folder name in sync with the project (folder =
   // project name — ADR-0064) when the project is renamed.
   PHYSIC_SYNC: "physic.sync",
@@ -38522,6 +38612,9 @@ var WsChannels = {
   // cli → server (reply): read / add the org's monthly autonomous-book counters — USER_TODO / USER_QA /
   // AI_TODO rows vs `autonomousRequestsPerMonth` (ADR-0365)
   AUTONOMOUS_BOOK_USAGE: "autonomous.bookUsage",
+  // cli → server (one-way): an autonomous condition the project's managers must see (ADR-0371) —
+  // protected base, lost claim, attempt limit, task split, task question. The server notifies them.
+  AUTONOMOUS_ALERT: "autonomous.alert",
   USAGE_REPORT: "usage.report",
   // cli → server: Claude subscription usage snapshot (5h / weekly — ADR-0072)
   MACHINE_USAGE: "machine.usage",
@@ -38630,7 +38723,7 @@ var COMMAND_CANCELLED_EXIT_CODE = 130;
 import { spawn as spawn2 } from "child_process";
 
 // src/common/logger/logger.ts
-import { appendFile, mkdir as mkdir2, readdir, unlink } from "fs/promises";
+import { appendFile, mkdir as mkdir2, readdir as readdir2, unlink } from "fs/promises";
 import { readdirSync as readdirSync2, readFileSync as readFileSync6, statSync } from "fs";
 import { join as join7 } from "path";
 var LEVEL_ORDER = { error: 0, warn: 1, info: 2, debug: 3 };
@@ -38690,7 +38783,7 @@ var CliLogger = class {
   async cleanupOldLogs() {
     const dir2 = this.dir;
     if (!dir2) return;
-    const files = await readdir(dir2).catch(() => []);
+    const files = await readdir2(dir2).catch(() => []);
     const cutoff = Date.now() - this.retentionDays * DAY_MS;
     for (const file of files) {
       const match = /^cli-(\d{4}-\d{2}-\d{2})\.jsonl$/.exec(file);
@@ -39049,9 +39142,9 @@ var UpdateScheduler = class {
         day: "2-digit",
         hour: "2-digit"
       }).formatToParts(/* @__PURE__ */ new Date());
-      const get2 = (type) => parts.find((p2) => p2.type === type)?.value ?? "";
-      const hour = Number.parseInt(get2("hour"), 10);
-      const dateKey = `${get2("year")}-${get2("month")}-${get2("day")}`;
+      const get3 = (type) => parts.find((p2) => p2.type === type)?.value ?? "";
+      const hour = Number.parseInt(get3("hour"), 10);
+      const dateKey = `${get3("year")}-${get3("month")}-${get3("day")}`;
       if (Number.isNaN(hour)) return null;
       return { hour: hour % 24, dateKey };
     } catch {
@@ -40425,11 +40518,11 @@ function reportToolResult(tool, ok, message) {
 }
 
 // src/core/autonomous.ts
-import { readFile as readFile5, writeFile as writeFile4, chmod } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile5, chmod } from "fs/promises";
 import { readFileSync as readFileSync14 } from "fs";
-import { execFile as execFile3, spawn as spawn5 } from "child_process";
-import { join as join17 } from "path";
-import { promisify as promisify3 } from "util";
+import { execFile as execFile5, spawn as spawn5 } from "child_process";
+import { join as join19 } from "path";
+import { promisify as promisify5 } from "util";
 
 // src/core/autonomous-config.ts
 import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
@@ -40444,7 +40537,11 @@ var DEFAULT_AUTONOMOUS_CONFIG = {
   logRetentionDays: 14,
   model: "",
   maxSessionPct: 80,
-  maxWeeklyPct: 90
+  maxWeeklyPct: 90,
+  claimTtlHours: 6,
+  claimCheckMinutes: 10,
+  maxTaskAttempts: 5,
+  taskSizeHints: { sMaxFiles: 5, sMaxLines: 300, mMaxFiles: 20, mMaxLines: 1500 }
 };
 function autonomousConfigPath(profileDir2) {
   return join15(profileDir2, "autonomous.config.json");
@@ -40463,7 +40560,20 @@ function coerce2(raw) {
     logRetentionDays: num(o.logRetentionDays, d.logRetentionDays),
     model: str(o.model, d.model),
     maxSessionPct: num(o.maxSessionPct, d.maxSessionPct),
-    maxWeeklyPct: num(o.maxWeeklyPct, d.maxWeeklyPct)
+    maxWeeklyPct: num(o.maxWeeklyPct, d.maxWeeklyPct),
+    claimTtlHours: Math.max(1, num(o.claimTtlHours, d.claimTtlHours)),
+    claimCheckMinutes: Math.max(1, num(o.claimCheckMinutes, d.claimCheckMinutes)),
+    maxTaskAttempts: Math.max(1, num(o.maxTaskAttempts, d.maxTaskAttempts)),
+    taskSizeHints: (() => {
+      const h = o.taskSizeHints && typeof o.taskSizeHints === "object" ? o.taskSizeHints : {};
+      const dh = d.taskSizeHints;
+      return {
+        sMaxFiles: num(h.sMaxFiles, dh.sMaxFiles),
+        sMaxLines: num(h.sMaxLines, dh.sMaxLines),
+        mMaxFiles: num(h.mMaxFiles, dh.mMaxFiles),
+        mMaxLines: num(h.mMaxLines, dh.mMaxLines)
+      };
+    })()
   };
 }
 async function readAutonomousConfig(profileDir2) {
@@ -40539,8 +40649,481 @@ function pushRecord(h, rec) {
   return h;
 }
 
-// src/core/autonomous.ts
+// src/core/autonomous-books.ts
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { join as join17 } from "path";
+function splitRow(line) {
+  const body = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  return body.split(/(?<!\\)\|/).map((c) => c.trim().replace(/\\\|/g, "|"));
+}
+function cell(value) {
+  return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim();
+}
+function findTables(md) {
+  const lines = md.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const l = lines[i].trim();
+    const next = lines[i + 1]?.trim() ?? "";
+    if (l.startsWith("|") && /^\|[\s:|-]+\|?$/.test(next)) {
+      const header = splitRow(l);
+      let j2 = i + 2;
+      const rows = [];
+      while (j2 < lines.length && lines[j2].trim().startsWith("|")) {
+        const cells = splitRow(lines[j2]);
+        if (cells.some((c) => c.length > 0)) rows.push(cells);
+        j2++;
+      }
+      out.push({ start: i, end: j2, header, rows });
+      i = j2;
+    } else i++;
+  }
+  return out;
+}
+function replaceRows(md, table, rows) {
+  const lines = md.split("\n");
+  const width = table.header.length;
+  const sep9 = `|${table.header.map(() => "---").join("|")}|`;
+  const body = (rows.length ? rows : [table.header.map(() => "")]).map(
+    (r) => `| ${Array.from({ length: width }, (_2, k2) => cell(r[k2] ?? "")).join(" | ")} |`
+  );
+  const head = `| ${table.header.join(" | ")} |`;
+  lines.splice(table.start, table.end - table.start, head, sep9, ...body);
+  return lines.join("\n");
+}
+function col(header, name) {
+  return header.findIndex((h) => h.toLowerCase() === name.toLowerCase());
+}
+function get(t2, row, name) {
+  const i = col(t2.header, name);
+  return i >= 0 ? row[i] ?? "" : "";
+}
+function build(header, values) {
+  return header.map((h) => values[h.toLowerCase()] ?? "");
+}
+function splitIds(v2) {
+  return v2.split(/[,\s]+/).map((x) => x.trim()).filter((x) => /^(TSK|QA)-/.test(x));
+}
+function parseTasks(md) {
+  const table = findTables(md).find((t2) => col(t2.header, "ID") >= 0 && col(t2.header, "Depends") >= 0 && col(t2.header, "Priority") >= 0) ?? null;
+  if (!table) return { table: null, tasks: [] };
+  const tasks = table.rows.map((r) => ({
+    id: get(table, r, "ID"),
+    priority: get(table, r, "Priority"),
+    tag: get(table, r, "Tag"),
+    depends: splitIds(get(table, r, "Depends")),
+    group: get(table, r, "Group"),
+    desc: get(table, r, "Task description"),
+    notes: get(table, r, "Notes")
+  })).filter((t2) => /^TSK-/.test(t2.id));
+  return { table, tasks };
+}
+function writeTasks(md, tasks) {
+  const { table } = parseTasks(md);
+  if (!table) return md;
+  return replaceRows(
+    md,
+    table,
+    tasks.map(
+      (t2) => build(table.header, {
+        id: t2.id,
+        priority: t2.priority,
+        tag: t2.tag,
+        depends: t2.depends.join(", "),
+        group: t2.group,
+        "task description": t2.desc,
+        notes: t2.notes
+      })
+    )
+  );
+}
+var PROGRESS_HEADER = ["Started", "ID", "Worker", "Claim", "Attempt", "Task description"];
+function parseClaims(md) {
+  const table = findTables(md).find((t2) => col(t2.header, "ID") >= 0 && col(t2.header, "Started") >= 0) ?? null;
+  if (!table) return { table: null, claims: [] };
+  const claims = table.rows.map((r) => ({
+    started: get(table, r, "Started"),
+    id: get(table, r, "ID"),
+    worker: get(table, r, "Worker"),
+    claim: get(table, r, "Claim"),
+    attempt: Number(get(table, r, "Attempt")) || 1,
+    desc: get(table, r, "Task description")
+  })).filter((c) => /^TSK-/.test(c.id));
+  return { table, claims };
+}
+function writeClaims(md, claims) {
+  const found = parseClaims(md).table;
+  const table = found ? { ...found, header: PROGRESS_HEADER } : { start: md.split("\n").length, end: md.split("\n").length, header: PROGRESS_HEADER, rows: [] };
+  const src = found ? md : `${md.replace(/\n*$/, "")}
+
+`;
+  return replaceRows(
+    src,
+    table,
+    claims.map((c) => [c.started, c.id, c.worker, c.claim, String(c.attempt), c.desc])
+  );
+}
+function appendDone(md, row) {
+  const table = findTables(md).find((t2) => col(t2.header, "ID") >= 0 && col(t2.header, "Timestamp") >= 0);
+  if (!table) return md;
+  const values = { timestamp: stamp(), id: row.id, "task description": row.desc, files: row.files, notes: row.notes };
+  return replaceRows(md, table, [...table.rows, build(table.header, values)]);
+}
+function appendIncident(md, note) {
+  const table = findTables(md).find((t2) => col(t2.header, "Note") >= 0 && col(t2.header, "Timestamp") >= 0 && col(t2.header, "ID") < 0);
+  if (!table) return md;
+  return replaceRows(md, table, [...table.rows, build(table.header, { timestamp: stamp(), note })]);
+}
+function doneRows(md) {
+  const table = findTables(md).find((t2) => col(t2.header, "ID") >= 0 && col(t2.header, "Timestamp") >= 0);
+  const out = /* @__PURE__ */ new Map();
+  if (table) for (const r of table.rows) out.set(get(table, r, "ID"), get(table, r, "Notes"));
+  return out;
+}
+function parseQa(md) {
+  const table = findTables(md).find((t2) => col(t2.header, "ID") >= 0 && col(t2.header, "Answer") >= 0) ?? null;
+  if (!table) return { table: null, rows: [] };
+  const rows = table.rows.map((r) => ({
+    id: get(table, r, "ID"),
+    group: get(table, r, "Group"),
+    depends: get(table, r, "Depends"),
+    original: get(table, r, "Original request"),
+    question: get(table, r, "Question / options"),
+    answer: get(table, r, "Answer")
+  })).filter((q2) => /^QA-/.test(q2.id));
+  return { table, rows };
+}
+function writeQa(md, rows) {
+  const { table } = parseQa(md);
+  if (!table) return md;
+  return replaceRows(
+    md,
+    table,
+    rows.map(
+      (q2) => build(table.header, {
+        id: q2.id,
+        group: q2.group,
+        depends: q2.depends,
+        "original request": q2.original,
+        "question / options": q2.question,
+        answer: q2.answer
+      })
+    )
+  );
+}
+var ATTEMPTS_REL = ".claude/.autonomous.attempts.json";
+async function readAttempts(root) {
+  try {
+    return JSON.parse(await readFile5(join17(root, ATTEMPTS_REL), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeAttempts(root, map) {
+  const sorted = Object.fromEntries(Object.entries(map).sort(([a], [b2]) => a.localeCompare(b2)));
+  await writeFile4(join17(root, ATTEMPTS_REL), `${JSON.stringify(sorted, null, 2)}
+`, "utf8");
+}
+function stamp(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString().slice(0, 19).replace("T", " ");
+}
+function parseStamp(v2) {
+  const iso = v2.trim().replace(" ", "T");
+  return Date.parse(/[zZ]|[+-]\d\d:?\d\d$/.test(iso) ? iso : `${iso}Z`);
+}
+async function readBook(root, rel) {
+  try {
+    return await readFile5(join17(root, rel), "utf8");
+  } catch {
+    return "";
+  }
+}
+async function writeBook(root, rel, text) {
+  await writeFile4(join17(root, rel), text, "utf8");
+}
+
+// src/core/autonomous-git.ts
+import { execFile as execFile4 } from "child_process";
+import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join18 } from "path";
+import { promisify as promisify4 } from "util";
+
+// src/core/git-host.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
 var run3 = promisify3(execFile3);
+function repoHost(url) {
+  const p2 = parseRepoUrl(url);
+  if (!p2) return { provider: null, host: "", slug: "" };
+  const slug = `${p2.owner}/${p2.name}`;
+  const provider = /gitlab/i.test(p2.host) ? "glab" : /github|ghe\.com/i.test(p2.host) ? "gh" : null;
+  return { provider, host: p2.host, slug };
+}
+function ghHostArgs(h) {
+  return h.host && h.host !== "github.com" ? ["--hostname", h.host] : [];
+}
+function errText2(err) {
+  const e = err;
+  return (e?.stderr || e?.message || String(err)).trim().split("\n").filter(Boolean).slice(-2).join(" ").slice(0, 400);
+}
+async function branchProtection(url, branch) {
+  const h = repoHost(url);
+  if (!h.provider || !branch) return null;
+  try {
+    if (h.provider === "gh") {
+      const { stdout } = await run3("gh", ["api", ...ghHostArgs(h), `repos/${h.slug}/branches/${encodeURIComponent(branch)}`, "--jq", ".protected"], { timeout: 3e4 });
+      return stdout.trim() === "true";
+    }
+    const project = encodeURIComponent(h.slug);
+    try {
+      await run3("glab", ["api", `projects/${project}/protected_branches/${encodeURIComponent(branch)}`], { timeout: 3e4 });
+      return true;
+    } catch (err) {
+      return /404|not found/i.test(errText2(err)) ? false : null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function prStateOf(url, branch) {
+  const h = repoHost(url);
+  if (!h.provider) return null;
+  try {
+    if (h.provider === "gh") {
+      const { stdout: stdout2 } = await run3(
+        "gh",
+        ["pr", "list", "-R", h.host && h.host !== "github.com" ? `${h.host}/${h.slug}` : h.slug, "--head", branch, "--state", "all", "--json", "state", "-L", "1"],
+        { timeout: 3e4 }
+      );
+      const s4 = JSON.parse(stdout2)[0]?.state?.toLowerCase();
+      return s4 === "open" || s4 === "merged" || s4 === "closed" ? s4 : null;
+    }
+    const { stdout } = await run3("glab", ["mr", "list", "-R", h.slug, "--source-branch", branch, "--all", "-F", "json", "-P", "1"], { timeout: 3e4 });
+    const s3 = JSON.parse(stdout)[0]?.state?.toLowerCase();
+    return s3 === "opened" ? "open" : s3 === "merged" ? "merged" : s3 === "closed" ? "closed" : null;
+  } catch {
+    return null;
+  }
+}
+async function openPullRequest(opts) {
+  const h = repoHost(opts.url);
+  if (!h.provider) return { url: null, error: "Unknown git host \u2014 no pull request opened." };
+  const args = h.provider === "gh" ? ["pr", "create", "-R", h.host && h.host !== "github.com" ? `${h.host}/${h.slug}` : h.slug, "--base", opts.base, "--head", opts.head, "--title", opts.title, "--body", opts.body] : ["mr", "create", "-R", h.slug, "--target-branch", opts.base, "--source-branch", opts.head, "--title", opts.title, "--description", opts.body, "--yes"];
+  try {
+    const { stdout } = await run3(h.provider, args, { cwd: opts.cwd, timeout: 12e4 });
+    return { url: stdout.trim().split(/\s+/).find((x) => /^https?:\/\//.test(x)) ?? null, error: null };
+  } catch (err) {
+    const msg = errText2(err);
+    const existing = /already exists/i.test(msg) ? msg.match(/https?:\/\/\S+/)?.[0] ?? null : null;
+    return existing ? { url: existing, error: null } : { url: null, error: msg };
+  }
+}
+
+// src/core/autonomous-git.ts
+var run4 = promisify4(execFile4);
+var BOOK_PATHS = [
+  "AI_TODO.md",
+  "AI_DONE.md",
+  "AI_PROGRESS.md",
+  "USER_TODO.md",
+  "USER_QA.md",
+  ".claude/.autonomous.approvals.json",
+  ".claude/.autonomous.authors.json",
+  ATTEMPTS_REL
+];
+async function git(cwd2, args, timeout = 12e4) {
+  try {
+    const { stdout } = await run4("git", args, { cwd: cwd2, timeout, maxBuffer: 32 * 1024 * 1024 });
+    return stdout;
+  } catch (err) {
+    const e = err;
+    throw new Error((e.stderr || e.message || String(err)).trim().split("\n").slice(-3).join(" "));
+  }
+}
+async function gitQuiet(cwd2, args, timeout = 6e4) {
+  try {
+    return await git(cwd2, args, timeout);
+  } catch {
+    return "";
+  }
+}
+async function remoteDefault(cwd2) {
+  const ref = (await gitQuiet(cwd2, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"])).trim();
+  if (ref) return ref.replace(/^origin\//, "");
+  const out = await gitQuiet(cwd2, ["ls-remote", "--symref", "origin", "HEAD"]);
+  return /ref: refs\/heads\/(\S+)\s+HEAD/.exec(out)?.[1] ?? "";
+}
+async function resolveBases(root) {
+  let declared = "";
+  let url = "";
+  try {
+    const spec = JSON.parse(await readFile6(join18(root, "project.spec.json"), "utf8"));
+    const primary = spec.repos?.find((r) => r.primary) ?? spec.repos?.[0];
+    declared = primary?.branch?.trim() ?? "";
+    url = primary?.url?.trim() ?? "";
+  } catch {
+  }
+  if (!url) url = (await gitQuiet(root, ["remote", "get-url", "origin"])).trim();
+  const rootBase = { dir: "", url, base: declared || await remoteDefault(root) };
+  const subs = [];
+  if (existsSync11(join18(root, ".gitmodules"))) {
+    const paths = (await gitQuiet(root, ["config", "-f", ".gitmodules", "--get-regexp", "^submodule\\..*\\.path$"])).split("\n").filter(Boolean);
+    for (const line of paths) {
+      const [key = "", ...rest] = line.split(" ");
+      const name = key.replace(/^submodule\./, "").replace(/\.path$/, "");
+      const dir2 = rest.join(" ");
+      const subUrl = (await gitQuiet(root, ["config", "-f", ".gitmodules", `submodule.${name}.url`])).trim();
+      const b2 = (await gitQuiet(root, ["config", "-f", ".gitmodules", `submodule.${name}.branch`])).trim();
+      const abs = join18(root, dir2);
+      subs.push({ dir: dir2, url: subUrl, base: b2 || (existsSync11(join18(abs, ".git")) ? await remoteDefault(abs) : "") });
+    }
+  }
+  return { root: rootBase, subs };
+}
+async function hasRemoteBranch(cwd2, branch) {
+  return (await gitQuiet(cwd2, ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${branch}`])).trim().length > 0;
+}
+async function currentBranch(cwd2) {
+  const b2 = (await gitQuiet(cwd2, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  return b2 === "HEAD" ? "" : b2;
+}
+async function wipCommit(cwd2, message) {
+  await gitQuiet(cwd2, ["add", "-A"]);
+  const staged = (await gitQuiet(cwd2, ["diff", "--cached", "--name-only"])).trim();
+  if (!staged) return false;
+  await git(cwd2, ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", "commit", "-q", "-m", message]).catch(() => void 0);
+  return true;
+}
+async function syncBase(root, base) {
+  const cur = await currentBranch(root);
+  if ((await gitQuiet(root, ["status", "--porcelain"])).trim()) {
+    if (cur.includes("/dev/")) await wipCommit(root, "wip: autosave before sync (4PM)");
+    else await gitQuiet(root, ["stash", "push", "-u", "-m", "4PM autosave"]);
+  }
+  await git(root, ["fetch", "-q", "--prune", "origin"]);
+  if (await hasRemoteBranch(root, base)) await git(root, ["checkout", "-q", "-B", base, `origin/${base}`]);
+  else await git(root, ["checkout", "-q", base]);
+  await gitQuiet(root, ["submodule", "update", "--init", "-q"], 3e5);
+}
+async function publishBooks(root, base, message, change, opts = {}) {
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    await git(root, ["fetch", "-q", "origin", base]).catch(() => void 0);
+    if (await hasRemoteBranch(root, base)) {
+      if (opts.detach) await git(root, ["checkout", "-q", "--detach", `origin/${base}`]);
+      else await git(root, ["checkout", "-q", "-B", base, `origin/${base}`]);
+    }
+    if (!await change()) return "aborted";
+    await gitQuiet(root, ["add", "--", ...BOOK_PATHS.filter((p2) => existsSync11(join18(root, p2)))]);
+    const staged = (await gitQuiet(root, ["diff", "--cached", "--name-only"])).trim();
+    if (!staged) return "unchanged";
+    await git(root, ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", "commit", "-q", "-m", message]);
+    try {
+      await git(root, ["push", "-q", "origin", `HEAD:refs/heads/${base}`]);
+      return "pushed";
+    } catch (err) {
+      const msg = String(err);
+      if (!/non-fast-forward|fetch first|rejected|stale info/i.test(msg)) return "failed";
+      await new Promise((r) => setTimeout(r, 500 + Math.random() * 2e3 * attempt));
+    }
+  }
+  return "failed";
+}
+async function publishIntake(root, base, message) {
+  await gitQuiet(root, ["add", "--", ...BOOK_PATHS.filter((p2) => existsSync11(join18(root, p2)))]);
+  const staged = (await gitQuiet(root, ["diff", "--cached", "--name-only"])).trim();
+  await gitQuiet(root, ["checkout", "--", "."]);
+  await gitQuiet(root, ["clean", "-fdq", "--", "."]);
+  if (!staged) return "unchanged";
+  await git(root, ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", "commit", "-q", "-m", message]);
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    try {
+      await git(root, ["push", "-q", "origin", `HEAD:refs/heads/${base}`]);
+      return "pushed";
+    } catch {
+      await gitQuiet(root, ["fetch", "-q", "origin", base]);
+      try {
+        await git(root, ["rebase", "-q", `origin/${base}`]);
+      } catch {
+        await gitQuiet(root, ["rebase", "--abort"]);
+        await gitQuiet(root, ["reset", "-q", "--hard", `origin/${base}`]);
+        return "aborted";
+      }
+    }
+  }
+  return "failed";
+}
+async function remoteBook(cwd2, base, rel) {
+  await gitQuiet(cwd2, ["fetch", "-q", "origin", base]);
+  return gitQuiet(cwd2, ["show", `origin/${base}:${rel}`]);
+}
+async function isMerged(cwd2, url, branch, base) {
+  const state3 = await prStateOf(url, branch);
+  if (state3 === "merged") return true;
+  if (state3 === "open" || state3 === "closed") return false;
+  if (!await hasRemoteBranch(cwd2, branch)) return true;
+  try {
+    await git(cwd2, ["merge-base", "--is-ancestor", `origin/${branch}`, `origin/${base}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkoutTaskBranch(cwd2, branch, base, from) {
+  await git(cwd2, ["fetch", "-q", "--prune", "origin"]);
+  const local = (await gitQuiet(cwd2, ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`])).trim();
+  if (await hasRemoteBranch(cwd2, branch)) {
+    if (local && await gitQuiet(cwd2, ["merge-base", "--is-ancestor", `origin/${branch}`, branch]).then(() => true, () => false)) {
+      await git(cwd2, ["checkout", "-q", branch]);
+    } else await git(cwd2, ["checkout", "-q", "-B", branch, `origin/${branch}`]);
+    return;
+  }
+  if (local) {
+    await git(cwd2, ["checkout", "-q", branch]);
+    return;
+  }
+  const start = from && await hasRemoteBranch(cwd2, from) ? `origin/${from}` : `origin/${base}`;
+  await git(cwd2, ["checkout", "-q", "-B", branch, start]);
+}
+async function aheadOf(cwd2, branch, base) {
+  return Number((await gitQuiet(cwd2, ["rev-list", "--count", `origin/${base}..${branch}`])).trim()) || 0;
+}
+async function pushBranch(cwd2, branch) {
+  await git(cwd2, ["push", "-q", "-u", "origin", `${branch}:refs/heads/${branch}`], 18e4);
+}
+async function deliverPr(cwd2, url, branch, base, title, body) {
+  return openPullRequest({ url, cwd: cwd2, base, head: branch, title, body });
+}
+async function mutateBooksOnBase(root, base, message, fn) {
+  await git(root, ["fetch", "-q", "origin", base]).catch(() => void 0);
+  if (!await hasRemoteBranch(root, base)) return "unchanged";
+  const dir2 = join18(root, ".git", `4pm-books-${process.pid}-${Date.now()}`);
+  await git(root, ["worktree", "add", "-q", "--detach", dir2, `origin/${base}`]);
+  try {
+    return await publishBooks(dir2, base, message, () => fn(dir2), { detach: true });
+  } finally {
+    await gitQuiet(root, ["worktree", "remove", "--force", dir2]);
+    await gitQuiet(root, ["worktree", "prune"]);
+  }
+}
+var lastFetch = /* @__PURE__ */ new Map();
+async function readBaseFile(root, base, rel) {
+  const key = `${root}\0${base}`;
+  if (Date.now() - (lastFetch.get(key) ?? 0) > 15e3) {
+    await gitQuiet(root, ["fetch", "-q", "origin", base]);
+    lastFetch.set(key, Date.now());
+  }
+  if (!await hasRemoteBranch(root, base)) return null;
+  try {
+    return await git(root, ["show", `origin/${base}:${rel}`]);
+  } catch {
+    return "";
+  }
+}
+
+// src/core/autonomous.ts
+var run5 = promisify5(execFile5);
 var APPROVALS_REL = ".claude/.autonomous.approvals.json";
 var AUTHORS_REL = ".claude/.autonomous.authors.json";
 var TICK_REL = ".claude/hooks/autonomous-tick.sh";
@@ -40554,7 +41137,7 @@ var BOOK_FILES = {
 };
 async function readText(path, fallback = "") {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile7(path, "utf8");
   } catch {
     return fallback;
   }
@@ -40603,16 +41186,16 @@ var CAPPED_BOOK_FILES = { USER_TODO: "USER_TODO.md", USER_QA: "USER_QA.md", AI_T
 async function cappedBookIds(root) {
   const out = {};
   for (const [book, file] of Object.entries(CAPPED_BOOK_FILES)) {
-    out[book] = new Set(tableRowsById(await readText(join17(root, file))).keys());
+    out[book] = new Set(tableRowsById(await readText(join19(root, file))).keys());
   }
   return out;
 }
 function tickScript(root) {
-  return join17(root, TICK_REL);
+  return join19(root, TICK_REL);
 }
 async function crontabList() {
   try {
-    const { stdout } = await run3("crontab", ["-l"], { timeout: 1e4 });
+    const { stdout } = await run5("crontab", ["-l"], { timeout: 1e4 });
     return stdout;
   } catch {
     return "";
@@ -40645,13 +41228,15 @@ async function getAutonomousStatus(root, profileDir2) {
     lastTickAt: last?.ts ?? null,
     lastResult: last?.status ?? null,
     consecutiveFails: hist.consecutiveFails,
-    todayTicks: hist.ticks.day === today ? hist.ticks.count : 0
+    todayTicks: hist.ticks.day === today ? hist.ticks.count : 0,
+    // The last tick stopped on a protected base (ADR-0371 phase 0) — "<branch> (<repo>)".
+    baseProtected: /^base-protected: (.+)$/.exec(last?.note ?? "")?.[1] ?? null
   };
 }
 function isAutonomousRunning(root, profileDir2) {
   try {
     if (readAutonomousConfigSync(profileDir2).paused) return false;
-    const h = JSON.parse(readFileSync14(join17(root, ".claude/.autonomous.histories.json"), "utf8"));
+    const h = JSON.parse(readFileSync14(join19(root, ".claude/.autonomous.histories.json"), "utf8"));
     const ts2 = h.records?.[h.records.length - 1]?.ts;
     if (!ts2) return false;
     const t2 = Date.parse(ts2.replace(" ", "T"));
@@ -40661,21 +41246,27 @@ function isAutonomousRunning(root, profileDir2) {
   }
 }
 async function readAutonomous(root, profileDir2) {
-  const [settings, approvals, authors, status, ...books] = await Promise.all([
+  const base = (await resolveBases(root).catch(() => null))?.root.base ?? "";
+  const read = async (rel, fallback = "") => {
+    const remote = base ? await readBaseFile(root, base, rel) : null;
+    return remote === null ? readText(join19(root, rel), fallback) : remote || fallback;
+  };
+  const [settings, approvals, authors, attempts, status, ...books] = await Promise.all([
     readAutonomousConfigText(profileDir2),
-    readText(join17(root, APPROVALS_REL), "{}"),
-    readText(join17(root, AUTHORS_REL), "{}"),
+    read(APPROVALS_REL, "{}"),
+    read(AUTHORS_REL, "{}"),
+    read(ATTEMPTS_REL, "{}"),
     getAutonomousStatus(root, profileDir2),
-    ...Object.values(BOOK_FILES).map((f2) => readText(join17(root, f2)))
+    ...Object.values(BOOK_FILES).map((f2) => read(f2))
   ]);
   const keys = Object.keys(BOOK_FILES);
   const bookMap = {};
   keys.forEach((k2, i) => bookMap[k2] = books[i] ?? "");
-  return { settings, status, books: bookMap, approvals, authors };
+  return { settings, status, books: bookMap, approvals, authors, attempts };
 }
 async function readAutonomousLogs(root, date) {
   const day = date && /^\d{4}-\d{2}-\d{2}$/.test(date) ? date : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const text = await readText(join17(root, LOG_DIR_REL, `autonomous-tick-${day}.log`));
+  const text = await readText(join19(root, LOG_DIR_REL, `autonomous-tick-${day}.log`));
   const lines = text ? text.split("\n").filter((l) => l.length > 0).slice(-500) : [];
   return { date: day, lines };
 }
@@ -40697,79 +41288,88 @@ async function uninstallCron(root) {
   const kept = cur.split("\n").filter((l) => l.trim() && !l.includes(script));
   await crontabSet(kept.join("\n"));
 }
+async function applyWebWrite(dir2, req, by) {
+  switch (req.kind) {
+    case "approvals": {
+      if (req.approved && !req.byIsAdmin) {
+        const authors = await readJsonMap(join19(dir2, AUTHORS_REL));
+        if (entryBy(authors, req.taskId) === by) return { ok: false, code: "APPROVAL_SELF", failedId: req.taskId, error: "self-approval blocked" };
+      }
+      const map = parseJson(await readText(join19(dir2, APPROVALS_REL), "{}")) ?? {};
+      if (req.approved) map[req.taskId] = { approved: true, by, byLabel: req.byLabel ?? by, at: (/* @__PURE__ */ new Date()).toISOString() };
+      else delete map[req.taskId];
+      await writeFile5(join19(dir2, APPROVALS_REL), JSON.stringify(map, null, 2) + "\n", "utf8");
+      return { ok: true };
+    }
+    case "approvalsBatch": {
+      if (!req.byIsAdmin) {
+        const authors = await readJsonMap(join19(dir2, AUTHORS_REL));
+        const selfId = req.approve.find((id) => entryBy(authors, id) === by);
+        if (selfId) return { ok: false, code: "APPROVAL_SELF", failedId: selfId, error: "self-approval blocked" };
+      }
+      const map = parseJson(await readText(join19(dir2, APPROVALS_REL), "{}")) ?? {};
+      const at2 = (/* @__PURE__ */ new Date()).toISOString();
+      const byLabel = req.byLabel ?? by;
+      for (const taskId of req.approve) map[taskId] = { approved: true, by, byLabel, at: at2 };
+      for (const taskId of req.unapprove) delete map[taskId];
+      await writeFile5(join19(dir2, APPROVALS_REL), JSON.stringify(map, null, 2) + "\n", "utf8");
+      return { ok: true };
+    }
+    case "userTodo": {
+      const cur = await readText(join19(dir2, BOOK_FILES.userTodo));
+      const ids = [...cur.matchAll(/REQ-(\d{4})-(\d{4})/g)];
+      const maxGroup = ids.reduce((m2, g2) => Math.max(m2, Number(g2[1])), 0);
+      const id = `REQ-${String(maxGroup + 1).padStart(4, "0")}-0001`;
+      const row = `| ${id} | | | ${tableCell(req.content)} |
+`;
+      await writeFile5(join19(dir2, BOOK_FILES.userTodo), cur.replace(/\s*$/, "\n") + row, "utf8");
+      const authors = await readJsonMap(join19(dir2, AUTHORS_REL));
+      authors[id] = { by, byLabel: req.byLabel ?? by, at: (/* @__PURE__ */ new Date()).toISOString() };
+      await writeFile5(join19(dir2, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
+      return { ok: true, added: 1 };
+    }
+    case "bookSave": {
+      const file = BOOK_FILES[req.book];
+      const prev = tableRowsById(await readText(join19(dir2, file)));
+      const next = tableRowsById(req.content);
+      const authors = await readJsonMap(join19(dir2, AUTHORS_REL));
+      const at2 = (/* @__PURE__ */ new Date()).toISOString();
+      const byLabel = req.byLabel ?? by;
+      let added = 0;
+      for (const [id, cells] of next) {
+        if (prev.get(id) !== cells) authors[id] = { by, byLabel, at: at2 };
+        if (!prev.has(id)) added += 1;
+      }
+      await writeFile5(join19(dir2, file), req.content, "utf8");
+      await writeFile5(join19(dir2, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
+      return { ok: true, added };
+    }
+    default:
+      return { ok: false, error: "not a book write" };
+  }
+}
 async function writeAutonomous(root, profileDir2, req, by) {
   let added;
   try {
-    switch (req.kind) {
-      case "settings": {
-        const parsed = parseJson(req.settings);
-        if (!parsed) return { ok: false, error: "settings is not valid JSON" };
-        await writeAutonomousConfig(profileDir2, parsed);
-        await syncCron(root, profileDir2);
-        break;
-      }
-      case "approvals": {
-        if (req.approved && !req.byIsAdmin) {
-          const authors = await readJsonMap(join17(root, AUTHORS_REL));
-          if (entryBy(authors, req.taskId) === by) {
-            return { ok: false, code: "APPROVAL_SELF", failedId: req.taskId, error: "self-approval blocked" };
-          }
-        }
-        const map = parseJson(await readText(join17(root, APPROVALS_REL), "{}")) ?? {};
-        if (req.approved) map[req.taskId] = { approved: true, by, byLabel: req.byLabel ?? by, at: (/* @__PURE__ */ new Date()).toISOString() };
-        else delete map[req.taskId];
-        await writeFile4(join17(root, APPROVALS_REL), JSON.stringify(map, null, 2) + "\n", "utf8");
-        break;
-      }
-      case "approvalsBatch": {
-        if (!req.byIsAdmin) {
-          const authors = await readJsonMap(join17(root, AUTHORS_REL));
-          const selfId = req.approve.find((id) => entryBy(authors, id) === by);
-          if (selfId) return { ok: false, code: "APPROVAL_SELF", failedId: selfId, error: "self-approval blocked" };
-        }
-        const map = parseJson(await readText(join17(root, APPROVALS_REL), "{}")) ?? {};
-        const at2 = (/* @__PURE__ */ new Date()).toISOString();
-        const byLabel = req.byLabel ?? by;
-        for (const taskId of req.approve) map[taskId] = { approved: true, by, byLabel, at: at2 };
-        for (const taskId of req.unapprove) delete map[taskId];
-        await writeFile4(join17(root, APPROVALS_REL), JSON.stringify(map, null, 2) + "\n", "utf8");
-        break;
-      }
-      case "userTodo": {
-        const cur = await readText(join17(root, BOOK_FILES.userTodo));
-        const ids = [...cur.matchAll(/REQ-(\d{4})-(\d{4})/g)];
-        const maxGroup = ids.reduce((m2, g2) => Math.max(m2, Number(g2[1])), 0);
-        const id = `REQ-${String(maxGroup + 1).padStart(4, "0")}-0001`;
-        const row = `| ${id} | | | ${tableCell(req.content)} |
-`;
-        await writeFile4(join17(root, BOOK_FILES.userTodo), cur.replace(/\s*$/, "\n") + row, "utf8");
-        added = 1;
-        const authors = await readJsonMap(join17(root, AUTHORS_REL));
-        authors[id] = { by, byLabel: req.byLabel ?? by, at: (/* @__PURE__ */ new Date()).toISOString() };
-        await writeFile4(join17(root, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
-        break;
-      }
-      case "bookSave": {
-        const file = BOOK_FILES[req.book];
-        const prev = tableRowsById(await readText(join17(root, file)));
-        const next = tableRowsById(req.content);
-        const authors = await readJsonMap(join17(root, AUTHORS_REL));
-        const at2 = (/* @__PURE__ */ new Date()).toISOString();
-        const byLabel = req.byLabel ?? by;
-        added = 0;
-        for (const [id, cells] of next) {
-          if (prev.get(id) !== cells) authors[id] = { by, byLabel, at: at2 };
-          if (!prev.has(id)) added += 1;
-        }
-        await writeFile4(join17(root, file), req.content, "utf8");
-        await writeFile4(join17(root, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
-        break;
-      }
-      case "cron": {
-        if (req.action === "install") await installCron(root, profileDir2);
-        else await uninstallCron(root);
-        break;
-      }
+    if (req.kind === "settings") {
+      const parsed = parseJson(req.settings);
+      if (!parsed) return { ok: false, error: "settings is not valid JSON" };
+      await writeAutonomousConfig(profileDir2, parsed);
+      await syncCron(root, profileDir2);
+    } else if (req.kind === "cron") {
+      if (req.action === "install") await installCron(root, profileDir2);
+      else await uninstallCron(root);
+    } else {
+      const base = (await resolveBases(root).catch(() => null))?.root.base ?? "";
+      let res;
+      const pub = base ? await mutateBooksOnBase(root, base, `chore(web): ${req.kind} by ${req.byLabel ?? by}`, async (dir2) => {
+        res = await applyWebWrite(dir2, req, by);
+        return res.ok;
+      }) : "unchanged";
+      if (res === void 0) res = await applyWebWrite(root, req, by);
+      else if (pub === "failed") return { ok: false, error: "could not push the change to the base branch (retry)" };
+      if (!res.ok) return { ok: false, ...res.code ? { code: res.code } : {}, ...res.failedId ? { failedId: res.failedId } : {}, error: res.error };
+      added = res.added;
     }
     return { ok: true, status: await getAutonomousStatus(root, profileDir2), ...added !== void 0 ? { added } : {} };
   } catch (err) {
@@ -40778,7 +41378,7 @@ async function writeAutonomous(root, profileDir2, req, by) {
 }
 
 // src/core/network-probe.ts
-import { existsSync as existsSync11, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync15 } from "fs";
 import { connect } from "net";
 var CANARY_TARGETS = [
   { host: "1.1.1.1", port: 443 },
@@ -40787,7 +41387,7 @@ var CANARY_TARGETS = [
 var PROBE_TIMEOUT_MS = 2500;
 function detectContainerized() {
   try {
-    if (existsSync11("/.dockerenv")) return true;
+    if (existsSync12("/.dockerenv")) return true;
     const cgroup = readFileSync15("/proc/1/cgroup", "utf8");
     return /docker|containerd|kubepods|libpod/.test(cgroup);
   } catch {
@@ -40855,9 +41455,9 @@ async function probeNetwork() {
 }
 
 // src/core/git-auth.ts
-import { chmodSync as chmodSync3, existsSync as existsSync12, mkdirSync as mkdirSync6, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync13, mkdirSync as mkdirSync6, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
 import { request as httpsRequest } from "https";
-import { delimiter, dirname as dirname4, join as join18, resolve as resolve3 } from "path";
+import { delimiter, dirname as dirname4, join as join20, resolve as resolve3 } from "path";
 var JOB_ID_ENV = "FOURPM_JOB_ID";
 var PROFILE_DIR_ENV = "FOURPM_PROFILE_DIR";
 var GIT_HOST_ENV = "FOURPM_GIT_HOST";
@@ -40877,8 +41477,8 @@ function helperCommand() {
 function findRealGh(pathValue, shimDir) {
   for (const dir2 of pathValue.split(delimiter)) {
     if (!dir2 || dir2 === shimDir) continue;
-    const candidate = join18(dir2, process.platform === "win32" ? "gh.exe" : "gh");
-    if (existsSync12(candidate)) return candidate;
+    const candidate = join20(dir2, process.platform === "win32" ? "gh.exe" : "gh");
+    if (existsSync13(candidate)) return candidate;
   }
   return null;
 }
@@ -40939,22 +41539,22 @@ function configureGitAuth(method, host, profileDir2, transport) {
     process.env[PROFILE_DIR_ENV] = resolve3(profileDir2);
     const script = process.argv[1];
     const devTsconfig = script ? resolve3(dirname4(script), "..", "tsconfig.json") : "";
-    if (process.execArgv.some((a) => a.includes("tsx")) && devTsconfig && existsSync12(devTsconfig) && !process.env.TSX_TSCONFIG_PATH) {
+    if (process.execArgv.some((a) => a.includes("tsx")) && devTsconfig && existsSync13(devTsconfig) && !process.env.TSX_TSCONFIG_PATH) {
       process.env.TSX_TSCONFIG_PATH = devTsconfig;
     }
     process.env[GIT_HOST_ENV] = host;
     process.env[GIT_HOST_KIND_ENV] = githubHostKind(host);
     if (process.platform !== "win32") {
-      const shimDir = join18(profileDir2, "bin");
+      const shimDir = join20(profileDir2, "bin");
       const realGh = findRealGh(state.baseEnv.path, shimDir);
       if (realGh) {
         mkdirSync6(shimDir, { recursive: true });
-        const shim = join18(shimDir, "gh");
+        const shim = join20(shimDir, "gh");
         writeFileSync8(shim, shimScript(realGh, cliInvocation()), { encoding: "utf8", mode: 493 });
         chmodSync3(shim, 493);
         process.env.PATH = `${shimDir}${delimiter}${state.baseEnv.path}`;
       } else {
-        rmSync6(join18(shimDir, "gh"), { force: true });
+        rmSync6(join20(shimDir, "gh"), { force: true });
       }
     }
     state.host = host;
@@ -41028,16 +41628,16 @@ async function revokeAll() {
 }
 
 // src/core/git-snapshot.ts
-import { execFile as execFile6 } from "child_process";
+import { execFile as execFile8 } from "child_process";
 import { stat } from "fs/promises";
-import { join as join20, resolve as resolve5 } from "path";
-import { promisify as promisify6 } from "util";
+import { join as join22, resolve as resolve5 } from "path";
+import { promisify as promisify8 } from "util";
 
 // src/core/git-history.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile6 } from "child_process";
 import { resolve as resolve4, sep as sep2 } from "path";
-import { promisify as promisify4 } from "util";
-var run4 = promisify4(execFile4);
+import { promisify as promisify6 } from "util";
+var run6 = promisify6(execFile6);
 var FS = "";
 var RS = "";
 function resolveRepo(root, repo) {
@@ -41046,9 +41646,9 @@ function resolveRepo(root, repo) {
   const requested = resolve4(base, repo && repo.trim() ? repo : ".");
   return requested === base || requested.startsWith(base + sep2) ? requested : base;
 }
-async function git(cwd2, args) {
+async function git2(cwd2, args) {
   try {
-    const { stdout } = await run4("git", args, {
+    const { stdout } = await run6("git", args, {
       cwd: cwd2,
       timeout: 15e3,
       maxBuffer: 8 * 1024 * 1024
@@ -41061,21 +41661,21 @@ async function git(cwd2, args) {
 async function gitRepos(root) {
   if (!root) return { repos: [] };
   const base = resolve4(root);
-  const top = (await git(base, ["rev-parse", "--show-toplevel"])).trim();
+  const top = (await git2(base, ["rev-parse", "--show-toplevel"])).trim();
   if (!top || !(top === base || top.startsWith(base + sep2))) return { repos: [] };
   const repos = [];
-  const rootRemote = (await git(base, ["remote", "get-url", "origin"])).trim();
-  const rootBranch = (await git(base, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  const rootRemote = (await git2(base, ["remote", "get-url", "origin"])).trim();
+  const rootBranch = (await git2(base, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
   repos.push({ subdir: "", name: "", remote: rootRemote || null, branch: rootBranch || null });
-  const subOut = await git(base, ["submodule", "status"]);
+  const subOut = await git2(base, ["submodule", "status"]);
   for (const line of subOut.split("\n")) {
     const m2 = line.trim().match(/^[-+U ]?[0-9a-f]{7,40}\s+(\S+)/);
     const subPath = m2?.[1];
     if (!subPath) continue;
     const abs = resolve4(base, subPath);
     if (!(abs === base || abs.startsWith(base + sep2))) continue;
-    const remote = (await git(abs, ["remote", "get-url", "origin"])).trim();
-    const branch = (await git(abs, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    const remote = (await git2(abs, ["remote", "get-url", "origin"])).trim();
+    const branch = (await git2(abs, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
     repos.push({ subdir: subPath, name: subPath, remote: remote || null, branch: branch || null });
   }
   return { repos };
@@ -41085,7 +41685,7 @@ async function gitLog(root, repo, skip, limit) {
   if (!cwd2) return { entries: [], hasMore: false };
   const capped = Math.min(Math.max(limit, 1), 200);
   const format = ["%H", "%h", "%an", "%aI", "%s"].join(FS) + RS;
-  const stdout = await git(cwd2, [
+  const stdout = await git2(cwd2, [
     "log",
     `--skip=${Math.max(skip, 0)}`,
     `-n`,
@@ -41104,7 +41704,7 @@ async function gitCommit(root, repo, hash) {
   const empty = { hash, author: "", date: "", subject: "", files: [] };
   if (!cwd2 || !hash) return empty;
   const format = ["%H", "%an", "%aI", "%s"].join(FS);
-  const stdout = await git(cwd2, [
+  const stdout = await git2(cwd2, [
     "show",
     "--name-status",
     "-M",
@@ -41131,8 +41731,8 @@ async function gitCommit(root, repo, hash) {
 async function gitCommitDiff(root, repo, hash, path) {
   const cwd2 = resolveRepo(root, repo);
   if (!cwd2 || !hash || !path) return { path, oldContent: "", newContent: "" };
-  const oldContent = await git(cwd2, ["show", `${hash}^:${path}`]);
-  const newContent = await git(cwd2, ["show", `${hash}:${path}`]);
+  const oldContent = await git2(cwd2, ["show", `${hash}^:${path}`]);
+  const newContent = await git2(cwd2, ["show", `${hash}:${path}`]);
   return { path, oldContent, newContent };
 }
 
@@ -41352,7 +41952,7 @@ function summarizeAiFailure(captured, exitCode) {
 
 // src/utils/time.ts
 function formatTimestampInZone(date, timeZone) {
-  const build = (tz) => {
+  const build2 = (tz) => {
     const parts = new Intl.DateTimeFormat("en-CA", {
       ...tz ? { timeZone: tz } : {},
       hour12: false,
@@ -41363,20 +41963,20 @@ function formatTimestampInZone(date, timeZone) {
       minute: "2-digit",
       second: "2-digit"
     }).formatToParts(date);
-    const get2 = (type) => parts.find((p2) => p2.type === type)?.value ?? "";
-    const hour = get2("hour") === "24" ? "00" : get2("hour");
-    return `${get2("year")}/${get2("month")}/${get2("day")} ${hour}:${get2("minute")}:${get2("second")}`;
+    const get3 = (type) => parts.find((p2) => p2.type === type)?.value ?? "";
+    const hour = get3("hour") === "24" ? "00" : get3("hour");
+    return `${get3("year")}/${get3("month")}/${get3("day")} ${hour}:${get3("minute")}:${get3("second")}`;
   };
   try {
-    return build(timeZone);
+    return build2(timeZone);
   } catch {
-    return build();
+    return build2();
   }
 }
 
 // src/ui/slash-commands.ts
-import { existsSync as existsSync13 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join21 } from "path";
 var CONFIG_KEYS = [
   "aiCli",
   "claudeHome",
@@ -41388,7 +41988,7 @@ var CONFIG_KEYS = [
   "aiEnv"
 ];
 function configPath(profileDir2) {
-  return join19(profileDir2, "config.json");
+  return join21(profileDir2, "config.json");
 }
 function parseConfigAssignment(key, valueTokens) {
   const value = valueTokens.join(" ").trim();
@@ -41438,7 +42038,7 @@ function runConfig(ctx) {
       ctx.print(t("slash.config.wroteDefault", { verb, path }));
       ctx.print(t("slash.config.addClaudeHint"));
     };
-    if (existsSync13(path)) {
+    if (existsSync14(path)) {
       ctx.confirm(
         t("slash.config.replaceConfirm", { path }),
         () => writeDefaults(t("slash.config.verbReplaced"))
@@ -41523,7 +42123,7 @@ function runOutput(ctx) {
 }
 function runLogs(ctx) {
   const n = Math.max(1, Math.min(200, Number(ctx.args[0]) || 20));
-  const dir2 = join19(ctx.info.profileDir, "logs");
+  const dir2 = join21(ctx.info.profileDir, "logs");
   const lines = readRecentLogLines(dir2, n);
   if (lines.length === 0) {
     ctx.print(t("slash.logs.none"));
@@ -41870,13 +42470,13 @@ async function runMemoryCompaction(ai2, cwd2, input) {
 }
 
 // src/core/git-commit-identity.ts
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
-var run5 = promisify5(execFile5);
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var run7 = promisify7(execFile7);
 async function setCommitAuthor(cwd2, machineUsername) {
   if (!machineUsername) return;
   try {
-    await run5("git", ["config", "--local", "user.name", machineUsername], { cwd: cwd2, timeout: 8e3 });
+    await run7("git", ["config", "--local", "user.name", machineUsername], { cwd: cwd2, timeout: 8e3 });
   } catch {
   }
 }
@@ -41983,10 +42583,10 @@ function activeAiRunCount() {
   return activeRuns.size;
 }
 function cancelActiveRun(commandId) {
-  const run12 = activeRuns.get(commandId);
-  if (!run12) return { ok: false, state: "unknown" };
-  run12.controller.abort();
-  return { ok: true, state: run12.state };
+  const run15 = activeRuns.get(commandId);
+  if (!run15) return { ok: false, state: "unknown" };
+  run15.controller.abort();
+  return { ok: true, state: run15.state };
 }
 function handleCommandChannels(ctx, message, payload) {
   if (message.channel === WsChannels.COMMAND_CANCEL) {
@@ -42082,17 +42682,18 @@ async function runLocalCommand(ctx, input) {
   const commandId = randomCommandId();
   await runAiPrompt(ctx, prompt, commandId, "local");
 }
+var REFUSED = { exitCode: 1, cancelled: false, exhausted: false, neverStarted: true, output: "" };
 async function runAiPrompt(ctx, prompt, commandId, origin, oneShot = false, images, aiConfig, readOnly = false, bypass = false) {
-  const run12 = { controller: new AbortController(), state: "queued" };
-  activeRuns.set(commandId, run12);
+  const run15 = { controller: new AbortController(), state: "queued" };
+  activeRuns.set(commandId, run15);
   try {
-    await runAiPromptInner(ctx, prompt, commandId, origin, run12, oneShot, images, aiConfig, readOnly, bypass);
+    return await runAiPromptInner(ctx, prompt, commandId, origin, run15, oneShot, images, aiConfig, readOnly, bypass);
   } finally {
     activeRuns.delete(commandId);
     if (!readOnly) requestGitSnapshot("ai-run");
   }
 }
-async function runAiPromptInner(ctx, prompt, commandId, origin, run12, oneShot = false, images, aiConfig, readOnly = false, bypass = false) {
+async function runAiPromptInner(ctx, prompt, commandId, origin, run15, oneShot = false, images, aiConfig, readOnly = false, bypass = false) {
   const config = readProfileConfig(ctx.profileDir);
   const projectTimeoutSec = config.projectAiRunTimeoutSec ?? 0;
   const machineTimeoutSec = config.aiRunTimeoutSec ?? 0;
@@ -42103,7 +42704,7 @@ async function runAiPromptInner(ctx, prompt, commandId, origin, run12, oneShot =
     const estimated = estimateTokens(prompt);
     if (estimated > perPromptLimit) {
       rejectPromptOverLimit(ctx, commandId, origin, prompt, estimated, perPromptLimit);
-      return;
+      return REFUSED;
     }
   }
   if (ctx.outboundReviewEnabled) {
@@ -42118,7 +42719,7 @@ async function runAiPromptInner(ctx, prompt, commandId, origin, run12, oneShot =
     }
     if (!verdict.ok) {
       rejectByReview(ctx, commandId, origin, prompt, verdict.reasons);
-      return;
+      return REFUSED;
     }
   }
   const cwd2 = ctx.physicRoot ?? config.physicPath ?? process.cwd();
@@ -42209,6 +42810,7 @@ ${guardedPrompt}`;
   let resultId = null;
   let resultBuf = "";
   let answerText = "";
+  const failReasons = [];
   const handlers = {
     onChunk: (text) => {
       if (!responseHeaderShown) {
@@ -42250,6 +42852,7 @@ ${guardedPrompt}`;
 `, log: true });
     },
     onAttemptFail: (label, reason) => {
+      failReasons.push(String(reason));
       const text = reason === "limit" ? `profile "${label}" hit its session limit \u2014 trying next` : reason === "credits" ? `profile "${label}" is out of usage credits \u2014 trying next` : reason === "auth" ? `profile "${label}" failed to authenticate \u2014 trying next` : reason === "timeout" ? `profile "${label}" timed out \u2014 trying next` : `profile "${label}" run failed \u2014 trying next`;
       ctx.bus.push({ source: origin, kind: "log", text, level: "warn" });
       ctx.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: `${text}
@@ -42273,7 +42876,7 @@ ${guardedPrompt}`;
           queue: { position, limit, running: running2 }
         });
       },
-      run12.controller.signal
+      run15.controller.signal
     );
     if (slot.kind === "timeout") {
       neverStarted = true;
@@ -42294,9 +42897,9 @@ ${guardedPrompt}`;
       result = { exitCode: COMMAND_CANCELLED_EXIT_CODE, workedDir: null, workedKey: null, workedCmd: null, usage: { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 }, sessionId: "", cancelled: true };
     } else {
       if (slot.queued) ctx.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: "", log: true, queue: null });
-      run12.state = "running";
+      run15.state = "running";
       try {
-        result = await runAiFailover(plan, commandId, cwd2, handlers, aiRunTimeoutMs, run12.controller.signal);
+        result = await runAiFailover(plan, commandId, cwd2, handlers, aiRunTimeoutMs, run15.controller.signal);
       } finally {
         slot.handle.release();
       }
@@ -42389,6 +42992,13 @@ ${guardedPrompt}`;
     ctx.sessionIdByKey.clear();
     ctx.sessionMetaByKey.clear();
   }
+  return {
+    exitCode: result.exitCode,
+    cancelled: !!result.cancelled,
+    exhausted: result.exitCode !== 0 && !result.cancelled && failReasons.length > 0 && failReasons.every((r) => r === "limit" || r === "credits"),
+    neverStarted,
+    output: answerText
+  };
 }
 function pruneResumableSessions(ctx, policy, now) {
   for (const key of [...ctx.sessionIdByKey.keys()]) {
@@ -42608,14 +43218,14 @@ function rejectByReview(ctx, commandId, origin, prompt, reasons) {
 }
 
 // src/core/git-snapshot.ts
-var run6 = promisify6(execFile6);
+var run8 = promisify8(execFile8);
 var US = "";
 var RS2 = "";
 var MIN_SPACING_MS = 15e3;
 var DEFAULT_INTERVAL_MIN = 10;
-async function git2(cwd2, args, timeout = 2e4) {
+async function git3(cwd2, args, timeout = 2e4) {
   try {
-    const { stdout } = await run6("git", args, { cwd: cwd2, timeout, maxBuffer: 16 * 1024 * 1024 });
+    const { stdout } = await run8("git", args, { cwd: cwd2, timeout, maxBuffer: 16 * 1024 * 1024 });
     return stdout;
   } catch {
     return "";
@@ -42670,13 +43280,13 @@ async function buildRepoSnapshot(dir2, subdir) {
   const L2 = GIT_SNAPSHOT_LIMITS;
   const fmt = `--format=${RS2}%H${US}%P${US}%an${US}%aI${US}%s`;
   const [abbrev, headSha, heads, remotes, remoteHead, status, gitDir] = await Promise.all([
-    git2(dir2, ["rev-parse", "--abbrev-ref", "HEAD"]),
-    git2(dir2, ["rev-parse", "--verify", "HEAD"]),
-    git2(dir2, ["for-each-ref", "refs/heads", `--format=%(refname:short)${US}%(objectname)${US}%(upstream:short)${US}%(upstream:track,nobracket)`]),
-    git2(dir2, ["for-each-ref", "refs/remotes/origin", `--format=%(refname:short)${US}%(objectname)${US}%(symref)`]),
-    git2(dir2, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]),
-    git2(dir2, ["status", "--porcelain=v2", "--untracked-files=all"]),
-    git2(dir2, ["rev-parse", "--absolute-git-dir"])
+    git3(dir2, ["rev-parse", "--abbrev-ref", "HEAD"]),
+    git3(dir2, ["rev-parse", "--verify", "HEAD"]),
+    git3(dir2, ["for-each-ref", "refs/heads", `--format=%(refname:short)${US}%(objectname)${US}%(upstream:short)${US}%(upstream:track,nobracket)`]),
+    git3(dir2, ["for-each-ref", "refs/remotes/origin", `--format=%(refname:short)${US}%(objectname)${US}%(symref)`]),
+    git3(dir2, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]),
+    git3(dir2, ["status", "--porcelain=v2", "--untracked-files=all"]),
+    git3(dir2, ["rev-parse", "--absolute-git-dir"])
   ]);
   const branchName = abbrev.trim();
   const detached = branchName === "HEAD";
@@ -42687,8 +43297,8 @@ async function buildRepoSnapshot(dir2, subdir) {
   const remoteBranches = remotes.split("\n").filter(Boolean).map((l) => l.split(US)).filter(([, , symref]) => !symref).map(([name = "", sha = ""]) => ({ name: name.replace(/^origin\//, ""), sha })).filter((b2) => b2.name && b2.name !== "origin");
   const { dirty, files } = parseStatus(status);
   const [localOut, remoteOut] = await Promise.all([
-    git2(dir2, ["log", "--branches", "--not", "--remotes", "-n", String(L2.localCommits + 1), "--name-status", fmt], 3e4),
-    git2(dir2, ["log", "--remotes", "--date-order", "-n", String(L2.remoteCommits), fmt], 3e4)
+    git3(dir2, ["log", "--branches", "--not", "--remotes", "-n", String(L2.localCommits + 1), "--name-status", fmt], 3e4),
+    git3(dir2, ["log", "--remotes", "--date-order", "-n", String(L2.remoteCommits), fmt], 3e4)
   ]);
   const localAll = parseLog(localOut, true);
   const localCommits = localAll.slice(0, L2.localCommits).map((c) => ({
@@ -42701,10 +43311,10 @@ async function buildRepoSnapshot(dir2, subdir) {
   const defaultBranch = remoteHead.trim().replace(/^origin\//, "") || null;
   const upstream = branches.find((b2) => b2.name === branchName)?.upstream;
   const baseRef = upstream ?? (defaultBranch ? `origin/${defaultBranch}` : null);
-  const baseSha = headSha.trim() && baseRef ? (await git2(dir2, ["merge-base", "HEAD", baseRef])).trim() || null : null;
+  const baseSha = headSha.trim() && baseRef ? (await git3(dir2, ["merge-base", "HEAD", baseRef])).trim() || null : null;
   let lastFetchAt = null;
   try {
-    if (gitDir.trim()) lastFetchAt = (await stat(join20(gitDir.trim(), "FETCH_HEAD"))).mtime.toISOString();
+    if (gitDir.trim()) lastFetchAt = (await stat(join22(gitDir.trim(), "FETCH_HEAD"))).mtime.toISOString();
   } catch {
     lastFetchAt = null;
   }
@@ -42732,7 +43342,7 @@ async function buildGitSnapshot(root) {
 async function fetchAll(root) {
   const base = resolve5(root);
   const { repos } = await gitRepos(base);
-  for (const r of repos) await git2(r.subdir ? resolve5(base, r.subdir) : base, ["fetch", "--prune", "--quiet", "origin"], 6e4);
+  for (const r of repos) await git3(r.subdir ? resolve5(base, r.subdir) : base, ["fetch", "--prune", "--quiet", "origin"], 6e4);
 }
 var state2 = { host: null, lastSentAt: 0, pending: null, periodic: null, running: false };
 async function reportNow(fetchFirst) {
@@ -42799,96 +43409,394 @@ function envReconnectMaxSec() {
 
 // src/core/autonomous-cycle.ts
 import { randomUUID } from "crypto";
-import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile6, readdir as readdir2, rm as rm2, stat as stat2 } from "fs/promises";
-import { join as join21 } from "path";
-function buildAutonomousCyclePrompt(opts = {}) {
-  const capNote = opts.intakeBlocked ? `
-
-**Step 2 is DISABLED this cycle** \u2014 the organization reached its monthly plan limit for new \`AI_TODO\` /
-\`USER_QA\` rows. Do NOT add any row to \`AI_TODO.md\` or \`USER_QA.md\`; skip Step 2 entirely and continue
-with the already-approved work.` : "";
-  return `You are running UNATTENDED as the 4PM autonomous cycle (headless, one tick). Do EXACTLY ONE small
-work cycle with the steps below, then STOP. Keep each cycle to ONE small task so you never run out of
-tokens mid-way. If a step fails, append a row to the **Incidents** table of \`AI_DONE.md\` and STOP \u2014
-do not push on. Write all books/docs/code in the language the project's \`CLAUDE.md\` specifies (default
-English).${capNote}
-
-## Books & approval (MUST read the approvals file)
-The five "book" files at the project root \u2014 \`USER_TODO.md\`, \`USER_QA.md\`, \`AI_TODO.md\`,
+import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile9, readdir as readdir3, rm as rm3, stat as stat2 } from "fs/promises";
+import { join as join24 } from "path";
+
+// src/core/autonomous-tasks.ts
+import { readFile as readFile8, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { join as join23 } from "path";
+var APPROVALS_REL2 = ".claude/.autonomous.approvals.json";
+function claimPath(profileDir2) {
+  return join23(profileDir2, "autonomous-claim.json");
+}
+async function readLocalClaim(profileDir2) {
+  try {
+    return JSON.parse(await readFile8(claimPath(profileDir2), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeLocalClaim(profileDir2, c) {
+  if (c) await writeFile6(claimPath(profileDir2), `${JSON.stringify(c, null, 2)}
+`, "utf8");
+  else await rm2(claimPath(profileDir2), { force: true });
+}
+function groupOf(taskId) {
+  const m2 = /^TSK-(\d+)-\d+/.exec(taskId);
+  return m2 ? `GRP-${m2[1]}` : "GRP-0000";
+}
+function taskBranch(base, taskId) {
+  return `dev/${base}/${groupOf(taskId)}/${taskId}`;
+}
+function fromHint(notes) {
+  return /(?:^|;\s*)from:\s*(\S+)/.exec(notes)?.[1] ?? null;
+}
+function doneBranch(notes) {
+  return /branch:\s*([^\s;]+)/.exec(notes)?.[1] ?? null;
+}
+async function approvedIds(root) {
+  try {
+    const map = JSON.parse(await readFile8(join23(root, APPROVALS_REL2), "utf8"));
+    return new Set(Object.entries(map).filter(([, v2]) => v2?.approved === true).map(([k2]) => k2));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function claimAgeHours(c) {
+  const t2 = parseStamp(c.started);
+  return Number.isFinite(t2) ? (Date.now() - t2) / 36e5 : Infinity;
+}
+async function claimState(root, mine, ttlHours) {
+  const row = parseClaims(await readBook(root, "AI_PROGRESS.md")).claims.find((c) => c.id === mine.id);
+  if (!row || row.claim !== mine.claim) return "lost";
+  return claimAgeHours(row) >= ttlHours ? "expired" : "live";
+}
+async function pickTask(root, rootBase, opts) {
+  const [todo, prog, done, qa, attempts, approved] = await Promise.all([
+    readBook(root, "AI_TODO.md"),
+    readBook(root, "AI_PROGRESS.md"),
+    readBook(root, "AI_DONE.md"),
+    readBook(root, "USER_QA.md"),
+    readAttempts(root),
+    approvedIds(root)
+  ]);
+  const claims = parseClaims(prog).claims;
+  const skip = opts.skip ?? /* @__PURE__ */ new Set();
+  for (const c of claims) {
+    if (skip.has(c.id) || c.worker === opts.worker || claimAgeHours(c) < opts.ttlHours) continue;
+    const snap = attempts[c.id]?.task;
+    const task = snap ?? { id: c.id, priority: "Medium", tag: "", depends: [], group: groupOf(c.id), desc: c.desc, notes: "" };
+    return { task, takeover: c, from: null };
+  }
+  const doneMap = doneRows(done);
+  const qaRows = new Map(parseQa(qa).rows.map((q2) => [q2.id, q2]));
+  const claimed = new Set(claims.map((c) => c.id));
+  const rank = (p2) => ({ high: 0, medium: 1, low: 2 })[p2.trim().toLowerCase()] ?? 1;
+  const groupNum = (id) => Number(/^TSK-(\d+)/.exec(id)?.[1] ?? 9999);
+  const tasks = parseTasks(todo).tasks.map((t2, i) => ({ t: t2, i })).sort((a, b2) => groupNum(a.t.id) - groupNum(b2.t.id) || rank(a.t.priority) - rank(b2.t.priority) || a.i - b2.i);
+  for (const { t: t2 } of tasks) {
+    if (skip.has(t2.id) || claimed.has(t2.id) || !approved.has(t2.id)) continue;
+    const a = attempts[t2.id];
+    if (a && (a.splitPending || a.count >= opts.maxAttempts)) continue;
+    const qaOk = t2.depends.filter((d) => d.startsWith("QA-")).every((d) => {
+      const q2 = qaRows.get(d);
+      return !q2 || q2.answer.trim().length > 0 && approved.has(d);
+    });
+    if (!qaOk) continue;
+    const deps = t2.depends.filter((d) => d.startsWith("TSK-"));
+    if (deps.some((d) => !doneMap.has(d))) continue;
+    let from = null;
+    if (deps.length === 1) {
+      const dep = deps[0];
+      const branch = doneBranch(doneMap.get(dep) ?? "") ?? taskBranch(rootBase.base, dep);
+      if (!await isMerged(root, rootBase.url, branch, rootBase.base)) from = branch;
+    } else if (deps.length >= 2) {
+      let allMerged = true;
+      for (const dep of deps) {
+        const branch = doneBranch(doneMap.get(dep) ?? "") ?? taskBranch(rootBase.base, dep);
+        if (!await isMerged(root, rootBase.url, branch, rootBase.base)) {
+          allMerged = false;
+          break;
+        }
+      }
+      if (!allMerged) continue;
+    }
+    return { task: t2, takeover: null, from: fromHint(t2.notes) ?? from };
+  }
+  return null;
+}
+async function applyClaim(root, cand, mine, ttlHours) {
+  const [todo, prog, done, attempts] = await Promise.all([
+    readBook(root, "AI_TODO.md"),
+    readBook(root, "AI_PROGRESS.md"),
+    readBook(root, "AI_DONE.md"),
+    readAttempts(root)
+  ]);
+  const claims = parseClaims(prog).claims;
+  const existing = claims.find((c) => c.id === cand.task.id);
+  let incident = null;
+  if (cand.takeover) {
+    if (!existing || existing.claim !== cand.takeover.claim || claimAgeHours(existing) < ttlHours) return false;
+    incident = `Claim of ${cand.task.id} by ${existing.worker} expired (${ttlHours} h) \u2014 taken over by ${mine.worker}.`;
+    attempts[cand.task.id] = { ...attempts[cand.task.id] ?? {}, count: (attempts[cand.task.id]?.count ?? 0) + 1, last: "claim expired (taken over)", at: (/* @__PURE__ */ new Date()).toISOString() };
+  } else {
+    if (existing) return false;
+    const { tasks } = parseTasks(todo);
+    if (!tasks.some((t2) => t2.id === cand.task.id)) return false;
+    await writeBook(root, "AI_TODO.md", writeTasks(todo, tasks.filter((t2) => t2.id !== cand.task.id)));
+    attempts[cand.task.id] = { ...attempts[cand.task.id] ?? { count: 0, last: "", at: "" }, task: cand.task };
+  }
+  const row = { started: mine.started, id: cand.task.id, worker: mine.worker, claim: mine.claim, attempt: mine.attempt, desc: cand.task.desc };
+  await writeBook(root, "AI_PROGRESS.md", writeClaims(prog, [...claims.filter((c) => c.id !== cand.task.id), row]));
+  if (cand.takeover) attempts[cand.task.id] = { ...attempts[cand.task.id], task: attempts[cand.task.id]?.task ?? cand.task };
+  await writeAttempts(root, attempts);
+  if (incident) await writeBook(root, "AI_DONE.md", appendIncident(done, incident));
+  return true;
+}
+async function dropClaim(root, mine) {
+  const prog = await readBook(root, "AI_PROGRESS.md");
+  const claims = parseClaims(prog).claims;
+  const row = claims.find((c) => c.id === mine.id);
+  if (!row || row.claim !== mine.claim) return false;
+  await writeBook(root, "AI_PROGRESS.md", writeClaims(prog, claims.filter((c) => c.id !== mine.id)));
+  return true;
+}
+async function applyFinish(root, mine, done) {
+  if (!await dropClaim(root, mine)) return false;
+  await writeBook(root, "AI_DONE.md", appendDone(await readBook(root, "AI_DONE.md"), { id: mine.id, desc: mine.task.desc, files: done.files, notes: done.notes }));
+  const attempts = await readAttempts(root);
+  delete attempts[mine.id];
+  await writeAttempts(root, attempts);
+  return true;
+}
+async function applyRelease(root, mine, reason, maxAttempts) {
+  if (!await dropClaim(root, mine)) return null;
+  const attempts = await readAttempts(root);
+  const count = (attempts[mine.id]?.count ?? 0) + 1;
+  attempts[mine.id] = { ...attempts[mine.id] ?? {}, count, last: reason.slice(0, 300), at: (/* @__PURE__ */ new Date()).toISOString(), ...count >= maxAttempts ? { splitPending: true } : {} };
+  await writeAttempts(root, attempts);
+  const todo = await readBook(root, "AI_TODO.md");
+  const { tasks } = parseTasks(todo);
+  const back = { ...mine.task, notes: appendNote(mine.task.notes, `attempt ${count} ended: ${reason.slice(0, 160)}; WIP on ${mine.branch}`) };
+  await writeBook(root, "AI_TODO.md", writeTasks(todo, [...tasks.filter((t2) => t2.id !== mine.id), back]));
+  await writeBook(root, "AI_DONE.md", appendIncident(await readBook(root, "AI_DONE.md"), `${mine.id} attempt ${count} by ${mine.worker}: ${reason.slice(0, 200)} \u2014 returned to AI_TODO (WIP pushed on ${mine.branch}).`));
+  return count;
+}
+function nextId(prefix, group, texts) {
+  const re2 = new RegExp(`${prefix}-${group}-(\\d+)`, "g");
+  let max = 0;
+  for (const t2 of texts) for (const m2 of t2.matchAll(re2)) max = Math.max(max, Number(m2[1]));
+  return `${prefix}-${group}-${String(max + 1).padStart(4, "0")}`;
+}
+function appendNote(notes, add) {
+  return notes.trim() ? `${notes.trim()}; ${add}` : add;
+}
+async function applyQuestion(root, mine, question, resetAttempts = false) {
+  if (!await dropClaim(root, mine)) return null;
+  if (resetAttempts) {
+    const attempts = await readAttempts(root);
+    delete attempts[mine.id];
+    await writeAttempts(root, attempts);
+  }
+  const [todo, qa, done, attemptsText] = await Promise.all([
+    readBook(root, "AI_TODO.md"),
+    readBook(root, "USER_QA.md"),
+    readBook(root, "AI_DONE.md"),
+    readBook(root, ATTEMPTS_REL)
+  ]);
+  const g2 = /^TSK-(\d+)/.exec(mine.id)?.[1] ?? "0000";
+  const qaId = nextId("QA", g2, [qa, todo, done, attemptsText]);
+  const { rows } = parseQa(qa);
+  const qaDeps = mine.task.depends.filter((d) => d.startsWith("QA-")).join(", ");
+  await writeBook(root, "USER_QA.md", writeQa(qa, [...rows, { id: qaId, group: mine.task.group, depends: qaDeps, original: `${mine.id}: ${mine.task.desc}`, question, answer: "" }]));
+  const { tasks } = parseTasks(todo);
+  const back = { ...mine.task, depends: [...mine.task.depends.filter((d) => d !== qaId), qaId], notes: appendNote(mine.task.notes, `waiting for ${qaId}; WIP on ${mine.branch}`) };
+  await writeBook(root, "AI_TODO.md", writeTasks(todo, [...tasks.filter((t2) => t2.id !== mine.id), back]));
+  return qaId;
+}
+async function foldTaskAnswers(root) {
+  const [todo, qa, approved] = await Promise.all([readBook(root, "AI_TODO.md"), readBook(root, "USER_QA.md"), approvedIds(root)]);
+  const { tasks } = parseTasks(todo);
+  const { rows } = parseQa(qa);
+  const answered = rows.filter((q2) => q2.answer.trim() && approved.has(q2.id) && tasks.some((t2) => t2.depends.includes(q2.id)));
+  if (answered.length === 0) return false;
+  const byId = new Map(answered.map((q2) => [q2.id, q2]));
+  const next = tasks.map((t2) => {
+    const add = t2.depends.filter((d) => byId.has(d)).map((d) => `answer ${d}: ${byId.get(d).answer}`);
+    return add.length ? { ...t2, notes: appendNote(t2.notes, add.join("; ")) } : t2;
+  });
+  await writeBook(root, "AI_TODO.md", writeTasks(todo, next));
+  await writeBook(root, "USER_QA.md", writeQa(qa, rows.filter((q2) => !byId.has(q2.id))));
+  return true;
+}
+async function hasIntakeWork(root) {
+  const [userTodo, todo, qa, approved] = await Promise.all([
+    readBook(root, "USER_TODO.md"),
+    readBook(root, "AI_TODO.md"),
+    readBook(root, "USER_QA.md"),
+    approvedIds(root)
+  ]);
+  if ([...approved].some((id) => id.startsWith("REQ-") && userTodo.includes(id))) return true;
+  const taskDeps = new Set(parseTasks(todo).tasks.flatMap((t2) => t2.depends));
+  return parseQa(qa).rows.some((q2) => !taskDeps.has(q2.id) && q2.answer.trim() && approved.has(q2.id));
+}
+async function applySplit(root, mine, children) {
+  if (!await dropClaim(root, mine)) return null;
+  const [todo, done, prog] = await Promise.all([readBook(root, "AI_TODO.md"), readBook(root, "AI_DONE.md"), readBook(root, "AI_PROGRESS.md")]);
+  const g2 = /^TSK-(\d+)/.exec(mine.id)?.[1] ?? "0000";
+  const texts = [todo, done, prog, mine.id];
+  const ids = [];
+  const rows = children.map((c, i) => {
+    const id = nextId("TSK", g2, [...texts, ...ids]);
+    ids.push(id);
+    const deps = i === 0 ? mine.task.depends : [ids[i - 1]];
+    const notes = [c.size ? `size: ${c.size}` : "", c.notes ?? "", `split from ${mine.id}`, i === 0 ? `from: ${mine.branch}` : ""].filter(Boolean).join("; ");
+    return { id, priority: c.priority || mine.task.priority || "Medium", tag: "", depends: deps, group: mine.task.group, desc: c.desc, notes };
+  });
+  const { tasks } = parseTasks(todo);
+  await writeBook(root, "AI_TODO.md", writeTasks(todo, [...tasks, ...rows]));
+  await writeBook(root, "AI_DONE.md", appendDone(done, { id: mine.id, desc: mine.task.desc, files: "", notes: `split into ${ids.join(", ")} (after repeated attempts); WIP on ${mine.branch}` }));
+  const attempts = await readAttempts(root);
+  delete attempts[mine.id];
+  await writeAttempts(root, attempts);
+  return ids;
+}
+function isSplitChild(task) {
+  return /split from TSK-/.test(task.notes);
+}
+
+// src/core/autonomous-cycle.ts
+var BOOKS_INTRO = `The five "book" files at the project root \u2014 \`USER_TODO.md\`, \`USER_QA.md\`, \`AI_TODO.md\`,
 \`AI_PROGRESS.md\`, \`AI_DONE.md\` \u2014 have canonical templates in \`.claude/templates/\` (\`<NAME>.empty.md\`
-= EMPTY, \`<NAME>.sample.md\` = example WITH DATA). To tell empty/has-work, COMPARE a book to its
-\`<NAME>.empty.md\` (equal after trimming \u21D2 empty). When clearing a book, overwrite it with EXACTLY the
-empty template (\`cp .claude/templates/<NAME>.empty.md <NAME>\`).
-
-The single source of truth for approval is \`.claude/.autonomous.approvals.json\` \u2014 a map
-\`{ "<ID>": { "approved": true, "by": "...", "at": "..." } }\` (the user ticks rows in the web grids). A
-row is APPROVED only when its ID has \`"approved": true\`. Row IDs: \`USER_TODO\` = \`REQ-\u2026\`, \`USER_QA\`
-= \`QA-\u2026\`, \`AI_TODO\` = \`TSK-\u2026\`. NEVER act on an unapproved row.
-
-## Step 1 \u2014 Base branch (from the spec, ADR-0292)
-The project root IS the primary repo (ADR-0314). Its currently checked-out branch is the base branch
-(4PM cloned it with \`-b <branch>\`): \`BASE=$(git rev-parse --abbrev-ref HEAD)\`. Sync it:
-\`git fetch origin\` then \`git pull --ff-only origin "$BASE"\` (skip the pull if the remote has no such
-branch yet). Do NOT invent a separate integration/dev branch.
-
-## Step 2 \u2014 Intake APPROVED user requests \u2192 tasks
-Read \`USER_TODO.md\` (content-only columns \`ID | Group | Depends | Request\`; who/when wrote or approved a
-row lives in \`.claude/.autonomous.authors.json\` / \`.autonomous.approvals.json\`, ADR-0320 \u2014 never add
-provenance columns to the table). For each row that is APPROVED (its \`REQ-\u2026\` in the approvals file) AND
-whose \`Depends\` \`REQ-\u2026\` are already handled:
-- If the request is CLEAR: split it into small tasks and append them to \`AI_TODO.md\` (7 columns
-  \`ID | Priority | Tag | Depends | Group | Task description | Notes\`), each with an ID
-  \`TSK-{groupid:0000}-{taskid:0000}\`. **groupid** must be UNIQUE + INCREASING across all history \u2014 find
-  the largest ever used in git history of \`AI_TODO.md\`/\`AI_DONE.md\`/\`AI_PROGRESS.md\`, then use max+1;
-  **taskid** starts at 0001 within the group. Leave \`Tag\` blank unless a catalog tag applies; leave
-  \`Priority\` = High/Medium/Low (default Medium). Then REMOVE the analysed request row from
-  \`USER_TODO.md\` (if it becomes empty, reset it to the empty template).
-- If the request is UNCLEAR (ambiguous/missing info/contradictory): do NOT guess. Append a row to
-  \`USER_QA.md\` (content-only columns \`ID | Group | Depends | Original request | Question / options |
-  Answer\`) with a new \`QA-{groupid:0000}-{qaid:0000}\` id, the original request and the question +
-  options; leave \`Answer\` blank for the user. Remove the request row from \`USER_TODO.md\`. (Do NOT
-  generate tasks for it.)
-An unapproved request row is LEFT in place (wait for approval).
-
-## Step 3 \u2014 Fold APPROVED answers back (USER_QA)
-For each \`USER_QA.md\` row that has an \`Answer\` AND is APPROVED (its \`QA-\u2026\` in the approvals file):
-re-analyse using the answer \u2014 append the resulting tasks to \`AI_TODO.md\` (same ID rules as Step 2) \u2014
-then clear that QA row. An unanswered or unapproved QA row is left in place.
-
-## Step 4 \u2014 Pick ONE approved task and start it
-Read \`AI_TODO.md\` + the approvals file. Filter tasks that are BOTH approved (\`TSK-\u2026\` in approvals) AND
-have every \`Depends\` \`TSK-\u2026\` already in \`AI_DONE.md\`. Run group by group (smallest eligible group
-first), within a group High \u2192 Medium \u2192 Low, then line order. If NO eligible task: append a row to the
-\`AI_DONE.md\` Incidents table (e.g. "only generated tasks / waiting for approval / waiting for deps")
-and STOP. Otherwise move the chosen task into \`AI_PROGRESS.md\` (with a start timestamp), remove it from
-\`AI_TODO.md\`, and commit on the base branch: \`git commit -am "chore(auto): start TSK-\u2026"\`.
-
-## Step 5 \u2014 Implement on a task branch + test
-\`git checkout -b task/TSK-\u2026\`. Implement following the project's architecture + \`CLAUDE.md\`; add/update
-tests. Run the project's test command (per \`CLAUDE.md\` / the project's scripts); WAIT for it to finish
-and check the result. Keep any produced report/evidence. Commit: \`git commit -am "feat(TSK-\u2026): <desc>"\`.
-
-## Step 6 \u2014 Pull request into the base branch (NO direct merge \u2014 ADR-0319/0271)
-1. Rebase onto the freshest base to minimise conflicts: \`git fetch origin\` then
-   \`git rebase origin/"$BASE"\` (on conflict you can't resolve confidently, \`git rebase --abort\`, write a
-   \`USER_QA.md\` row, and STOP).
-2. Push the task branch: \`git push -u origin task/TSK-\u2026\`.
-3. Open a PR into the base branch with \`gh\` (GitHub) or \`glab\` (GitLab) \u2014 e.g.
-   \`gh pr create --base "$BASE" --head task/TSK-\u2026 --title "TSK-\u2026: <desc>" --body "<summary>"\`. Do NOT
-   merge it and do NOT fast-forward the base yourself \u2014 a human reviews the PR. If no remote / no
-   \`gh\`/\`glab\` auth is available, keep the local task-branch commit and append an Incidents row saying
-   the PR could not be opened.
-
-## Step 7 \u2014 Update the books
-On the base branch, append a row to the \`AI_DONE.md\` Done table (Timestamp, ID, Task description, Files,
-Notes \u2014 include the PR link if opened) and REMOVE the task from \`AI_PROGRESS.md\` (reset it to the empty
-template if nothing is in progress). Commit + push the base branch:
-\`git commit -am "chore(auto): finish TSK-\u2026 (PR opened)" && git push origin "$BASE"\` (a push rejected as
-non-fast-forward \u21D2 \`git pull --rebase origin "$BASE"\` then push again).
-
-## Step 8 \u2014 Stop
-Print a one-line summary (task id + PR link or incident). STOP \u2014 the next cron tick runs the next cycle.
-The 4PM cli serializes cycles (one at a time); you do NOT manage any run lock.`;
+= EMPTY, \`<NAME>.sample.md\` = example WITH DATA). When clearing a book, overwrite it with EXACTLY the
+empty template. The single source of truth for approval is \`.claude/.autonomous.approvals.json\`
+(\`{ "<ID>": { "approved": true, \u2026 } }\`); a row is APPROVED only when its id has \`"approved": true\`.
+NEVER act on an unapproved row.`;
+function buildIntakePrompt(cfg) {
+  const h = cfg.taskSizeHints;
+  return `You are the 4PM autonomous INTAKE step (headless). Edit ONLY \`USER_TODO.md\`, \`USER_QA.md\` and
+\`AI_TODO.md\`. Do NOT run git, do NOT touch \`AI_PROGRESS.md\` / \`AI_DONE.md\` / any code \u2014 the 4PM cli
+commits and publishes your book edits. Write in the language the project's \`CLAUDE.md\` specifies (default English).
+
+${BOOKS_INTRO}
+
+## 1 \u2014 Approved user requests \u2192 tasks
+Read \`USER_TODO.md\` (columns \`ID | Group | Depends | Request\`). For each APPROVED \`REQ-\u2026\` whose \`Depends\`
+are already handled:
+- CLEAR request \u21D2 split it into tasks appended to \`AI_TODO.md\` (columns
+  \`ID | Priority | Tag | Depends | Group | Task description | Notes\`), ids \`TSK-{groupid:0000}-{taskid:0000}\`
+  (groupid UNIQUE + INCREASING across all history \u2014 the largest ever used in \`AI_TODO.md\`/\`AI_DONE.md\`/
+  \`AI_PROGRESS.md\`/their git history, +1; taskid from 0001). \`Depends\` = the \`TSK-\u2026\` it needs.
+  Remove the analysed request row (empty \u21D2 reset to the empty template).
+- UNCLEAR request \u21D2 do NOT guess: append a \`USER_QA.md\` row (\`ID | Group | Depends | Original request |
+  Question / options | Answer\`) with a new \`QA-{groupid:0000}-{qaid:0000}\`, blank \`Answer\`; remove the request row.
+An unapproved request stays.
+
+## 2 \u2014 Answered intake questions
+For each \`USER_QA.md\` row with an \`Answer\`, APPROVED, and whose id is NOT in any \`AI_TODO.md\` \`Depends\`
+(those are task questions \u2014 the cli handles them; leave them alone): re-analyse the original request with the
+answer into tasks (same rules), then remove that QA row.
+
+## Task size (MANDATORY \u2014 every task must be finishable in ONE run)
+Size each task by SCOPE and write \`size: S\` or \`size: M\` at the start of \`Notes\`:
+- **S** \u2014 one small change in one module/layer (\u2248 \u2264 ${h.sMaxFiles} files, \u2248 \u2264 ${h.sMaxLines} lines), e.g. fix a bug, add a field.
+- **M** \u2014 one feature slice across 2\u20133 layers with ONE purpose (\u2248 \u2264 ${h.mMaxFiles} files, \u2248 \u2264 ${h.mMaxLines} lines), e.g. one CRUD screen, one API + its UI + tests.
+- **L** \u2014 several features, a cross-cutting change, a big migration, a new subsystem, or an architecture decision.
+  **Never write an L task**: split it into S/M tasks chained with \`Depends\`, or ask in \`USER_QA.md\` when the split needs a decision.
+The counts are hints, not hard limits. Each task's \`Task description\` states the acceptance criteria and how to test it.
+
+When done, reply with one short line summarising what you added.`;
+}
+function buildImplementPrompt(mine, subs, resumed) {
+  const subLines = subs.length ? subs.map((s3) => `- submodule \`${s3.dir}\` is on branch \`${s3.branch}\` \u2014 commit changes to it INSIDE \`${s3.dir}\``).join("\n") : "- (no submodules)";
+  return `You are the 4PM autonomous IMPLEMENT step (headless). Implement exactly ONE task, then STOP.
+
+Task ${mine.id} (group ${mine.task.group}, attempt ${mine.attempt}):
+${mine.task.desc}
+Notes: ${mine.task.notes || "(none)"}
+${resumed ? "\nThis is a CONTINUATION: earlier work for this task is already committed on the branches below \u2014 review it (git log / git diff against the base) and continue from it; do not start over.\n" : ""}
+Branches (already checked out by the 4PM cli \u2014 stay on them):
+- project root is on \`${mine.branch}\`
+${subLines}
+
+Rules:
+- Follow the project's architecture and \`CLAUDE.md\`. Add/update tests; run the project's test command and WAIT for the result.
+- Commit your work (\`git add\` + \`git commit\`) in the root and/or inside each submodule you changed.
+- Do NOT push, do NOT open pull requests, do NOT switch/create branches, do NOT edit the book files
+  (USER_TODO/USER_QA/AI_TODO/AI_PROGRESS/AI_DONE) \u2014 the 4PM cli delivers and records everything.
+- If you need a human DECISION to continue (ambiguous requirement, missing information, a choice with real
+  trade-offs), do NOT guess: commit what you have and report \`needs-input\` with the question + options.
+
+Finish with ONLY one fenced \`json\` block:
+{"status": "done" | "needs-input" | "failed", "summary": "<what you did / why it failed>", "question": "<only for needs-input: the question and the options>"}`;
+}
+function buildSplitPrompt(mine, reasons, diff2) {
+  return `You are the 4PM autonomous SPLIT step (read-only \u2014 do not change any file). Task ${mine.id} failed to
+finish after repeated attempts, so it is probably too big for one run. Split it into 2\u20136 smaller child tasks
+that are each finishable in ONE run (size S or M), in execution order (each depends on the previous).
+
+Task: ${mine.task.desc}
+Notes: ${mine.task.notes || "(none)"}
+Why the attempts ended: ${reasons || "(unknown)"}
+Work already done on its WIP branch \`${mine.branch}\` (diff against the base, may be truncated):
+\`\`\`
+${diff2 || "(no changes yet)"}
+\`\`\`
+The first child continues from that WIP branch: note which parts are already done so they are not redone.
+Each child description must state its acceptance criteria and how to test it.
+
+Reply with ONLY one fenced \`json\` block:
+{"children": [{"desc": "<task + acceptance criteria>", "priority": "High|Medium|Low", "size": "S|M", "notes": "<optional>"}]}`;
+}
+function parseJsonReply(text) {
+  const fenced = [...text.matchAll(/```json\s*([\s\S]*?)```/gi)].map((m2) => m2[1].trim());
+  const candidates = fenced.length ? fenced.reverse() : [text.slice(text.lastIndexOf("{"), text.lastIndexOf("}") + 1)];
+  for (const c of candidates) {
+    try {
+      return JSON.parse(c);
+    } catch {
+    }
+  }
+  return null;
+}
+var watch = {
+  commandId: null,
+  claim: null,
+  root: null,
+  lost: false
+};
+async function verifyHeldClaim(ctx) {
+  const { claim, root, commandId } = watch;
+  if (!claim || !root || !commandId || watch.lost) return;
+  const prog = await remoteBook(root, claim.base, "AI_PROGRESS.md");
+  if (!prog) return;
+  const row = parseClaims(prog).claims.find((c) => c.id === claim.id);
+  if (!row || row.claim !== claim.claim) {
+    watch.lost = true;
+    ctx.bus.log(`autonomous: claim of ${claim.id} was taken over \u2014 stopping this run`, "warn");
+    cancelActiveRun(commandId);
+  }
+}
+function onReconnectVerifyClaim(ctx) {
+  void verifyHeldClaim(ctx).catch(() => void 0);
+}
+function alert(ctx, payload) {
+  try {
+    ctx.send(WsChannels.AUTONOMOUS_ALERT, payload);
+  } catch {
+  }
+}
+function subBranches(subs, taskId, rootFrom) {
+  const fromTask = rootFrom ? rootFrom.split("/").pop() ?? null : null;
+  return subs.filter((s3) => s3.base).map((s3) => ({ sub: s3, branch: taskBranch(s3.base, taskId), from: fromTask ? taskBranch(s3.base, fromTask) : null }));
+}
+async function pushWip(root, mine, subs, note) {
+  for (const s3 of subs) {
+    const abs = join24(root, s3.sub.dir);
+    if (await currentBranch(abs) !== s3.branch) continue;
+    await wipCommit(abs, `wip(${mine.id}): ${note}`);
+    if (await aheadOf(abs, s3.branch, s3.sub.base) > 0) await pushBranch(abs, s3.branch).catch(() => void 0);
+  }
+  if (await currentBranch(root) === mine.branch) {
+    await wipCommit(root, `wip(${mine.id}): ${note}`);
+    await pushBranch(root, mine.branch).catch(() => void 0);
+  }
+}
+async function wipDiff(root, mine) {
+  const stat6 = await gitQuiet(root, ["diff", "--stat", `origin/${mine.base}...${mine.branch}`]);
+  const patch = await gitQuiet(root, ["diff", `origin/${mine.base}...${mine.branch}`]);
+  return `${stat6}
+${patch}`.slice(0, 2e4);
 }
 var running = /* @__PURE__ */ new Set();
 async function runAutonomousCycle(ctx) {
@@ -42908,6 +43816,7 @@ async function runAutonomousCycle(ctx) {
     const cfg = await readAutonomousConfig(profileDir2);
     await pruneLogs(root, cfg.logRetentionDays);
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const worker = ctx.machineUsername || "worker";
     if (!ctx.isReady) {
       await log("[skip] cli offline (no WS connection)");
       ctx.bus.autonomousDone(false, "cli offline");
@@ -42929,13 +43838,53 @@ async function runAutonomousCycle(ctx) {
       ctx.bus.autonomousDone(false, "max ticks reached");
       return;
     }
-    if (!await hasWork(root)) {
-      await log("[skip] no approved USER_TODO/USER_QA/AI_TODO work, AI_PROGRESS empty");
+    const bases = await resolveBases(root);
+    const rootBase = bases.root;
+    if (!rootBase.base) {
+      await log("[skip] base branch unknown (no spec branch, no origin/HEAD)");
+      ctx.bus.autonomousDone(false, "base branch unknown");
+      return;
+    }
+    for (const r of [rootBase, ...bases.subs]) {
+      if (!r.base || !r.url) continue;
+      if (await branchProtection(r.url, r.base) === true) {
+        const repo = r.dir || "root";
+        await log(`[stop] base branch "${r.base}" is protected in ${repo} \u2014 the books cannot be pushed`);
+        alert(ctx, { kind: "base-protected", repo, branch: r.base, message: `The base branch "${r.base}" (${repo}) is protected; autonomous cannot record its tasks there.` });
+        await recordRun(root, hist, "skip", `base-protected: ${r.base} (${repo})`, today);
+        ctx.bus.autonomousDone(false, "base branch protected");
+        return;
+      }
+    }
+    await syncBase(root, rootBase.base);
+    let mine = await readLocalClaim(profileDir2);
+    if (mine && mine.base !== rootBase.base) mine = null;
+    if (mine) {
+      const state3 = await claimState(root, mine, cfg.claimTtlHours);
+      if (state3 === "lost") {
+        await log(`[lost] claim of ${mine.id} was taken over \u2014 dropping local work (kept on ${mine.branch} locally)`);
+        await publishBooks(root, rootBase.base, `chore(auto): incident \u2014 ${mine.id} claim lost by ${worker}`, async () => {
+          await writeBook(root, "AI_DONE.md", appendIncident(await readBook(root, "AI_DONE.md"), `${worker} lost its claim of ${mine.id} (taken over); its local work was not pushed.`));
+          return true;
+        });
+        alert(ctx, { kind: "claim-lost", task: mine.id, message: `${worker} lost its claim of ${mine.id}.` });
+        await writeLocalClaim(profileDir2, null);
+        mine = null;
+      } else if (state3 === "expired") {
+        await log(`[release] claim of ${mine.id} reached ${cfg.claimTtlHours} h \u2014 pushing WIP and returning the task`);
+        await checkoutTaskBranch(root, mine.branch, rootBase.base, null).catch(() => void 0);
+        await releaseTask(ctx, root, rootBase, bases.subs, mine, `not finished within ${cfg.claimTtlHours} h`, cfg);
+        ctx.bus.autonomousDone(false, "claim expired \u2014 task returned");
+        return;
+      }
+    }
+    if (!mine && !await hasWork(root)) {
+      await log("[skip] no approved USER_TODO/USER_QA/AI_TODO work");
       ctx.bus.autonomousDone(false, "no work");
       return;
     }
     if (await allAiProfilesExhausted(ctx, cfg)) {
-      await log(`[skip] all AI profiles over usage limit (\u2265 ${cfg.maxSessionPct}%/${cfg.maxWeeklyPct}%)`);
+      await log(`[skip] all AI profiles over usage limit (\u2265 ${cfg.maxSessionPct}%/${cfg.maxWeeklyPct}%)${mine ? ` \u2014 ${mine.id} kept` : ""}`);
       await recordRun(root, hist, "skip", "all AI profiles over usage limit", today);
       ctx.bus.autonomousDone(false, "usage limit");
       return;
@@ -42943,42 +43892,244 @@ async function runAutonomousCycle(ctx) {
     hist.ticks = { day: today, count: todayTickCount(hist, today) + 1 };
     await writeHistories(root, hist);
     await log(`[run] cycle (tick ${hist.ticks.count}/${today})`);
-    const commandId = randomUUID();
     const override = cfg.model ? { model: cfg.model } : void 0;
-    const usage = await readBookUsage(ctx);
-    const intakeBlocked = ["AI_TODO", "USER_QA"].some((b2) => {
-      const c = usage?.books[b2];
-      return !!c && c.limit !== null && c.used >= c.limit;
-    });
-    if (intakeBlocked) await log("[cap] monthly AI_TODO/USER_QA limit reached \u2014 intake skipped this cycle");
-    const booksBefore = await cappedBookIds(root);
+    let resumed = !!mine;
+    if (!mine) {
+      const folded = await publishBooks(root, rootBase.base, "chore(auto): fold answered task questions", () => foldTaskAnswers(root));
+      if (folded === "pushed") await log("[fold] task-question answers folded into their tasks");
+      const usage = await readBookUsage(ctx);
+      const intakeBlocked = ["AI_TODO", "USER_QA"].some((b2) => {
+        const c = usage?.books[b2];
+        return !!c && c.limit !== null && c.used >= c.limit;
+      });
+      if (intakeBlocked) await log("[cap] monthly AI_TODO/USER_QA limit reached \u2014 intake skipped this cycle");
+      else if (await hasIntakeWork(root)) {
+        const before = await cappedBookIds(root);
+        const out2 = await runAiPrompt(ctx, buildIntakePrompt(cfg), randomUUID(), "local", false, void 0, override, false, true);
+        if (out2.exhausted) {
+          await gitQuiet(root, ["checkout", "--", "."]);
+          await log("[skip] usage limit during intake");
+          ctx.bus.autonomousDone(false, "usage limit");
+          return;
+        }
+        const res = await publishIntake(root, rootBase.base, "chore(auto): intake requests into tasks");
+        await log(`[intake] ${res}`);
+        if (res === "pushed") await reportNewBookRows(ctx, root, before);
+        await syncBase(root, rootBase.base);
+      }
+      const skip = /* @__PURE__ */ new Set();
+      for (let i = 0; i < 5 && !mine; i++) {
+        const cand = await pickTask(root, rootBase, { worker, ttlHours: cfg.claimTtlHours, maxAttempts: cfg.maxTaskAttempts, skip });
+        if (!cand) break;
+        const attempts = await readAttempts(root);
+        const claim = {
+          id: cand.task.id,
+          claim: randomUUID(),
+          worker,
+          started: stamp(),
+          attempt: (attempts[cand.task.id]?.count ?? 0) + 1 + (cand.takeover ? 1 : 0),
+          branch: taskBranch(rootBase.base, cand.task.id),
+          base: rootBase.base,
+          task: cand.task
+        };
+        const res = await publishBooks(
+          root,
+          rootBase.base,
+          `chore(auto): claim ${cand.task.id} by ${worker}`,
+          () => applyClaim(root, cand, claim, cfg.claimTtlHours)
+        );
+        if (res === "pushed") {
+          mine = { ...claim, from: cand.from };
+          await writeLocalClaim(profileDir2, mine);
+          await log(`[claim] ${mine.id}${cand.takeover ? ` (taken over from ${cand.takeover.worker})` : ""} attempt ${mine.attempt}`);
+        } else skip.add(cand.task.id);
+      }
+      if (!mine) {
+        await log("[idle] no eligible task (waiting for approval / dependencies / answers)");
+        hist = await readHistories(root);
+        await recordRun(root, hist, "success", "no eligible task", today);
+        ctx.bus.autonomousDone(true);
+        return;
+      }
+      resumed = false;
+    }
+    const from = mine.from ?? null;
+    await checkoutTaskBranch(root, mine.branch, rootBase.base, from);
+    const hadWork = await aheadOf(root, mine.branch, rootBase.base) > 0;
+    await gitQuiet(root, ["submodule", "update", "--init", "-q"], 3e5);
+    const subs = subBranches(bases.subs, mine.id, from);
+    for (const s3 of subs) await checkoutTaskBranch(join24(root, s3.sub.dir), s3.branch, s3.sub.base, s3.from).catch((e) => log(`[warn] submodule ${s3.sub.dir}: ${String(e)}`));
+    const commandId = randomUUID();
+    Object.assign(watch, { commandId, claim: mine, root, lost: false });
+    const timer = setInterval(() => void verifyHeldClaim(ctx).catch(() => void 0), cfg.claimCheckMinutes * 6e4);
+    timer.unref?.();
+    let out;
     try {
-      await runAiPrompt(ctx, buildAutonomousCyclePrompt({ intakeBlocked }), commandId, "local", false, void 0, override, false, true);
-      await reportNewBookRows(ctx, root, booksBefore);
+      out = await runAiPrompt(ctx, buildImplementPrompt(mine, subs.map((s3) => ({ dir: s3.sub.dir, branch: s3.branch })), resumed || hadWork), commandId, "local", false, void 0, override, false, true);
+    } finally {
+      clearInterval(timer);
+    }
+    const lost = watch.lost;
+    Object.assign(watch, { commandId: null, claim: null, root: null, lost: false });
+    if (await currentBranch(root) !== mine.branch) await gitQuiet(root, ["checkout", "-q", mine.branch]);
+    if (lost) {
+      await log(`[lost] ${mine.id} was taken over while running \u2014 stopped, nothing pushed`);
+      alert(ctx, { kind: "claim-lost", task: mine.id, message: `${worker} lost its claim of ${mine.id} while working; its work was not pushed.` });
+      await writeLocalClaim(profileDir2, null);
+      await syncBase(root, rootBase.base);
+      ctx.bus.autonomousDone(false, "claim lost");
+      return;
+    }
+    if (out.exhausted) {
+      for (const s3 of subs) await wipCommit(join24(root, s3.sub.dir), `wip(${mine.id}): out of tokens`);
+      await wipCommit(root, `wip(${mine.id}): out of tokens`);
+      await log(`[wait] ${mine.id}: usage limit \u2014 claim kept, resumes after the reset`);
+      ctx.bus.autonomousDone(false, "usage limit \u2014 task kept");
+      return;
+    }
+    const reply = parseJsonReply(out.output);
+    const status = out.cancelled ? "failed" : out.exitCode !== 0 ? "failed" : reply?.status ?? "failed";
+    if (status === "needs-input") {
+      await pushWip(root, mine, subs, "waiting for an answer");
+      await syncBase(root, rootBase.base);
+      const question = reply?.question?.trim() || reply?.summary?.trim() || "The agent needs a decision to continue.";
+      let qaId = null;
+      await publishBooks(root, rootBase.base, `chore(auto): ${mine.id} asks a question`, async () => {
+        qaId = await applyQuestion(root, mine, question);
+        return qaId !== null;
+      });
+      await writeLocalClaim(profileDir2, null);
+      await log(`[question] ${mine.id} parked on ${qaId ?? "?"}`);
+      alert(ctx, { kind: "task-question", task: mine.id, message: `${mine.id} waits for an answer (${qaId ?? "QA"}): ${question.slice(0, 200)}` });
       hist = await readHistories(root);
-      hist.consecutiveFails = 0;
-      await recordRun(root, hist, "success", "cycle complete", today);
-      await log("[done] cycle complete");
+      await recordRun(root, hist, "success", `${mine.id} needs input`, today);
       ctx.bus.autonomousDone(true);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      await reportNewBookRows(ctx, root, booksBefore);
+      return;
+    }
+    if (status !== "done") {
+      const reason = reply?.summary?.trim() || (out.cancelled ? "run stopped" : `agent run failed (exit ${out.exitCode})`);
+      await releaseTask(ctx, root, rootBase, bases.subs, mine, reason, cfg);
       hist = await readHistories(root);
       hist.consecutiveFails += 1;
-      await recordRun(root, hist, "failure", msg, today);
-      await log(`[warn] cycle failed: ${msg}`);
-      if (cfg.stopOnConsecutiveFailures > 0 && hist.consecutiveFails >= cfg.stopOnConsecutiveFailures) {
-        await writeAutonomousConfig(profileDir2, { ...cfg, paused: true });
-        await log(`[stop] ${hist.consecutiveFails} consecutive failures \u2192 paused`);
-      }
-      ctx.bus.autonomousDone(false, msg);
+      await recordRun(root, hist, "failure", `${mine.id}: ${reason}`, today);
+      await maybeAutoPause(root, profileDir2, cfg, hist, log);
+      ctx.bus.autonomousDone(false, reason);
+      return;
+    }
+    if (await remoteClaimLost(root, mine)) {
+      await log(`[lost] ${mine.id} was taken over before delivery \u2014 nothing pushed`);
+      alert(ctx, { kind: "claim-lost", task: mine.id, message: `${worker} lost its claim of ${mine.id} before delivering.` });
+      await writeLocalClaim(profileDir2, null);
+      await syncBase(root, rootBase.base);
+      ctx.bus.autonomousDone(false, "claim lost");
+      return;
+    }
+    let delivered;
+    try {
+      delivered = await deliver(root, rootBase, subs, mine, reply?.summary ?? "");
+    } catch (err) {
+      const reason = `delivery failed: ${String(err instanceof Error ? err.message : err)}`;
+      await releaseTask(ctx, root, rootBase, bases.subs, mine, reason, cfg);
+      ctx.bus.autonomousDone(false, reason);
+      return;
     }
+    await syncBase(root, rootBase.base);
+    const fin = await publishBooks(root, rootBase.base, `chore(auto): finish ${mine.id}`, () => applyFinish(root, mine, delivered));
+    await writeLocalClaim(profileDir2, null);
+    await log(`[done] ${mine.id} \u2014 ${delivered.notes} (${fin})`);
+    hist = await readHistories(root);
+    hist.consecutiveFails = 0;
+    await recordRun(root, hist, "success", `${mine.id} delivered`, today);
+    ctx.bus.autonomousDone(true);
   } catch (err) {
+    await dayLog(root, `[warn] cycle error: ${err instanceof Error ? err.message : String(err)}`).catch(() => void 0);
     ctx.bus.autonomousDone(false, err instanceof Error ? err.message : String(err));
   } finally {
     running.delete(root);
   }
 }
+async function remoteClaimLost(root, mine) {
+  const prog = await remoteBook(root, mine.base, "AI_PROGRESS.md");
+  if (!prog) return false;
+  const row = parseClaims(prog).claims.find((c) => c.id === mine.id);
+  return !row || row.claim !== mine.claim;
+}
+async function deliver(root, rootBase, subs, mine, summary) {
+  const title = `${mine.id}: ${mine.task.desc}`.replace(/\s+/g, " ").slice(0, 100);
+  const subPrs = [];
+  for (const s3 of subs) {
+    const abs = join24(root, s3.sub.dir);
+    if (await currentBranch(abs) !== s3.branch) continue;
+    await wipCommit(abs, `feat(${mine.id}): ${summary || mine.task.desc}`.slice(0, 200));
+    if (await aheadOf(abs, s3.branch, s3.sub.base) === 0) continue;
+    await pushBranch(abs, s3.branch);
+    const pr3 = await deliverPr(abs, s3.sub.url, s3.branch, s3.sub.base, title, `${summary}
+
+Task ${mine.id} (4PM autonomous).`);
+    if (pr3.error) throw new Error(`submodule ${s3.sub.dir} PR: ${pr3.error}`);
+    subPrs.push(`${s3.sub.dir}: ${pr3.url ?? s3.branch}`);
+  }
+  await wipCommit(root, `feat(${mine.id}): ${summary || mine.task.desc}`.slice(0, 200));
+  const files = (await gitQuiet(root, ["diff", "--name-only", `origin/${rootBase.base}...${mine.branch}`])).split("\n").filter(Boolean);
+  if (await aheadOf(root, mine.branch, rootBase.base) === 0) {
+    return { files: "", notes: `no changes needed; branch: ${mine.branch}${subPrs.length ? `; sub PRs: ${subPrs.join(", ")}` : ""}` };
+  }
+  await pushBranch(root, mine.branch);
+  const body = `${summary}
+
+Task ${mine.id} (4PM autonomous).${subPrs.length ? `
+
+Submodule PRs:
+${subPrs.map((p2) => `- ${p2}`).join("\n")}` : ""}`;
+  const pr2 = await deliverPr(root, rootBase.url, mine.branch, rootBase.base, title, body);
+  if (pr2.error) throw new Error(`PR: ${pr2.error}`);
+  return {
+    files: files.slice(0, 20).join(", ") + (files.length > 20 ? ` (+${files.length - 20})` : ""),
+    notes: `branch: ${mine.branch}; PR: ${pr2.url ?? "opened"}${subPrs.length ? `; sub PRs: ${subPrs.join(", ")}` : ""}`
+  };
+}
+async function releaseTask(ctx, root, rootBase, allSubs, mine, reason, cfg) {
+  const subs = subBranches(allSubs, mine.id, null);
+  await pushWip(root, mine, subs, reason.slice(0, 80));
+  await syncBase(root, rootBase.base);
+  const attempts = await readAttempts(root);
+  const next = (attempts[mine.id]?.count ?? 0) + 1;
+  const reasons = `${attempts[mine.id]?.last ?? ""}; ${reason}`;
+  if (next >= cfg.maxTaskAttempts) {
+    if (isSplitChild(mine.task)) {
+      const q2 = `${mine.id} (a task already split from a bigger one) failed ${next} times \u2014 last: ${reason}. How should it be handled (narrow the scope, change the approach, or drop it)?`;
+      await publishBooks(root, rootBase.base, `chore(auto): ${mine.id} needs a decision`, async () => await applyQuestion(root, mine, q2, true) !== null);
+      alert(ctx, { kind: "task-failed-limit", task: mine.id, message: `${mine.id} failed ${next} times; a decision was requested in USER_QA.` });
+    } else {
+      const out = await runAiPrompt(ctx, buildSplitPrompt(mine, reasons, await wipDiff(root, mine)), randomUUID(), "local", false, void 0, cfg.model ? { model: cfg.model } : void 0, true, false);
+      const children = parseJsonReply(out.output)?.children?.filter((c) => c?.desc?.trim()) ?? [];
+      await syncBase(root, rootBase.base);
+      if (children.length >= 2) {
+        let ids = null;
+        await publishBooks(root, rootBase.base, `chore(auto): split ${mine.id}`, async () => {
+          ids = await applySplit(root, mine, children);
+          return ids !== null;
+        });
+        alert(ctx, { kind: "task-split", task: mine.id, message: `${mine.id} was split into ${(ids ?? []).join(", ")} \u2014 approve the new tasks.` });
+      } else {
+        const q2 = `${mine.id} failed ${next} times and could not be split automatically \u2014 last: ${reason}. How should it be handled?`;
+        await publishBooks(root, rootBase.base, `chore(auto): ${mine.id} needs a decision`, async () => await applyQuestion(root, mine, q2, true) !== null);
+        alert(ctx, { kind: "task-failed-limit", task: mine.id, message: `${mine.id} failed ${next} times; a decision was requested in USER_QA.` });
+      }
+    }
+  } else {
+    await publishBooks(root, rootBase.base, `chore(auto): release ${mine.id} (attempt ${next})`, async () => await applyRelease(root, mine, reason, cfg.maxTaskAttempts) !== null);
+  }
+  await writeLocalClaim(ctx.profileDir, null);
+  await dayLog(root, `[release] ${mine.id} attempt ${next}: ${reason}`);
+}
+async function maybeAutoPause(root, profileDir2, cfg, hist, log) {
+  if (cfg.stopOnConsecutiveFailures > 0 && hist.consecutiveFails >= cfg.stopOnConsecutiveFailures) {
+    await writeAutonomousConfig(profileDir2, { ...cfg, paused: true });
+    await log(`[stop] ${hist.consecutiveFails} consecutive failures \u2192 paused`);
+  }
+  await writeHistories(root, hist);
+}
 async function readBookUsage(ctx) {
   try {
     return await ctx.request(WsChannels.AUTONOMOUS_BOOK_USAGE, {});
@@ -43000,11 +44151,11 @@ async function reportNewBookRows(ctx, root, before) {
 }
 async function dayLog(root, line) {
   try {
-    const dir2 = join21(root, ".claude", "logs");
+    const dir2 = join24(root, ".claude", "logs");
     await mkdir3(dir2, { recursive: true });
     const day = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const ts2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
-    await appendFile2(join21(dir2, `autonomous-tick-${day}.log`), `${ts2} ${line}
+    await appendFile2(join24(dir2, `autonomous-tick-${day}.log`), `${ts2} ${line}
 `, "utf8");
   } catch {
   }
@@ -43012,12 +44163,12 @@ async function dayLog(root, line) {
 async function pruneLogs(root, retentionDays) {
   if (!(retentionDays > 0)) return;
   try {
-    const dir2 = join21(root, ".claude", "logs");
+    const dir2 = join24(root, ".claude", "logs");
     const cutoff = Date.now() - retentionDays * 864e5;
-    for (const f2 of await readdir2(dir2)) {
+    for (const f2 of await readdir3(dir2)) {
       if (!/^autonomous-tick-.*\.log$/.test(f2)) continue;
-      const st2 = await stat2(join21(dir2, f2)).catch(() => null);
-      if (st2 && st2.mtimeMs < cutoff) await rm2(join21(dir2, f2), { force: true }).catch(() => void 0);
+      const st2 = await stat2(join24(dir2, f2)).catch(() => null);
+      if (st2 && st2.mtimeMs < cutoff) await rm3(join24(dir2, f2), { force: true }).catch(() => void 0);
     }
   } catch {
   }
@@ -43029,15 +44180,15 @@ async function recordRun(root, hist, status, note, today) {
 }
 async function readJsonObject(path) {
   try {
-    return JSON.parse(await readFile6(path, "utf8"));
+    return JSON.parse(await readFile9(path, "utf8"));
   } catch {
     return {};
   }
 }
 async function hasWork(root) {
-  const approvals = await readJsonObject(join21(root, ".claude/.autonomous.approvals.json"));
+  const approvals = await readJsonObject(join24(root, ".claude/.autonomous.approvals.json"));
   const approved = Object.entries(approvals).filter(([, v2]) => v2 && typeof v2 === "object" && v2.approved === true).map(([k2]) => k2);
-  const read = (f2) => readFile6(join21(root, f2), "utf8").catch(() => "");
+  const read = (f2) => readFile9(join24(root, f2), "utf8").catch(() => "");
   const [userTodo, userQa, aiTodo, aiProgress] = await Promise.all([
     read("USER_TODO.md"),
     read("USER_QA.md"),
@@ -43074,7 +44225,7 @@ async function allAiProfilesExhausted(ctx, cfg) {
 }
 
 // src/core/fs-browse.ts
-import { readdir as readdir3 } from "fs/promises";
+import { readdir as readdir4 } from "fs/promises";
 import { resolve as resolve6, sep as sep3 } from "path";
 async function listDir(path, root) {
   if (!root) return { path: "", entries: [] };
@@ -43082,7 +44233,7 @@ async function listDir(path, root) {
   const requested = resolve6(base, path && path.trim() ? path : ".");
   const target = requested === base || requested.startsWith(base + sep3) ? requested : base;
   try {
-    const dirents = await readdir3(target, { withFileTypes: true });
+    const dirents = await readdir4(target, { withFileTypes: true });
     const entries2 = dirents.map((d) => ({
       name: d.name,
       type: d.isDirectory() ? "dir" : "file"
@@ -43097,7 +44248,7 @@ async function listDir(path, root) {
 }
 
 // src/core/fs-read.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 import { resolve as resolve7, sep as sep4 } from "path";
 var MAX_BYTES = 256 * 1024;
 function resolveInRoot(root, relPath) {
@@ -43112,7 +44263,7 @@ async function readWorkerFile(root, path) {
     return { path, content: "", truncated: false };
   }
   try {
-    const buf = await readFile7(target);
+    const buf = await readFile10(target);
     const truncated = buf.byteLength > MAX_BYTES;
     const content = buf.subarray(0, MAX_BYTES).toString("utf8");
     return { path: target, content, truncated };
@@ -43122,7 +44273,7 @@ async function readWorkerFile(root, path) {
 }
 
 // src/core/fs-write.ts
-import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile7 } from "fs/promises";
 import { dirname as dirname5, resolve as resolve8, sep as sep5 } from "path";
 var MAX_BYTES2 = 2 * 1024 * 1024;
 function resolveInRoot2(root, relPath) {
@@ -43142,7 +44293,7 @@ async function writeWorkerFile(root, relPath, content) {
   }
   try {
     await mkdir4(dirname5(target), { recursive: true });
-    await writeFile5(target, content, "utf8");
+    await writeFile7(target, content, "utf8");
     return { ok: true, path: target, bytes };
   } catch (err) {
     return { ok: false, path: target, bytes: 0, error: err instanceof Error ? err.message : String(err) };
@@ -43150,7 +44301,7 @@ async function writeWorkerFile(root, relPath, content) {
 }
 
 // src/core/fs-mutate.ts
-import { mkdir as mkdir5, writeFile as writeFile6, rename, rm as rm3, stat as stat3 } from "fs/promises";
+import { mkdir as mkdir5, writeFile as writeFile8, rename, rm as rm4, stat as stat3 } from "fs/promises";
 import { basename as basename3, dirname as dirname6, resolve as resolve9, sep as sep6 } from "path";
 var MAX_BYTES3 = 2 * 1024 * 1024;
 function resolveInRoot3(root, rel) {
@@ -43193,7 +44344,7 @@ async function mutateFs(root, req) {
           return { ok: false, path: target, error: `content too large (max ${MAX_BYTES3} bytes)` };
         }
         await mkdir5(dirname6(target), { recursive: true });
-        await writeFile6(target, content, "utf8");
+        await writeFile8(target, content, "utf8");
         return { ok: true, path: target };
       }
       case "move": {
@@ -43212,7 +44363,7 @@ async function mutateFs(root, req) {
         const target = resolveInRoot3(root, req.path ?? "");
         if (!target) return escaped(req.path ?? "");
         if (target === resolve9(root)) return { ok: false, path: target, error: "cannot delete the project root" };
-        await rm3(target, { recursive: true, force: true });
+        await rm4(target, { recursive: true, force: true });
         return { ok: true, path: target };
       }
       default:
@@ -43224,7 +44375,7 @@ async function mutateFs(root, req) {
 }
 
 // src/core/fs-transfer.ts
-import { mkdir as mkdir6, readFile as readFile8, stat as stat4, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile11, stat as stat4, writeFile as writeFile9 } from "fs/promises";
 import { basename as basename4, dirname as dirname7, extname, resolve as resolve10, sep as sep7 } from "path";
 function resolveInRoot4(root, relPath) {
   if (!root) return null;
@@ -43269,7 +44420,7 @@ async function uploadBinaryFile(root, relPath, contentBase64) {
   }
   try {
     await mkdir6(dirname7(target), { recursive: true });
-    await writeFile7(target, buf);
+    await writeFile9(target, buf);
     return { ok: true, path: target, bytes: buf.byteLength };
   } catch (err) {
     return { ok: false, path: target, bytes: 0, error: err instanceof Error ? err.message : String(err) };
@@ -43284,7 +44435,7 @@ async function downloadBinaryFile(root, relPath) {
     if (info.size > FS_TRANSFER_MAX_BYTES) {
       return { error: `file too large (max ${FS_TRANSFER_MAX_BYTES} bytes)` };
     }
-    const buf = await readFile8(target);
+    const buf = await readFile11(target);
     return {
       contentBase64: buf.toString("base64"),
       contentType: guessMime(target),
@@ -43343,11 +44494,11 @@ function handleFsChannels(ctx, message, payload) {
 }
 
 // src/core/git-diff.ts
-import { readFile as readFile9 } from "fs/promises";
-import { execFile as execFile7 } from "child_process";
+import { readFile as readFile12 } from "fs/promises";
+import { execFile as execFile9 } from "child_process";
 import { basename as basename5, dirname as dirname8, resolve as resolve11, sep as sep8 } from "path";
-import { promisify as promisify7 } from "util";
-var run7 = promisify7(execFile7);
+import { promisify as promisify9 } from "util";
+var run9 = promisify9(execFile9);
 function resolveInRoot5(root, relPath) {
   if (!root) return null;
   const base = resolve11(root);
@@ -43370,12 +44521,12 @@ async function gitDiff(root, path) {
   const base = basename5(target);
   let newBuf = null;
   try {
-    newBuf = await readFile9(target);
+    newBuf = await readFile12(target);
   } catch {
   }
   let oldBuf = null;
   try {
-    const { stdout } = await run7("git", ["show", `HEAD:./${base}`], {
+    const { stdout } = await run9("git", ["show", `HEAD:./${base}`], {
       cwd: dir2,
       timeout: 15e3,
       maxBuffer: FS_TRANSFER_MAX_BYTES + 1024,
@@ -43405,12 +44556,12 @@ async function gitDiff(root, path) {
 }
 
 // src/core/git-env.ts
-import { execFile as execFile8 } from "child_process";
-import { promisify as promisify8 } from "util";
-var run8 = promisify8(execFile8);
+import { execFile as execFile10 } from "child_process";
+import { promisify as promisify10 } from "util";
+var run10 = promisify10(execFile10);
 async function hasBinary(bin, args = ["--version"]) {
   try {
-    await run8(bin, args, { timeout: 5e3 });
+    await run10(bin, args, { timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -43423,7 +44574,7 @@ async function checkGitEnv(provider) {
   let account = null;
   if (installed) {
     try {
-      const { stdout, stderr } = await run8(bin, ["auth", "status"], { timeout: 8e3 });
+      const { stdout, stderr } = await run10(bin, ["auth", "status"], { timeout: 8e3 });
       const out = `${stdout}
 ${stderr}`;
       authenticated = /logged in|logged into|✓/i.test(out);
@@ -43436,33 +44587,33 @@ ${stderr}`;
 }
 
 // src/core/git-ssh-key.ts
-import { execFile as execFile9 } from "child_process";
-import { readFile as readFile10, rm as rm4, mkdir as mkdir7 } from "fs/promises";
-import { join as join22 } from "path";
-import { promisify as promisify9 } from "util";
-var run9 = promisify9(execFile9);
+import { execFile as execFile11 } from "child_process";
+import { readFile as readFile13, rm as rm5, mkdir as mkdir7 } from "fs/promises";
+import { join as join25 } from "path";
+import { promisify as promisify11 } from "util";
+var run11 = promisify11(execFile11);
 function keyPaths(profileDir2) {
-  const dir2 = join22(profileDir2, ".ssh");
-  const key = join22(dir2, "id_4pm");
+  const dir2 = join25(profileDir2, ".ssh");
+  const key = join25(dir2, "id_4pm");
   return { dir: dir2, key, pub: `${key}.pub` };
 }
 async function readPublicKey(pub) {
   try {
-    return (await readFile10(pub, "utf8")).trim();
+    return (await readFile13(pub, "utf8")).trim();
   } catch {
     return null;
   }
 }
 async function fingerprintOf(pub) {
   try {
-    const { stdout } = await run9("ssh-keygen", ["-lf", pub], { timeout: 5e3 });
+    const { stdout } = await run11("ssh-keygen", ["-lf", pub], { timeout: 5e3 });
     return stdout.match(/SHA256:[A-Za-z0-9+/=]+/)?.[0] ?? null;
   } catch {
     return null;
   }
 }
 async function configureGit(key) {
-  await run9(
+  await run11(
     "git",
     ["config", "--global", "core.sshCommand", `ssh -i ${key} -o IdentitiesOnly=yes`],
     { timeout: 5e3 }
@@ -43471,9 +44622,9 @@ async function configureGit(key) {
 async function generate(profileDir2) {
   const { dir: dir2, key, pub } = keyPaths(profileDir2);
   await mkdir7(dir2, { recursive: true });
-  await rm4(key, { force: true });
-  await rm4(pub, { force: true });
-  await run9("ssh-keygen", ["-t", "ed25519", "-f", key, "-N", "", "-C", "4pm-deploy-key"], {
+  await rm5(key, { force: true });
+  await rm5(pub, { force: true });
+  await run11("ssh-keygen", ["-t", "ed25519", "-f", key, "-N", "", "-C", "4pm-deploy-key"], {
     timeout: 15e3
   });
   await configureGit(key);
@@ -43481,14 +44632,14 @@ async function generate(profileDir2) {
 }
 async function remove(profileDir2) {
   const { key, pub } = keyPaths(profileDir2);
-  await rm4(key, { force: true });
-  await rm4(pub, { force: true });
-  await run9("git", ["config", "--global", "--unset", "core.sshCommand"], { timeout: 5e3 }).catch(
+  await rm5(key, { force: true });
+  await rm5(pub, { force: true });
+  await run11("git", ["config", "--global", "--unset", "core.sshCommand"], { timeout: 5e3 }).catch(
     () => void 0
   );
   return { publicKey: null, fingerprint: null };
 }
-async function get(profileDir2) {
+async function get2(profileDir2) {
   const { pub } = keyPaths(profileDir2);
   const publicKey = await readPublicKey(pub);
   return { publicKey, fingerprint: publicKey ? await fingerprintOf(pub) : null };
@@ -43497,7 +44648,7 @@ async function manageSshKey(op, profileDir2) {
   try {
     if (op === "generate") return await generate(profileDir2);
     if (op === "delete") return await remove(profileDir2);
-    return await get(profileDir2);
+    return await get2(profileDir2);
   } catch {
     return { publicKey: null, fingerprint: null };
   }
@@ -43555,12 +44706,12 @@ function handleGitChannels(ctx, message, payload) {
 }
 
 // src/core/ws-client/handlers/misc.ts
-import { join as join23 } from "path";
+import { join as join26 } from "path";
 
 // src/core/ai-assist.ts
-import { execFile as execFile10 } from "child_process";
-import { promisify as promisify10 } from "util";
-var run10 = promisify10(execFile10);
+import { execFile as execFile12 } from "child_process";
+import { promisify as promisify12 } from "util";
+var run12 = promisify12(execFile12);
 function aiCli() {
   return process.env.AI_CLI || "claude";
 }
@@ -43603,7 +44754,7 @@ function parseAi(cli, stdout, prompt) {
 }
 async function runAi(prompt) {
   const cli = aiCli();
-  const { stdout } = await run10(cli, aiArgs(cli, prompt), {
+  const { stdout } = await run12(cli, aiArgs(cli, prompt), {
     timeout: 12e4,
     maxBuffer: 8 * 1024 * 1024
   });
@@ -43705,7 +44856,7 @@ function handleMiscChannels(ctx, message, payload) {
     }
     case WsChannels.LOG_READ: {
       const limit = Math.min(Math.max(payload.limit ?? 200, 1), 2e3);
-      const lines = readRecentLogLines(join23(ctx.profileDir, "logs"), limit);
+      const lines = readRecentLogLines(join26(ctx.profileDir, "logs"), limit);
       ctx.send(WsChannels.LOG_READ, { lines }, message.id);
       return true;
     }
@@ -43736,8 +44887,92 @@ function handleMiscChannels(ctx, message, payload) {
 }
 
 // src/core/ws-client/handlers/project.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, renameSync, rmSync as rmSync7 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, renameSync, rmSync as rmSync7 } from "fs";
+import { join as join28 } from "path";
+
+// src/core/repo-probe.ts
+import { execFile as execFile13 } from "child_process";
+import { mkdtemp as mkdtemp2, readdir as readdir5, rm as rm6 } from "fs/promises";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join27 } from "path";
+import { promisify as promisify13 } from "util";
+var run13 = promisify13(execFile13);
+var MAX_BRANCHES = 100;
+var REWRITTEN = ["project.spec.json", "README.md", "CLAUDE.md", "AGENT.md", ".4pm/.4pm.json", ".claude/settings.json", ".claude/skills/", ".claude/agents/"];
+async function git4(args, cwd2, timeout = 6e4) {
+  const { stdout } = await run13("git", args, { cwd: cwd2, timeout, maxBuffer: 32 * 1024 * 1024 });
+  return stdout;
+}
+async function templateEntries() {
+  try {
+    return new Set((await readdir5(projectSampleDir())).filter((n) => n !== ".git"));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function probeSubmodule(sub) {
+  try {
+    const out = await git4(["ls-remote", "--symref", sub.url, "HEAD", ...sub.branch ? [`refs/heads/${sub.branch}`] : []], void 0, 3e4);
+    const def = /ref: refs\/heads\/(\S+)\s+HEAD/.exec(out)?.[1] ?? "";
+    const branch = sub.branch || def;
+    const exists2 = !sub.branch || out.includes(`refs/heads/${sub.branch}`);
+    return { subdir: sub.subdir, url: sub.url, branch, exists: exists2, protected: exists2 ? await branchProtection(sub.url, branch) : null, error: null };
+  } catch (err) {
+    const e = err;
+    return { subdir: sub.subdir, url: sub.url, branch: sub.branch, exists: false, protected: null, error: (e.stderr || e.message || String(err)).trim().slice(0, 300) };
+  }
+}
+async function probeRepo(req) {
+  const empty = { branchExists: false, defaultBranch: null, branches: [], source: null, protected: null, submodules: [], error: null };
+  let tmp = null;
+  try {
+    const [symref, heads] = await Promise.all([
+      git4(["ls-remote", "--symref", req.url, "HEAD"], void 0, 3e4),
+      git4(["ls-remote", "--heads", req.url], void 0, 3e4)
+    ]);
+    const defaultBranch = /ref: refs\/heads\/(\S+)\s+HEAD/.exec(symref)?.[1] ?? null;
+    const branches = heads.split("\n").map((l) => l.split("	")[1] ?? "").filter((r) => r.startsWith("refs/heads/")).map((r) => r.slice("refs/heads/".length));
+    const branch = (req.branch ?? "").trim();
+    const branchExists = !branch || branches.includes(branch);
+    const kind = req.base?.kind ?? "default";
+    const ref = branchExists ? branch || defaultBranch : kind === "empty" ? null : kind === "branch" ? (req.base?.branch ?? "").trim() || null : defaultBranch;
+    const [isProtected, submodules] = await Promise.all([
+      branchExists ? branchProtection(req.url, branch || defaultBranch || "") : Promise.resolve(null),
+      Promise.all((req.submodules ?? []).map(probeSubmodule))
+    ]);
+    const result = { ...empty, branchExists, defaultBranch, branches: branches.slice(0, MAX_BRANCHES), protected: isProtected, submodules };
+    if (!ref) return result;
+    if (!branches.includes(ref)) return { ...result, error: `Branch "${ref}" does not exist on the remote.` };
+    tmp = await mkdtemp2(join27(tmpdir4(), "4pm-probe-"));
+    await git4(["init", "-q"], tmp);
+    await git4(["remote", "add", "origin", req.url], tmp);
+    await git4(["fetch", "-q", "--depth", "1", "--filter=blob:none", "origin", ref], tmp, 12e4);
+    const files = (await git4(["ls-tree", "-r", "--name-only", "FETCH_HEAD"], tmp)).split("\n").filter(Boolean);
+    const hasScaffold = files.includes(".4pm/.4pm.json");
+    let templateVersion = null;
+    if (hasScaffold) {
+      try {
+        const marker = JSON.parse(await git4(["show", "FETCH_HEAD:.4pm/.4pm.json"], tmp));
+        templateVersion = typeof marker.templateVersion === "string" ? marker.templateVersion : null;
+      } catch {
+        templateVersion = null;
+      }
+    }
+    const isRewritten = (f2) => REWRITTEN.some((r) => r.endsWith("/") ? f2.startsWith(r) : f2 === r);
+    const tracking = SCAFFOLD_TRACKING_FILES.filter((f2) => files.includes(f2));
+    const template = await templateEntries();
+    const overwrite = files.filter((f2) => isRewritten(f2) && !f2.endsWith(".gitkeep"));
+    const keep = files.filter(
+      (f2) => template.has(f2.split("/")[0] ?? "") && !isRewritten(f2) && !tracking.includes(f2) && !f2.endsWith(".gitkeep")
+    );
+    return { ...result, source: { ref, hasScaffold, templateVersion, keep: keep.slice(0, 200), overwrite, tracking: [...tracking] } };
+  } catch (err) {
+    const e = err;
+    return { ...empty, error: (e.stderr || e.message || String(err)).trim().split("\n").slice(-2).join(" ").slice(0, 400) };
+  } finally {
+    if (tmp) await rm6(tmp, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
 
 // src/core/ai-task.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -43809,16 +45044,16 @@ function handleProjectChannels(ctx, message, payload) {
     case WsChannels.PHYSIC_SYNC: {
       const sync = payload;
       const oldName = sync.oldName;
-      const oldPath = oldName ? join24(ctx.profileDir, oldName) : null;
-      const newPath = join24(ctx.profileDir, sync.newName);
+      const oldPath = oldName ? join28(ctx.profileDir, oldName) : null;
+      const newPath = join28(ctx.profileDir, sync.newName);
       if (oldName) {
         const oldRoot = ctx.physicFolderPath(oldName);
         if (oldRoot) void uninstallCron(oldRoot).catch(() => void 0);
       }
-      if (oldPath && oldName !== sync.newName && existsSync14(oldPath) && !existsSync14(newPath)) {
+      if (oldPath && oldName !== sync.newName && existsSync15(oldPath) && !existsSync15(newPath)) {
         renameSync(oldPath, newPath);
       } else {
-        if (oldPath && oldName !== sync.newName && existsSync14(oldPath)) rmSync7(oldPath, { recursive: true, force: true });
+        if (oldPath && oldName !== sync.newName && existsSync15(oldPath)) rmSync7(oldPath, { recursive: true, force: true });
         mkdirSync7(newPath, { recursive: true });
       }
       ctx.physicRoot = ctx.physicFolderPath(sync.newName);
@@ -43833,7 +45068,7 @@ function handleProjectChannels(ctx, message, payload) {
       if (del.name) {
         const delRoot = ctx.physicFolderPath(del.name);
         if (delRoot) void uninstallCron(delRoot).catch(() => void 0);
-        rmSync7(join24(ctx.profileDir, del.name), { recursive: true, force: true });
+        rmSync7(join28(ctx.profileDir, del.name), { recursive: true, force: true });
         ctx.bus.log(t("project.folderDeleted", { name: del.name }));
       }
       void manageSshKey("delete", ctx.profileDir).catch(() => void 0);
@@ -43872,6 +45107,10 @@ function handleProjectChannels(ctx, message, payload) {
         requestGitSnapshot("scaffold");
       });
       return true;
+    case WsChannels.REPO_PROBE: {
+      void probeRepo(payload).then((reply) => ctx.send(WsChannels.REPO_PROBE, reply, message.id));
+      return true;
+    }
     case WsChannels.PROJECT_PUBLISH: {
       const root = ctx.physicRoot;
       if (!root) {
@@ -43985,13 +45224,13 @@ async function runKnowledgeCompose(req, ai2, physicRoot) {
 }
 
 // src/core/faq-compose.ts
-import { spawn as spawn9, execFile as execFile11 } from "child_process";
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, rmSync as rmSync8 } from "fs";
+import { spawn as spawn9, execFile as execFile14 } from "child_process";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, rmSync as rmSync8 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join25 } from "path";
-import { tmpdir as tmpdir4 } from "os";
-import { promisify as promisify11 } from "util";
-var execFileAsync2 = promisify11(execFile11);
+import { join as join29 } from "path";
+import { tmpdir as tmpdir5 } from "os";
+import { promisify as promisify14 } from "util";
+var execFileAsync2 = promisify14(execFile14);
 var NO_USAGE2 = { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
 var COMPOSE_TIMEOUT_MS2 = 10 * 60 * 1e3;
 var AGENT_DENIED_TOOLS = ["Bash", "WebFetch", "WebSearch", "NotebookEdit", "Task"];
@@ -44109,7 +45348,7 @@ async function runClaudeWithFailover2(prompt, cwd2, ai2) {
 var MAX_OUTPUT_CHARS = 8e3;
 async function runFaqCompose(req, ai2) {
   if (!req.repo.token) return { prUrl: "", error: "no write token" };
-  const workDir = join25(tmpdir4(), "4pm-faq-sync", randomUUID3());
+  const workDir = join29(tmpdir5(), "4pm-faq-sync", randomUUID3());
   const gitEnv = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
   const auth = gitAuthArgs("x-access-token", req.repo.token);
   try {
@@ -44153,7 +45392,7 @@ async function runFaqCompose(req, ai2) {
     logger.warn("faq.compose.failed", { error: String(err) });
     return { prUrl: "", error: String(err) };
   } finally {
-    if (existsSync15(workDir)) {
+    if (existsSync16(workDir)) {
       try {
         rmSync8(workDir, { recursive: true, force: true });
       } catch {
@@ -44337,8 +45576,8 @@ function handleToolsChannels(ctx, message, payload) {
 }
 
 // src/core/agents.ts
-import { readFile as readFile11, writeFile as writeFile8, mkdir as mkdir8, readdir as readdir4, rm as rm5 } from "fs/promises";
-import { join as join26 } from "path";
+import { readFile as readFile14, writeFile as writeFile10, mkdir as mkdir8, readdir as readdir6, rm as rm7 } from "fs/promises";
+import { join as join30 } from "path";
 var AGENTS_REL = ".claude/agents";
 var SKILLS_REL = ".claude/skills";
 var MEMORY_DIRS = /* @__PURE__ */ new Set(["short-memory", "long-memory"]);
@@ -44347,7 +45586,7 @@ function safeName(name) {
 }
 async function readText2(path, fallback = "") {
   try {
-    return await readFile11(path, "utf8");
+    return await readFile14(path, "utf8");
   } catch {
     return fallback;
   }
@@ -44355,24 +45594,24 @@ async function readText2(path, fallback = "") {
 function frontmatter(text) {
   const m2 = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   const body = m2?.[1] ?? "";
-  const get2 = (key) => body.match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
-  return { name: get2("name"), description: get2("description") };
+  const get3 = (key) => body.match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
+  return { name: get3("name"), description: get3("description") };
 }
 async function listAgents(root) {
   const subagents = [];
   const skills = [];
   try {
-    for (const e of await readdir4(join26(root, AGENTS_REL), { withFileTypes: true })) {
+    for (const e of await readdir6(join30(root, AGENTS_REL), { withFileTypes: true })) {
       if (!e.isFile() || !e.name.endsWith(".md") || MEMORY_DIRS.has(e.name)) continue;
-      const fm = frontmatter(await readText2(join26(root, AGENTS_REL, e.name)));
+      const fm = frontmatter(await readText2(join30(root, AGENTS_REL, e.name)));
       subagents.push({ name: e.name.replace(/\.md$/, ""), description: fm.description });
     }
   } catch {
   }
   try {
-    for (const e of await readdir4(join26(root, SKILLS_REL), { withFileTypes: true })) {
+    for (const e of await readdir6(join30(root, SKILLS_REL), { withFileTypes: true })) {
       if (!e.isDirectory()) continue;
-      const fm = frontmatter(await readText2(join26(root, SKILLS_REL, e.name, "SKILL.md")));
+      const fm = frontmatter(await readText2(join30(root, SKILLS_REL, e.name, "SKILL.md")));
       skills.push({ name: e.name, description: fm.description });
     }
   } catch {
@@ -44383,15 +45622,15 @@ async function listAgents(root) {
 }
 function itemPath(root, kind, name) {
   const n = safeName(name);
-  return kind === "subagent" ? join26(root, AGENTS_REL, `${n}.md`) : join26(root, SKILLS_REL, n, "SKILL.md");
+  return kind === "subagent" ? join30(root, AGENTS_REL, `${n}.md`) : join30(root, SKILLS_REL, n, "SKILL.md");
 }
 async function readAgent(root, kind, name) {
   const content = await readText2(itemPath(root, kind, name));
   if (kind !== "subagent") return { content };
   const n = safeName(name);
   const [short, long] = await Promise.all([
-    readText2(join26(root, AGENTS_REL, "short-memory", `${n}.md`)),
-    readText2(join26(root, AGENTS_REL, "long-memory", `${n}.md`))
+    readText2(join30(root, AGENTS_REL, "short-memory", `${n}.md`)),
+    readText2(join30(root, AGENTS_REL, "long-memory", `${n}.md`))
   ]);
   return { content, memory: { short, long } };
 }
@@ -44400,14 +45639,14 @@ async function writeAgent(root, req) {
   if (!n) return { ok: false, error: "invalid name" };
   try {
     if (req.action === "delete") {
-      if (req.kind === "subagent") await rm5(itemPath(root, "subagent", n), { force: true });
-      else await rm5(join26(root, SKILLS_REL, n), { recursive: true, force: true });
+      if (req.kind === "subagent") await rm7(itemPath(root, "subagent", n), { force: true });
+      else await rm7(join30(root, SKILLS_REL, n), { recursive: true, force: true });
       return { ok: true };
     }
     if (req.content === void 0) return { ok: false, error: "content is required" };
     const path = itemPath(root, req.kind, n);
-    await mkdir8(join26(path, ".."), { recursive: true });
-    await writeFile8(path, req.content, "utf8");
+    await mkdir8(join30(path, ".."), { recursive: true });
+    await writeFile10(path, req.content, "utf8");
     return { ok: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
@@ -44415,21 +45654,21 @@ async function writeAgent(root, req) {
 }
 
 // src/core/secrets.ts
-import { readFile as readFile12, writeFile as writeFile9 } from "fs/promises";
-import { join as join27 } from "path";
+import { readFile as readFile15, writeFile as writeFile11 } from "fs/promises";
+import { join as join31 } from "path";
 var SECURITY_REL = "AI_SECURITY.md";
 var PLACEHOLDER_REL = "AI_PLACEHOLDER.md";
 var SECRETS_REL = "project.secrets.json";
 async function readText3(path, fallback = "") {
   try {
-    return await readFile12(path, "utf8");
+    return await readFile15(path, "utf8");
   } catch {
     return fallback;
   }
 }
 async function readSecretsObject(root) {
   try {
-    const v2 = JSON.parse(await readFile12(join27(root, SECRETS_REL), "utf8"));
+    const v2 = JSON.parse(await readFile15(join31(root, SECRETS_REL), "utf8"));
     return v2 && typeof v2 === "object" ? v2 : {};
   } catch {
     return {};
@@ -44448,8 +45687,8 @@ function placeholderKeys(text) {
 }
 async function readSecrets(root) {
   const [security, placeholder, secrets] = await Promise.all([
-    readText3(join27(root, SECURITY_REL)),
-    readText3(join27(root, PLACEHOLDER_REL)),
+    readText3(join31(root, SECURITY_REL)),
+    readText3(join31(root, PLACEHOLDER_REL)),
     readSecretsObject(root)
   ]);
   const names = /* @__PURE__ */ new Set([...placeholderKeys(placeholder), ...Object.keys(secrets)]);
@@ -44462,14 +45701,14 @@ async function readSecrets(root) {
 async function writeSecrets(root, req) {
   try {
     if (req.kind === "security") {
-      await writeFile9(join27(root, SECURITY_REL), req.content, "utf8");
+      await writeFile11(join31(root, SECURITY_REL), req.content, "utf8");
     } else if (req.kind === "placeholder") {
-      await writeFile9(join27(root, PLACEHOLDER_REL), req.content, "utf8");
+      await writeFile11(join31(root, PLACEHOLDER_REL), req.content, "utf8");
     } else {
       const secrets = await readSecretsObject(root);
       if (req.kind === "secret") secrets[req.key] = req.value;
       else delete secrets[req.key];
-      await writeFile9(join27(root, SECRETS_REL), JSON.stringify(secrets, null, 2) + "\n", "utf8");
+      await writeFile11(join31(root, SECRETS_REL), JSON.stringify(secrets, null, 2) + "\n", "utf8");
     }
     return { ok: true };
   } catch (err) {
@@ -44478,17 +45717,17 @@ async function writeSecrets(root, req) {
 }
 
 // src/core/agent-tools.ts
-import { readFile as readFile13, writeFile as writeFile10, mkdir as mkdir9 } from "fs/promises";
-import { dirname as dirname9, join as join28 } from "path";
+import { readFile as readFile16, writeFile as writeFile12, mkdir as mkdir9 } from "fs/promises";
+import { dirname as dirname9, join as join32 } from "path";
 var SHARED_REL = ".claude/settings.json";
 var LOCAL_REL = ".claude/settings.local.json";
 var SECRETS_DENY = "Read(./project.secrets.json)";
 function fileFor(root, scope) {
-  return join28(root, scope === "shared" ? SHARED_REL : LOCAL_REL);
+  return join32(root, scope === "shared" ? SHARED_REL : LOCAL_REL);
 }
 async function readSettingsObject(path) {
   try {
-    const v2 = JSON.parse(await readFile13(path, "utf8"));
+    const v2 = JSON.parse(await readFile16(path, "utf8"));
     return v2 && typeof v2 === "object" ? v2 : {};
   } catch {
     return {};
@@ -44511,7 +45750,7 @@ async function writeAgentTools(root, scope, permissions) {
     if (scope === "shared" && !next.deny.includes(SECRETS_DENY)) next.deny = [...next.deny, SECRETS_DENY];
     obj.permissions = next;
     await mkdir9(dirname9(path), { recursive: true });
-    await writeFile10(path, JSON.stringify(obj, null, 2) + "\n", "utf8");
+    await writeFile12(path, JSON.stringify(obj, null, 2) + "\n", "utf8");
     return { ok: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
@@ -44520,8 +45759,8 @@ async function writeAgentTools(root, scope, permissions) {
 
 // src/core/packages.ts
 import { createHash as createHash4 } from "crypto";
-import { readFile as readFile14, writeFile as writeFile11, mkdir as mkdir10, readdir as readdir5, rm as rm6, stat as stat5 } from "fs/promises";
-import { dirname as dirname10, join as join29, relative } from "path";
+import { readFile as readFile17, writeFile as writeFile13, mkdir as mkdir10, readdir as readdir7, rm as rm8, stat as stat5 } from "fs/promises";
+import { dirname as dirname10, join as join33, relative } from "path";
 var AGENTS_REL2 = ".claude/agents";
 var SKILLS_REL2 = ".claude/skills";
 var MANIFEST_REL = ".claude/.4pm-packages.json";
@@ -44530,7 +45769,7 @@ function safeName2(name) {
 }
 async function readMaybe(path) {
   try {
-    return await readFile14(path);
+    return await readFile17(path);
   } catch {
     return null;
   }
@@ -44540,12 +45779,12 @@ async function listFilesRel(dir2) {
   async function walk2(d) {
     let entries2;
     try {
-      entries2 = await readdir5(d, { withFileTypes: true });
+      entries2 = await readdir7(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries2) {
-      const full = join29(d, e.name);
+      const full = join33(d, e.name);
       if (e.isDirectory()) await walk2(full);
       else if (e.isFile()) out.push(relative(dir2, full));
     }
@@ -44556,16 +45795,16 @@ async function listFilesRel(dir2) {
 async function readArtifactFiles(root, kind, slug) {
   const files = [];
   if (kind === "subagent") {
-    const agent = await readMaybe(join29(root, AGENTS_REL2, `${slug}.md`));
+    const agent = await readMaybe(join33(root, AGENTS_REL2, `${slug}.md`));
     if (agent) files.push({ path: "agent.md", contentBase64: agent.toString("base64") });
-    const short = await readMaybe(join29(root, AGENTS_REL2, "short-memory", `${slug}.md`));
+    const short = await readMaybe(join33(root, AGENTS_REL2, "short-memory", `${slug}.md`));
     if (short) files.push({ path: "short-memory.md", contentBase64: short.toString("base64") });
-    const long = await readMaybe(join29(root, AGENTS_REL2, "long-memory", `${slug}.md`));
+    const long = await readMaybe(join33(root, AGENTS_REL2, "long-memory", `${slug}.md`));
     if (long) files.push({ path: "long-memory.md", contentBase64: long.toString("base64") });
   } else {
-    const base = join29(root, SKILLS_REL2, slug);
+    const base = join33(root, SKILLS_REL2, slug);
     for (const rel of await listFilesRel(base)) {
-      const buf = await readMaybe(join29(base, rel));
+      const buf = await readMaybe(join33(base, rel));
       if (buf) files.push({ path: rel.split("\\").join("/"), contentBase64: buf.toString("base64") });
     }
   }
@@ -44583,7 +45822,7 @@ async function artifactSha256(root, kind, slug) {
   return h.digest("hex");
 }
 async function artifactExists(root, kind, slug) {
-  const target = kind === "subagent" ? join29(root, AGENTS_REL2, `${slug}.md`) : join29(root, SKILLS_REL2, slug);
+  const target = kind === "subagent" ? join33(root, AGENTS_REL2, `${slug}.md`) : join33(root, SKILLS_REL2, slug);
   try {
     await stat5(target);
     return true;
@@ -44592,7 +45831,7 @@ async function artifactExists(root, kind, slug) {
   }
 }
 async function readManifest(root) {
-  const buf = await readMaybe(join29(root, MANIFEST_REL));
+  const buf = await readMaybe(join33(root, MANIFEST_REL));
   if (!buf) return {};
   try {
     return JSON.parse(buf.toString("utf8"));
@@ -44601,35 +45840,35 @@ async function readManifest(root) {
   }
 }
 async function writeManifest(root, manifest) {
-  const path = join29(root, MANIFEST_REL);
+  const path = join33(root, MANIFEST_REL);
   await mkdir10(dirname10(path), { recursive: true });
-  await writeFile11(path, JSON.stringify(manifest, null, 2), "utf8");
+  await writeFile13(path, JSON.stringify(manifest, null, 2), "utf8");
 }
 async function writeArtifactFiles(root, kind, slug, files) {
   const byPath = new Map(files.map((f2) => [f2.path, Buffer.from(f2.contentBase64, "base64")]));
   if (kind === "subagent") {
     const agent = byPath.get("agent.md");
     if (agent) {
-      await mkdir10(join29(root, AGENTS_REL2), { recursive: true });
-      await writeFile11(join29(root, AGENTS_REL2, `${slug}.md`), agent);
+      await mkdir10(join33(root, AGENTS_REL2), { recursive: true });
+      await writeFile13(join33(root, AGENTS_REL2, `${slug}.md`), agent);
     }
     const short = byPath.get("short-memory.md");
     if (short) {
-      await mkdir10(join29(root, AGENTS_REL2, "short-memory"), { recursive: true });
-      await writeFile11(join29(root, AGENTS_REL2, "short-memory", `${slug}.md`), short);
+      await mkdir10(join33(root, AGENTS_REL2, "short-memory"), { recursive: true });
+      await writeFile13(join33(root, AGENTS_REL2, "short-memory", `${slug}.md`), short);
     }
     const long = byPath.get("long-memory.md");
     if (long) {
-      await mkdir10(join29(root, AGENTS_REL2, "long-memory"), { recursive: true });
-      await writeFile11(join29(root, AGENTS_REL2, "long-memory", `${slug}.md`), long);
+      await mkdir10(join33(root, AGENTS_REL2, "long-memory"), { recursive: true });
+      await writeFile13(join33(root, AGENTS_REL2, "long-memory", `${slug}.md`), long);
     }
   } else {
-    const base = join29(root, SKILLS_REL2, slug);
+    const base = join33(root, SKILLS_REL2, slug);
     for (const [rel, buf] of byPath) {
       if (rel.includes("..") || rel.startsWith("/")) continue;
-      const dest = join29(base, rel);
+      const dest = join33(base, rel);
       await mkdir10(dirname10(dest), { recursive: true });
-      await writeFile11(dest, buf);
+      await writeFile13(dest, buf);
     }
   }
 }
@@ -44693,11 +45932,11 @@ async function removePackage(root, slug) {
     const entry = manifest[n];
     if (!entry) return { ok: false, error: "not installed" };
     if (entry.kind === "subagent") {
-      await rm6(join29(root, AGENTS_REL2, `${n}.md`), { force: true });
-      await rm6(join29(root, AGENTS_REL2, "short-memory", `${n}.md`), { force: true });
-      await rm6(join29(root, AGENTS_REL2, "long-memory", `${n}.md`), { force: true });
+      await rm8(join33(root, AGENTS_REL2, `${n}.md`), { force: true });
+      await rm8(join33(root, AGENTS_REL2, "short-memory", `${n}.md`), { force: true });
+      await rm8(join33(root, AGENTS_REL2, "long-memory", `${n}.md`), { force: true });
     } else {
-      await rm6(join29(root, SKILLS_REL2, n), { recursive: true, force: true });
+      await rm8(join33(root, SKILLS_REL2, n), { recursive: true, force: true });
     }
     delete manifest[n];
     await writeManifest(root, manifest);
@@ -44708,8 +45947,8 @@ async function removePackage(root, slug) {
 }
 
 // src/core/graph.ts
-import { readFile as readFile15, readdir as readdir6 } from "fs/promises";
-import { join as join30, relative as relative2, dirname as dirname11, resolve as resolve12, extname as extname2, basename as basename6 } from "path";
+import { readFile as readFile18, readdir as readdir8 } from "fs/promises";
+import { join as join34, relative as relative2, dirname as dirname11, resolve as resolve12, extname as extname2, basename as basename6 } from "path";
 var MAX_FILES = 2e3;
 var MAX_NODES = 3e3;
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "out", "coverage", ".turbo"]);
@@ -44721,7 +45960,7 @@ async function walk(root, accept) {
     const dir2 = stack.pop();
     let entries2;
     try {
-      entries2 = await readdir6(dir2, { withFileTypes: true });
+      entries2 = await readdir8(dir2, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -44729,7 +45968,7 @@ async function walk(root, accept) {
       if (e.name.startsWith(".") && e.name !== ".claude") {
         if (e.isDirectory()) continue;
       }
-      const full = join30(dir2, e.name);
+      const full = join34(dir2, e.name);
       if (e.isDirectory()) {
         if (!SKIP_DIRS.has(e.name)) stack.push(full);
       } else if (accept(full)) {
@@ -44757,7 +45996,7 @@ async function buildDocs(root) {
     const rel = relative2(root, f2).split("\\").join("/");
     let text = "";
     try {
-      text = await readFile15(f2, "utf8");
+      text = await readFile18(f2, "utf8");
     } catch {
       continue;
     }
@@ -44796,7 +46035,7 @@ async function buildCode(root) {
     const rel = relative2(root, f2).split("\\").join("/");
     let text = "";
     try {
-      text = await readFile15(f2, "utf8");
+      text = await readFile18(f2, "utf8");
     } catch {
       continue;
     }
@@ -44848,17 +46087,17 @@ async function buildGraph(root, mode) {
 }
 
 // src/core/rag.ts
-import { readFile as readFile16, writeFile as writeFile12, statfs as statfs2, mkdir as mkdir11 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
-import { execFile as execFile12, spawn as spawn10 } from "child_process";
+import { readFile as readFile19, writeFile as writeFile14, statfs as statfs2, mkdir as mkdir11 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import { execFile as execFile15, spawn as spawn10 } from "child_process";
 import { totalmem as totalmem2, cpus as cpus2 } from "os";
-import { join as join31 } from "path";
-import { promisify as promisify12 } from "util";
-var run11 = promisify12(execFile12);
+import { join as join35 } from "path";
+import { promisify as promisify15 } from "util";
+var run14 = promisify15(execFile15);
 var RAG_REL = ".claude/rag";
 async function tryRun(cmd, args) {
   try {
-    const { stdout } = await run11(cmd, args, { timeout: 8e3 });
+    const { stdout } = await run14(cmd, args, { timeout: 8e3 });
     return { ok: true, out: stdout.trim() };
   } catch {
     return { ok: false, out: "" };
@@ -44873,7 +46112,7 @@ async function detectPython() {
 }
 async function installLog(root) {
   try {
-    const text = await readFile16(join31(root, RAG_REL, "install.log"), "utf8");
+    const text = await readFile19(join35(root, RAG_REL, "install.log"), "utf8");
     return text.split("\n").filter((l) => l.length > 0).slice(-200);
   } catch {
     return [];
@@ -44935,14 +46174,14 @@ async function ragStatus(root) {
   };
   let modelName = "";
   try {
-    modelName = (await readFile16(join31(root, RAG_REL, ".installed"), "utf8")).trim();
+    modelName = (await readFile19(join35(root, RAG_REL, ".installed"), "utf8")).trim();
   } catch {
     modelName = "";
   }
   const modelPresent = modelName.length > 0;
   return {
     installed: fastembed && sqliteVec && modelPresent,
-    installing: existsSync16(join31(root, RAG_REL, ".installing")),
+    installing: existsSync17(join35(root, RAG_REL, ".installing")),
     python: { found: py.found, version: py.version },
     deps: { pip, fastembed, sqliteVec },
     model: { present: modelPresent, name: modelName },
@@ -44953,9 +46192,9 @@ async function ragStatus(root) {
   };
 }
 async function readIndexMeta(root) {
-  const indexing = existsSync16(join31(root, RAG_REL, ".indexing"));
+  const indexing = existsSync17(join35(root, RAG_REL, ".indexing"));
   try {
-    const m2 = JSON.parse(await readFile16(join31(root, RAG_REL, ".index.json"), "utf8"));
+    const m2 = JSON.parse(await readFile19(join35(root, RAG_REL, ".index.json"), "utf8"));
     return {
       present: true,
       indexing,
@@ -45022,14 +46261,14 @@ if __name__ == "__main__":
     elif cmd == "query": query(sys.argv[2], int(sys.argv[3]) if len(sys.argv) > 3 else 8)
 `;
 async function ensureEngine(root) {
-  await mkdir11(join31(root, RAG_REL), { recursive: true }).catch(() => void 0);
-  await writeFile12(join31(root, RAG_REL, "rag_engine.py"), RAG_ENGINE_PY, "utf8");
+  await mkdir11(join35(root, RAG_REL), { recursive: true }).catch(() => void 0);
+  await writeFile14(join35(root, RAG_REL, "rag_engine.py"), RAG_ENGINE_PY, "utf8");
 }
 async function ragReindex(root) {
   const py = await detectPython();
   if (!py.found) return { ok: false, started: false, error: "python3 not found" };
-  if (!existsSync16(join31(root, RAG_REL, ".installed"))) return { ok: false, started: false, error: "RAG is not installed" };
-  if (existsSync16(join31(root, RAG_REL, ".indexing"))) return { ok: true, started: true };
+  if (!existsSync17(join35(root, RAG_REL, ".installed"))) return { ok: false, started: false, error: "RAG is not installed" };
+  if (existsSync17(join35(root, RAG_REL, ".indexing"))) return { ok: true, started: true };
   await ensureEngine(root);
   const script = `
 set +e
@@ -45049,12 +46288,12 @@ rm -f "${RAG_REL}/.indexing"
 async function ragQuery(root, queryText, k2 = 8) {
   const py = await detectPython();
   if (!py.found) return { results: [], error: "python3 not found" };
-  if (!existsSync16(join31(root, RAG_REL, "index.db"))) return { results: [], error: "no index \u2014 reindex first" };
+  if (!existsSync17(join35(root, RAG_REL, "index.db"))) return { results: [], error: "no index \u2014 reindex first" };
   await ensureEngine(root);
   try {
-    const { stdout } = await run11(
+    const { stdout } = await run14(
       py.bin,
-      [join31(RAG_REL, "rag_engine.py"), "query", queryText, String(Math.min(Math.max(k2, 1), 20))],
+      [join35(RAG_REL, "rag_engine.py"), "query", queryText, String(Math.min(Math.max(k2, 1), 20))],
       { cwd: root, timeout: 3e4, maxBuffer: 4 * 1024 * 1024 }
     );
     const parsed = JSON.parse(stdout.trim() || '{"results":[]}');
@@ -45069,9 +46308,9 @@ async function ragInstall(root, model) {
   }
   const py = await detectPython();
   if (!py.found) return { ok: false, started: false, error: "python3 not found on the worker" };
-  if (existsSync16(join31(root, RAG_REL, ".installing"))) return { ok: true, started: true };
+  if (existsSync17(join35(root, RAG_REL, ".installing"))) return { ok: true, started: true };
   try {
-    await mkdir11(join31(root, RAG_REL), { recursive: true });
+    await mkdir11(join35(root, RAG_REL), { recursive: true });
   } catch {
   }
   const script = `
@@ -45098,8 +46337,8 @@ rm -f "${RAG_REL}/.installing"
 }
 
 // src/core/config-sync.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
+import { join as join36 } from "path";
 var SERVER_MANAGED_KEYS = [
   "physicPath",
   "sessionSwitchPct",
@@ -45116,8 +46355,8 @@ var SERVER_MANAGED_KEYS = [
   "projectAiMemoryBudgetChars"
 ];
 function readConfigText(profileDir2) {
-  const path = join32(profileDir2, "config.json");
-  if (existsSync17(path)) {
+  const path = join36(profileDir2, "config.json");
+  if (existsSync18(path)) {
     try {
       return readFileSync16(path, "utf8");
     } catch {
@@ -45839,6 +47078,7 @@ var WsClient = class {
         this.startUsagePolling();
         this.startLogUpload();
         this.startKbRefresh();
+        onReconnectVerifyClaim(this.hctx);
         const servedRoot = () => this.physicRoot;
         startGitSnapshots({
           get physicRoot() {
@@ -46009,7 +47249,7 @@ var WsClient = class {
   /** Create the physic folder at an absolute path if missing (best-effort). */
   ensurePhysicFolderPath(folder) {
     try {
-      if (!existsSync18(folder)) {
+      if (!existsSync19(folder)) {
         mkdirSync9(folder, { recursive: true });
         this.bus.log(t("project.createdFolder", { folder }));
       }
@@ -46024,7 +47264,7 @@ var WsClient = class {
    */
   physicFolderPath(projectName) {
     const safe = projectName.replace(/[/\\]/g, "_").replace(/\.\./g, "_").trim();
-    return safe ? join33(this.context.profileDir, safe) : null;
+    return safe ? join37(this.context.profileDir, safe) : null;
   }
   /**
    * Report machine.status: version + the state of the physic project being served
@@ -46039,7 +47279,7 @@ var WsClient = class {
       projects: [],
       version: CLI_VERSION,
       physicPath,
-      physicPathExists: physicPath ? existsSync18(physicPath) : void 0,
+      physicPathExists: physicPath ? existsSync19(physicPath) : void 0,
       // Real coarse state (ADR-0152): !paused and a recent tick (was hard-coded false).
       autonomousRunning: physicPath ? isAutonomousRunning(physicPath, this.context.profileDir) : false,
       // The machine-user AI-run limit (0 = unlimited) + profile count so a dispatch can resolve the
@@ -46136,7 +47376,7 @@ var WsClient = class {
    */
   uploadLog() {
     try {
-      const upload = readLogUpload(join33(this.context.profileDir, "logs"));
+      const upload = readLogUpload(join37(this.context.profileDir, "logs"));
       if (!upload) return;
       const sig = `${upload.fileName}:${upload.totalBytes}`;
       if (sig === this.lastLogSig) return;
@@ -46299,9 +47539,9 @@ var WsClient = class {
 
 // src/core/instance-lock.ts
 import { readFileSync as readFileSync17, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "fs";
-import { join as join34 } from "path";
+import { join as join38 } from "path";
 function lockPath(profileDir2) {
-  return join34(profileDir2, "start.lock");
+  return join38(profileDir2, "start.lock");
 }
 function isAlive(pid) {
   try {
@@ -46623,7 +47863,7 @@ var SessionBus = class {
 // src/core/control-server.ts
 import { createServer } from "net";
 import { chmodSync as chmodSync5, rmSync as rmSync10 } from "fs";
-import { join as join36 } from "path";
+import { join as join40 } from "path";
 
 // src/core/control-protocol.ts
 var CONTROL_SOCKET_FILE = "control.sock";
@@ -46654,9 +47894,9 @@ function createFrameParser() {
 // src/core/control-token.ts
 import { chmodSync as chmodSync4, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
 import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
-import { join as join35 } from "path";
+import { join as join39 } from "path";
 function controlTokenPath(profileDir2) {
-  return join35(profileDir2, CONTROL_TOKEN_FILE);
+  return join39(profileDir2, CONTROL_TOKEN_FILE);
 }
 function writeControlToken(profileDir2) {
   const token = randomBytes3(32).toString("hex");
@@ -46685,7 +47925,7 @@ function tokenMatches(expected, given) {
 
 // src/core/control-server.ts
 function startControlServer(bus, profileDir2, info) {
-  const socketPath = join36(profileDir2, CONTROL_SOCKET_FILE);
+  const socketPath = join40(profileDir2, CONTROL_SOCKET_FILE);
   try {
     rmSync10(socketPath, { force: true });
   } catch {
@@ -47071,11 +48311,11 @@ var isOldWindows = () => {
   }
   const parts = os2.release().split(".");
   const major = Number(parts[0]);
-  const build = Number(parts[2] ?? 0);
+  const build2 = Number(parts[2] ?? 0);
   if (major < 10) {
     return true;
   }
-  if (major === 10 && build < 10586) {
+  if (major === 10 && build2 < 10586) {
     return true;
   }
   return false;
@@ -52442,15 +53682,15 @@ var import_react21 = __toESM(require_react(), 1);
 var import_react26 = __toESM(require_react(), 1);
 
 // src/core/input-history.ts
-import { existsSync as existsSync20, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
+import { join as join41 } from "path";
 var MAX_HISTORY = 200;
 function historyPath(profileDir2) {
-  return join37(profileDir2, "input-history.json");
+  return join41(profileDir2, "input-history.json");
 }
 function loadInputHistory(profileDir2) {
   const path = historyPath(profileDir2);
-  if (!existsSync20(path)) return [];
+  if (!existsSync21(path)) return [];
   try {
     const data = JSON.parse(readFileSync20(path, "utf8"));
     return Array.isArray(data) ? data.filter((x) => typeof x === "string") : [];
@@ -52573,10 +53813,10 @@ function AiMarkerLine({ line }) {
   const idx = line.text.indexOf(arrow);
   if (idx < 0) return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: line.text || " " });
   const before = line.text.slice(0, idx);
-  const stamp = line.kind === "aireq" ? START_STAMP_RE.exec(before)?.[1] ?? "" : "";
-  const name = stamp ? before.slice(stamp.length) : before;
+  const stamp2 = line.kind === "aireq" ? START_STAMP_RE.exec(before)?.[1] ?? "" : "";
+  const name = stamp2 ? before.slice(stamp2.length) : before;
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(Text, { children: [
-    stamp ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: stamp }) : null,
+    stamp2 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: stamp2 }) : null,
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { color: "cyan", bold: true, children: name }),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { dimColor: true, children: arrow }),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { children: line.text.slice(idx + 1) })
@@ -53060,7 +54300,7 @@ async function runStart(profileDir2, profileName) {
     return;
   }
   logger.configure({
-    dir: join38(profileDir2, "logs"),
+    dir: join42(profileDir2, "logs"),
     level: resolveLogLevel(),
     base: { version: CLI_VERSION, profile: profileName, scope: credential.scope }
   });
@@ -53170,7 +54410,7 @@ async function runStart(profileDir2, profileName) {
 }
 
 // src/commands/attach.ts
-import { join as join39 } from "path";
+import { join as join43 } from "path";
 
 // src/core/control-client.ts
 import { connect as connect2 } from "net";
@@ -53279,7 +54519,7 @@ async function runAttach(profileDir2, profileName) {
     process.exitCode = 1;
     return;
   }
-  const socketPath = join39(profileDir2, CONTROL_SOCKET_FILE);
+  const socketPath = join43(profileDir2, CONTROL_SOCKET_FILE);
   const bus = new SessionBus();
   let conn;
   try {
@@ -53310,11 +54550,11 @@ async function runAttach(profileDir2, profileName) {
 
 // src/commands/auto-run.ts
 import { connect as connect3 } from "net";
-import { join as join40 } from "path";
+import { join as join44 } from "path";
 var AUTO_RUN_TIMEOUT_MS = 3 * 60 * 60 * 1e3;
 async function runAutoRun(profileDir2, profileName) {
   initI18n(readProfileConfig(profileDir2).locale);
-  const socketPath = join40(profileDir2, CONTROL_SOCKET_FILE);
+  const socketPath = join44(profileDir2, CONTROL_SOCKET_FILE);
   const token = readControlToken(profileDir2);
   const code = await new Promise((resolve13) => {
     let settled = false;
@@ -53371,7 +54611,7 @@ async function runAutoRun(profileDir2, profileName) {
 
 // src/commands/git-credential.ts
 import { connect as connect4 } from "net";
-import { join as join41 } from "path";
+import { join as join45 } from "path";
 var REQUEST_TIMEOUT_MS = 2e4;
 function requestToken(host, path) {
   const profileDir2 = process.env[PROFILE_DIR_ENV];
@@ -53386,7 +54626,7 @@ function requestToken(host, path) {
       socket.destroy();
       resolve13(value);
     };
-    const socket = connect4(join41(profileDir2, CONTROL_SOCKET_FILE));
+    const socket = connect4(join45(profileDir2, CONTROL_SOCKET_FILE));
     socket.setEncoding("utf8");
     const timer = setTimeout(() => finish(null), REQUEST_TIMEOUT_MS);
     socket.on("connect", () => {