@4pm/cli 1.14.0 → 1.18.0

package/dist/index.js

@@ -28873,7 +28873,11 @@ var en_default = {
   "slash.claudeCmd.usage": "usage: /claude-cmd /context  (forwards to the AI CLI)",
   "start.connecting": "Connecting to {server} (profile: {profile})\u2026",
   "start.recovered": "Recovered from an internal error \u2014 reconnecting: {message}",
-  "attach.attached": 'Attached to profile "{profile}" \u2014 the worker runs headless; input is forwarded.'
+  "attach.attached": 'Attached to profile "{profile}" \u2014 the worker runs headless; input is forwarded.',
+  "autoRun.done": "Autonomous cycle complete.",
+  "autoRun.failed": "Autonomous cycle failed to dispatch: {note}",
+  "autoRun.noDaemon": 'No running daemon for profile "{profile}" \u2014 start it first: 4pm start --profile {profile}',
+  "autoRun.timeout": "Autonomous cycle exceeded the time limit \u2014 aborting."
 };
 
 // src/i18n/messages/vi.json
@@ -29051,7 +29055,11 @@ var vi_default = {
   "slash.claudeCmd.usage": "c\xE1ch d\xF9ng: /claude-cmd /context  (chuy\u1EC3n ti\u1EBFp t\u1EDBi AI CLI)",
   "start.connecting": "\u0110ang k\u1EBFt n\u1ED1i t\u1EDBi {server} (h\u1ED3 s\u01A1: {profile})\u2026",
   "start.recovered": "\u0110\xE3 kh\xF4i ph\u1EE5c sau l\u1ED7i n\u1ED9i b\u1ED9 \u2014 \u0111ang k\u1EBFt n\u1ED1i l\u1EA1i: {message}",
-  "attach.attached": '\u0110\xE3 g\u1EAFn v\xE0o h\u1ED3 s\u01A1 "{profile}" \u2014 worker ch\u1EA1y kh\xF4ng giao di\u1EC7n; \u0111\u1EA7u v\xE0o \u0111\u01B0\u1EE3c chuy\u1EC3n ti\u1EBFp.'
+  "attach.attached": '\u0110\xE3 g\u1EAFn v\xE0o h\u1ED3 s\u01A1 "{profile}" \u2014 worker ch\u1EA1y kh\xF4ng giao di\u1EC7n; \u0111\u1EA7u v\xE0o \u0111\u01B0\u1EE3c chuy\u1EC3n ti\u1EBFp.',
+  "autoRun.done": "Chu k\u1EF3 t\u1EF1 \u0111\u1ED9ng \u0111\xE3 ho\xE0n t\u1EA5t.",
+  "autoRun.failed": "Kh\xF4ng \u0111i\u1EC1u ph\u1ED1i \u0111\u01B0\u1EE3c chu k\u1EF3 t\u1EF1 \u0111\u1ED9ng: {note}",
+  "autoRun.noDaemon": 'Kh\xF4ng c\xF3 ti\u1EBFn tr\xECnh n\u1EC1n n\xE0o cho h\u1ED3 s\u01A1 "{profile}" \u2014 h\xE3y kh\u1EDFi \u0111\u1ED9ng tr\u01B0\u1EDBc: 4pm start --profile {profile}',
+  "autoRun.timeout": "Chu k\u1EF3 t\u1EF1 \u0111\u1ED9ng v\u01B0\u1EE3t qu\xE1 gi\u1EDBi h\u1EA1n th\u1EDDi gian \u2014 \u0111ang h\u1EE7y."
 };
 
 // src/i18n/messages/ja.json
@@ -29229,7 +29237,11 @@ var ja_default = {
   "slash.claudeCmd.usage": "\u4F7F\u3044\u65B9: /claude-cmd /context  (AI CLI \u306B\u8EE2\u9001)",
   "start.connecting": "{server} \u306B\u63A5\u7D9A\u4E2D\uFF08\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB: {profile}\uFF09\u2026",
   "start.recovered": "\u5185\u90E8\u30A8\u30E9\u30FC\u304B\u3089\u56DE\u5FA9\u3057\u307E\u3057\u305F \u2014 \u518D\u63A5\u7D9A\u4E2D: {message}",
-  "attach.attached": "\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u300C{profile}\u300D\u306B\u30A2\u30BF\u30C3\u30C1\u3057\u307E\u3057\u305F \u2014 worker \u306F\u30D8\u30C3\u30C9\u30EC\u30B9\u3067\u52D5\u4F5C\u3057\u3001\u5165\u529B\u306F\u8EE2\u9001\u3055\u308C\u307E\u3059\u3002"
+  "attach.attached": "\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u300C{profile}\u300D\u306B\u30A2\u30BF\u30C3\u30C1\u3057\u307E\u3057\u305F \u2014 worker \u306F\u30D8\u30C3\u30C9\u30EC\u30B9\u3067\u52D5\u4F5C\u3057\u3001\u5165\u529B\u306F\u8EE2\u9001\u3055\u308C\u307E\u3059\u3002",
+  "autoRun.done": "\u81EA\u5F8B\u30B5\u30A4\u30AF\u30EB\u304C\u5B8C\u4E86\u3057\u307E\u3057\u305F\u3002",
+  "autoRun.failed": "\u81EA\u5F8B\u30B5\u30A4\u30AF\u30EB\u306E\u30C7\u30A3\u30B9\u30D1\u30C3\u30C1\u306B\u5931\u6557\u3057\u307E\u3057\u305F: {note}",
+  "autoRun.noDaemon": '\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB "{profile}" \u306E\u30C7\u30FC\u30E2\u30F3\u304C\u5B9F\u884C\u3055\u308C\u3066\u3044\u307E\u305B\u3093 \u2014 \u5148\u306B\u8D77\u52D5\u3057\u3066\u304F\u3060\u3055\u3044: 4pm start --profile {profile}',
+  "autoRun.timeout": "\u81EA\u5F8B\u30B5\u30A4\u30AF\u30EB\u304C\u5236\u9650\u6642\u9593\u3092\u8D85\u3048\u307E\u3057\u305F \u2014 \u4E2D\u6B62\u3057\u307E\u3059\u3002"
 };
 
 // src/i18n/messages/zh.json
@@ -29407,7 +29419,11 @@ var zh_default = {
   "slash.claudeCmd.usage": "\u7528\u6CD5\uFF1A/claude-cmd /context  (\u8F6C\u53D1\u7ED9 AI CLI)",
   "start.connecting": "\u6B63\u5728\u8FDE\u63A5\u5230 {server}\uFF08\u914D\u7F6E\u6587\u4EF6\uFF1A{profile}\uFF09\u2026",
   "start.recovered": "\u5DF2\u4ECE\u5185\u90E8\u9519\u8BEF\u4E2D\u6062\u590D \u2014 \u6B63\u5728\u91CD\u65B0\u8FDE\u63A5\uFF1A{message}",
-  "attach.attached": "\u5DF2\u9644\u52A0\u5230\u914D\u7F6E\u6587\u4EF6 \u201C{profile}\u201D \u2014 worker \u4EE5\u65E0\u754C\u9762\u65B9\u5F0F\u8FD0\u884C\uFF1B\u8F93\u5165\u5C06\u88AB\u8F6C\u53D1\u3002"
+  "attach.attached": "\u5DF2\u9644\u52A0\u5230\u914D\u7F6E\u6587\u4EF6 \u201C{profile}\u201D \u2014 worker \u4EE5\u65E0\u754C\u9762\u65B9\u5F0F\u8FD0\u884C\uFF1B\u8F93\u5165\u5C06\u88AB\u8F6C\u53D1\u3002",
+  "autoRun.done": "\u81EA\u4E3B\u5FAA\u73AF\u5DF2\u5B8C\u6210\u3002",
+  "autoRun.failed": "\u81EA\u4E3B\u5FAA\u73AF\u8C03\u5EA6\u5931\u8D25\uFF1A{note}",
+  "autoRun.noDaemon": "\u914D\u7F6E\u6587\u4EF6 \u201C{profile}\u201D \u6CA1\u6709\u6B63\u5728\u8FD0\u884C\u7684\u5B88\u62A4\u8FDB\u7A0B \u2014 \u8BF7\u5148\u542F\u52A8\uFF1A4pm start --profile {profile}",
+  "autoRun.timeout": "\u81EA\u4E3B\u5FAA\u73AF\u8D85\u8FC7\u65F6\u95F4\u9650\u5236 \u2014 \u6B63\u5728\u4E2D\u6B62\u3002"
 };
 
 // src/i18n/messages/index.ts
@@ -32706,7 +32722,7 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
 
 // src/core/ws-client.ts
 init_wrapper();
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { basename as basename7, join as join28 } from "path";
 import { existsSync as existsSync16, mkdirSync as mkdirSync7 } from "fs";
 
@@ -37098,10 +37114,32 @@ var taskApproveRequestSchema = external_exports.object({
   taskId: external_exports.string().min(1).max(64),
   approved: external_exports.boolean()
 });
+var taskApproveEntrySchema = external_exports.object({
+  taskId: external_exports.string().min(1).max(64),
+  tags: external_exports.array(external_exports.string().min(1).max(64)).max(16).default([])
+});
+var taskApproveBatchRequestSchema = external_exports.object({
+  approvals: external_exports.array(taskApproveEntrySchema).max(500).default([]),
+  unapprovals: external_exports.array(external_exports.string().min(1).max(64)).max(500).default([])
+});
 var autonomousWriteRequestSchema = external_exports.discriminatedUnion("kind", [
   external_exports.object({ kind: external_exports.literal("settings"), settings: external_exports.string().max(64 * 1024) }),
   external_exports.object({ kind: external_exports.literal("approvals"), taskId: external_exports.string().min(1).max(64), approved: external_exports.boolean() }),
+  // Batched approvals (ADR-0311): commit many approve/unapprove ids in ONE approvals-file write, so a
+  // Save's coupled batch lands atomically. Constructed by the server after its tag actions succeed.
+  external_exports.object({
+    kind: external_exports.literal("approvalsBatch"),
+    approve: external_exports.array(external_exports.string().min(1).max(64)).max(500),
+    unapprove: external_exports.array(external_exports.string().min(1).max(64)).max(500)
+  }),
   external_exports.object({ kind: external_exports.literal("userTodo"), content: external_exports.string().min(1).max(16 * 1024) }),
+  // Traced book save (ADR-0320): the cli diffs rows by id + stamps `.autonomous.authors.json` so
+  // authorship is server-filled, not a spoofable `.md` cell. `by`/author are added server-side.
+  external_exports.object({
+    kind: external_exports.literal("bookSave"),
+    book: external_exports.enum(["userTodo", "userQa", "aiTodo"]),
+    content: external_exports.string().max(256 * 1024)
+  }),
   external_exports.object({ kind: external_exports.literal("cron"), action: external_exports.enum(["install", "uninstall"]) })
 ]);
 var autonomousLogsQuerySchema = external_exports.object({
@@ -37288,11 +37326,14 @@ var repoSpecSchema = external_exports.object({
   role: external_exports.string().max(60).optional().default(""),
   /** Free-form description of what this repo holds (optional). */
   desc: external_exports.string().max(500).optional().default(""),
-  /** Exactly one repo of the project is the primary. */
+  /** Exactly one repo of the project is the primary (the root); the rest are submodules. */
   primary: external_exports.boolean().optional().default(false),
   /** Clone url — `https` or `ssh` (required; ADR-0172). */
   url: external_exports.string().max(500).regex(GIT_URL_RE, "must be an https or ssh git url"),
-  /** Sub-repo subfolder under the target root (empty ⇒ derived from role/name). */
+  /**
+   * Folder under the root: **empty for the primary** (the root itself), **non-empty and unique for a
+   * submodule** — the path `git submodule add` attaches it at (ADR-0316).
+   */
   subdir: external_exports.string().max(120).optional().default(""),
   /**
    * Primary branch to clone / check out (ADR-0292). Empty ⇒ the repo's default branch. The
@@ -37301,9 +37342,38 @@ var repoSpecSchema = external_exports.object({
    */
   branch: external_exports.string().max(200).optional().default("")
 });
-function repoName(url) {
-  const last = (url || "").trim().replace(/\/+$/, "").split(/[/:]/).pop() ?? "";
-  return last.replace(/\.git$/i, "");
+function validateProjectRepos(repos, ctx, path = ["repos"]) {
+  const list = repos ?? [];
+  const issue = (message) => ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path, message });
+  if (list.length < 1) {
+    issue("a project must declare at least one repo");
+    return;
+  }
+  const primaries = list.filter((r) => r.primary);
+  if (primaries.length !== 1) {
+    issue("exactly one repo must be primary");
+  }
+  for (const r of list) {
+    if (r.primary) {
+      if ((r.subdir ?? "").trim() !== "") issue("the primary repo must be at the root (no subfolder)");
+    } else if ((r.subdir ?? "").trim() === "") {
+      issue("each submodule needs a folder path");
+    }
+  }
+  const seenDir = /* @__PURE__ */ new Set();
+  for (const r of list) {
+    const dir2 = (r.subdir ?? "").trim().toLowerCase();
+    if (!dir2) continue;
+    if (seenDir.has(dir2)) issue("submodule folder paths must be unique");
+    seenDir.add(dir2);
+  }
+  const seenUrl = /* @__PURE__ */ new Set();
+  for (const r of list) {
+    const url = (r.url ?? "").trim().toLowerCase();
+    if (!url) continue;
+    if (seenUrl.has(url)) issue("repo URLs must be unique");
+    seenUrl.add(url);
+  }
 }
 var specFieldEnvelopeSchema = external_exports.object({
   id: external_exports.string().min(1),
@@ -37335,16 +37405,7 @@ var projectSpecSchema = external_exports.object({
       });
     }
   }
-  if (v2.repos && v2.repos.length > 0) {
-    const primaries = v2.repos.filter((r) => r.primary).length;
-    if (primaries !== 1) {
-      ctx.addIssue({
-        code: external_exports.ZodIssueCode.custom,
-        path: ["repos"],
-        message: "exactly one primary repo is required"
-      });
-    }
-  }
+  validateProjectRepos(v2.repos, ctx);
 });
 var createFromSpecRequestSchema = external_exports.object({
   projectId: external_exports.string().uuid(),
@@ -37354,14 +37415,7 @@ var addRepoRequestSchema = external_exports.object({
   projectId: external_exports.string().uuid(),
   repos: external_exports.array(repoSpecSchema).min(1)
 }).superRefine((v2, ctx) => {
-  const primaries = v2.repos.filter((r) => r.primary).length;
-  if (primaries !== 1) {
-    ctx.addIssue({
-      code: external_exports.ZodIssueCode.custom,
-      path: ["repos"],
-      message: "Exactly one repo must be primary"
-    });
-  }
+  validateProjectRepos(v2.repos, ctx);
 });
 var addProjectRepoRequestSchema = external_exports.object({
   /** Clone url — `https` or `ssh` (required; ADR-0172). */
@@ -37439,7 +37493,7 @@ var activityHeartbeatSchema = external_exports.object({
 });
 
 // src/core/scaffold.ts
-import { cp, mkdir, readdir, rename, rm, writeFile } from "fs/promises";
+import { cp, mkdir, rm, writeFile } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { execFile as execFile2 } from "child_process";
 import { dirname as dirname3, join as join6, resolve } from "path";
@@ -37524,89 +37578,111 @@ function reposOf(spec) {
   const repos = spec?.repos;
   return Array.isArray(repos) ? repos : [];
 }
-function folderName(repo) {
-  const raw = (repo.subdir || repo.role || repoName(repo.url ?? "") || "repo").trim();
-  return raw.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-}
-function repoFolders(repos) {
-  const used = /* @__PURE__ */ new Set();
-  return repos.map((r) => {
-    const base = folderName(r);
-    let name = base;
-    let n = 2;
-    while (used.has(name)) name = `${base}-${n++}`;
-    used.add(name);
-    return name;
-  });
+function singleRepo(repos) {
+  return repos.find((r) => r.primary) ?? repos[0] ?? null;
+}
+function submodulesOf(repos) {
+  const primary = singleRepo(repos);
+  return repos.filter((r) => r !== primary && !!r.url && !!(r.subdir ?? "").trim());
+}
+async function attachSubmodules(root, submodules, emit) {
+  if (submodules.length === 0) return;
+  if (!existsSync4(join6(root, ".git"))) return;
+  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 {
+        await run2("git", ["submodule", "update", "--init", "--", dir2], { cwd: root, timeout: 12e4 });
+      } catch {
+      }
+      continue;
+    }
+    emit("submodule", `Adding submodule ${sub.url} \u2192 ${dir2}\u2026`);
+    const b2 = (sub.branch ?? "").trim();
+    try {
+      await run2("git", ["submodule", "add", ...b2 ? ["-b", b2] : [], sub.url, dir2], { cwd: root, timeout: 12e4 });
+      added++;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (/already exists|already registered|in the index/i.test(msg)) {
+        try {
+          await run2("git", ["submodule", "update", "--init", "--", dir2], { cwd: root, timeout: 12e4 });
+          added++;
+        } catch {
+        }
+      } else {
+        throw new Error(`git submodule add ${dir2} failed: ${msg}`);
+      }
+    }
+  }
+  if (added > 0) await commitAndPushSubmodules(root, submodules, emit);
+}
+async function commitAndPushSubmodules(root, submodules, emit) {
+  const dirs = submodules.map((s3) => (s3.subdir ?? "").trim()).filter(Boolean);
+  emit("submodule", "Committing .gitmodules\u2026");
+  await run2("git", ["add", ".gitmodules", ...dirs], { cwd: root, timeout: 6e4 });
+  const staged = (await run2("git", ["diff", "--cached", "--name-only"], { cwd: root, timeout: 3e4 })).stdout.trim();
+  if (!staged) return;
+  const commitArgs = ["commit", "-m", "chore: add git submodules (4PM)"];
+  try {
+    await run2("git", commitArgs, { cwd: root, timeout: 6e4 });
+  } catch {
+    await run2("git", ["-c", "user.name=4PM", "-c", "user.email=noreply@4pm.app", ...commitArgs], { cwd: root, timeout: 6e4 });
+  }
+  emit("submodule", "Pushing .gitmodules to the primary remote\u2026");
+  try {
+    await run2("git", ["push"], { 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}`);
+  }
 }
 function cloneArgs(url, dest, branch) {
   const b2 = (branch ?? "").trim();
   return b2 ? ["clone", "-b", b2, url, dest] : ["clone", url, dest];
 }
-async function updateRepo(dir2, label, branch, emit) {
+async function updateRepo(dir2, branch, emit) {
   const b2 = (branch ?? "").trim();
-  emit("git", `Updating ${label} (fetch + ${b2 ? `checkout ${b2} + ` : ""}fast-forward pull)\u2026`);
+  emit("git", `Updating repository (fetch + ${b2 ? `checkout ${b2} + ` : ""}fast-forward pull)\u2026`);
   await run2("git", ["fetch", "origin", "--prune"], { cwd: dir2, timeout: 12e4 });
   if (b2) await run2("git", ["checkout", b2], { cwd: dir2, timeout: 6e4 });
   await run2("git", ["pull", "--ff-only"], { cwd: dir2, timeout: 12e4 });
 }
-function repoDir(target, repo, folder, legacyRoot) {
-  if (repo.primary && legacyRoot) return target;
-  return join6(target, folder);
-}
-async function provisionRepos(target, repos, emit, opts = {}) {
+async function provisionRepo(target, repo, emit, opts = {}) {
   const mode = opts.mode ?? "clone";
-  const legacyRoot = existsSync4(join6(target, ".git"));
-  const folders = repoFolders(repos);
-  const foldersToKeep = new Set(
-    repos.map((r, i) => r.primary && legacyRoot ? null : folders[i]).filter((f2) => !!f2)
-  );
-  for (const [i, repo] of repos.entries()) {
-    const folder = folders[i];
-    const atRoot = !!repo.primary && legacyRoot;
-    const dir2 = repoDir(target, repo, folder, legacyRoot);
-    const label = repo.primary ? "primary repo" : `repo ${folder}`;
-    if (!repo.url) {
-      if (!existsSync4(join6(dir2, ".git"))) {
-        emit("git", `Initializing ${label}\u2026`);
-        await mkdir(dir2, { recursive: true });
-        await run2("git", ["init"], { cwd: dir2, timeout: 2e4 });
-      }
-      continue;
+  if (!repo.url) {
+    if (!existsSync4(join6(target, ".git"))) {
+      emit("git", "Initializing repository\u2026");
+      await mkdir(target, { recursive: true });
+      await run2("git", ["init"], { cwd: target, timeout: 2e4 });
     }
-    if (existsSync4(join6(dir2, ".git"))) {
-      if (mode === "sync") {
-        await updateRepo(dir2, label, repo.branch, emit);
-      } else if (mode === "force" && atRoot) {
-        emit("git", `Re-cloning ${repo.url} (force)\u2026`);
-        const tmp = `${target}.4pm-reclone`;
-        await rm(tmp, { recursive: true, force: true });
-        await run2("git", cloneArgs(repo.url, tmp, repo.branch), { timeout: 12e4 });
-        for (const entry of await readdir(target)) {
-          if (foldersToKeep.has(entry)) continue;
-          await rm(join6(target, entry), { recursive: true, force: true });
-        }
-        for (const entry of await readdir(tmp)) {
-          if (foldersToKeep.has(entry)) continue;
-          await rename(join6(tmp, entry), join6(target, entry));
-        }
-        await rm(tmp, { recursive: true, force: true });
-      } else if (mode === "force") {
-        emit("git", `Re-cloning ${repo.url} (force)\u2026`);
-        await rm(dir2, { recursive: true, force: true });
-        await run2("git", cloneArgs(repo.url, dir2, repo.branch), { timeout: 12e4 });
-      } else {
-        emit("git", `${label} already present \u2014 skipping clone.`);
-      }
-      continue;
+    return;
+  }
+  if (existsSync4(join6(target, ".git"))) {
+    if (mode === "sync") {
+      await updateRepo(target, repo.branch, emit);
+    } else if (mode === "force") {
+      emit("git", `Re-cloning ${repo.url} (force)\u2026`);
+      await rm(target, { recursive: true, force: true });
+      await run2("git", cloneArgs(repo.url, target, repo.branch), { timeout: 12e4 });
+    } else {
+      emit("git", "Repository already present \u2014 skipping clone.");
     }
-    emit("git", `Cloning ${repo.url}\u2026`);
-    await run2("git", cloneArgs(repo.url, dir2, repo.branch), { timeout: 12e4 });
+    return;
   }
+  emit("git", `Cloning ${repo.url}\u2026`);
+  await run2("git", cloneArgs(repo.url, target, repo.branch), { timeout: 12e4 });
 }
 async function ensureReposCloned(physicRoot, repos, emit) {
-  if (repos.length === 0) return;
-  await provisionRepos(physicRoot, repos, emit ?? (() => void 0));
+  const list = repos;
+  const repo = singleRepo(list);
+  if (!repo) return;
+  const step = emit ?? (() => void 0);
+  await provisionRepo(physicRoot, repo, step);
+  await attachSubmodules(physicRoot, submodulesOf(list), step);
 }
 function sampleDir() {
   if (process.env.SCAFFOLD_SAMPLE_DIR) return process.env.SCAFFOLD_SAMPLE_DIR;
@@ -37627,17 +37703,12 @@ async function scaffoldProject(payload, profileDir2, onProgress) {
     const root = process.env.SCAFFOLD_ROOT ? resolve(process.env.SCAFFOLD_ROOT) : resolve(profileDir2);
     const target = join6(root, payload.projectName);
     await mkdir(target, { recursive: true });
-    const repos = reposOf(payload.spec);
-    if (repos.length > 0) {
-      emit("git", "Cloning repositories\u2026");
-      await provisionRepos(target, repos, emit);
-      const folders = repoFolders(repos);
-      for (let i = 0; i < repos.length; i++) {
-        await scaffoldRepo(join6(target, folders[i]), folders[i], payload.spec, emit);
-      }
-    } else {
-      await scaffoldRepo(target, payload.projectName, payload.spec, emit);
-    }
+    const repo = singleRepo(reposOf(payload.spec));
+    if (!repo) throw new Error("A project must declare one repo (ADR-0314).");
+    emit("git", "Cloning repository\u2026");
+    await provisionRepo(target, repo, emit);
+    await scaffoldRepo(target, payload.projectName, payload.spec, emit);
+    await attachSubmodules(target, submodulesOf(reposOf(payload.spec)), emit);
     emit("version", "Writing .4pm/.4pm.json\u2026");
     await writeTemplateMarker(target);
     onProgress?.({ projectId: payload.projectId, step: "done", message: "Scaffold complete.", done: true });
@@ -37723,12 +37794,13 @@ async function addProject(payload, profileDir2, onProgress) {
     const root = process.env.SCAFFOLD_ROOT ? resolve(process.env.SCAFFOLD_ROOT) : resolve(profileDir2);
     const target = join6(root, payload.projectName);
     await mkdir(target, { recursive: true });
-    const repos = payload.repos ?? [];
+    const repo = singleRepo(payload.repos ?? []);
     const mode = payload.mode ?? "clone";
-    if (repos.length > 0) await provisionRepos(target, repos, emit, { mode });
-    for (const sub of payload.scaffoldRepos ?? []) {
-      await scaffoldRepo(join6(target, sub), sub, payload.spec, emit);
+    if (repo) await provisionRepo(target, repo, emit, { mode });
+    if (payload.scaffoldRepos && payload.scaffoldRepos.length > 0) {
+      await scaffoldRepo(target, payload.projectName, payload.spec, emit);
     }
+    await attachSubmodules(target, submodulesOf(payload.repos ?? []), emit);
     onProgress?.({ projectId: payload.projectId, step: "done", message: "Project added.", done: true });
     return { ok: true, path: target };
   } catch (err) {
@@ -38227,7 +38299,7 @@ function decryptPayload(key, payloadBase64, nonceBase64) {
 import { spawn as spawn2 } from "child_process";
 
 // src/common/logger/logger.ts
-import { appendFile, mkdir as mkdir2, readdir as readdir2, unlink } from "fs/promises";
+import { appendFile, mkdir as mkdir2, readdir, 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 };
@@ -38287,7 +38359,7 @@ var CliLogger = class {
   async cleanupOldLogs() {
     const dir2 = this.dir;
     if (!dir2) return;
-    const files = await readdir2(dir2).catch(() => []);
+    const files = await readdir(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);
@@ -38823,7 +38895,6 @@ var ONE_SHOT_DISALLOWED_CLAUDE_TOOLS = [
   "WebSearch",
   "WebFetch",
   "Skill",
-  "SlashCommand",
   "ToolSearch",
   "TaskCreate",
   "TaskGet",
@@ -39564,7 +39635,7 @@ var DOC_EXTENSIONS = [".md", ".mdx", ".txt"];
 function kbRoot(profileDir2) {
   return join14(profileDir2, "support-kb");
 }
-function repoDir2(profileDir2, url, branch) {
+function repoDir(profileDir2, url, branch) {
   const key = createHash3("sha1").update(`${url}#${branch}`).digest("hex").slice(0, 16);
   return join14(kbRoot(profileDir2), key);
 }
@@ -39574,7 +39645,7 @@ function authedUrl(url, token) {
   return url;
 }
 async function ensureRepo(profileDir2, repo) {
-  const dir2 = repoDir2(profileDir2, repo.url, repo.branch);
+  const dir2 = repoDir(profileDir2, repo.url, repo.branch);
   if (existsSync10(join14(dir2, ".git"))) return dir2;
   const url = authedUrl(repo.url, repo.token);
   const gitEnv = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
@@ -39825,6 +39896,7 @@ var run4 = promisify4(execFile4);
 var SETTINGS_REL = ".claude/.autonomous.settings.json";
 var HISTORIES_REL = ".claude/.autonomous.histories.json";
 var APPROVALS_REL = ".claude/.autonomous.approvals.json";
+var AUTHORS_REL = ".claude/.autonomous.authors.json";
 var TICK_REL = ".claude/hooks/autonomous-tick.sh";
 var LOG_DIR_REL = ".claude/logs";
 var BOOK_FILES = {
@@ -39853,6 +39925,35 @@ function parseJson(text) {
 function tableCell(value) {
   return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim();
 }
+async function readJsonMap(path) {
+  return parseJson(await readText(path, "{}")) ?? {};
+}
+function entryBy(map, id) {
+  const e = map[id];
+  return e && typeof e === "object" && typeof e.by === "string" ? e.by : null;
+}
+function tableRowsById(md) {
+  const rows = /* @__PURE__ */ new Map();
+  let headerSeen = false;
+  let inTable = false;
+  for (const line of md.split(/\r?\n/)) {
+    const s3 = line.trim();
+    if (!s3.startsWith("|")) {
+      if (inTable) break;
+      continue;
+    }
+    inTable = true;
+    if (!headerSeen) {
+      headerSeen = true;
+      continue;
+    }
+    if (/^\|[\s:|-]+\|?$/.test(s3)) continue;
+    const cells = s3.replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+    const id = cells[0] ?? "";
+    if (id) rows.set(id, cells.join("
"));
+  }
+  return rows;
+}
 function tickScript(root) {
   return join15(root, TICK_REL);
 }
@@ -39907,16 +40008,17 @@ function isAutonomousRunning(root) {
   }
 }
 async function readAutonomous(root) {
-  const [settings, approvals, status, ...books] = await Promise.all([
+  const [settings, approvals, authors, status, ...books] = await Promise.all([
     readText(join15(root, SETTINGS_REL)),
     readText(join15(root, APPROVALS_REL), "{}"),
+    readText(join15(root, AUTHORS_REL), "{}"),
     getAutonomousStatus(root),
     ...Object.values(BOOK_FILES).map((f2) => readText(join15(root, f2)))
   ]);
   const keys = Object.keys(BOOK_FILES);
   const bookMap = {};
   keys.forEach((k2, i) => bookMap[k2] = books[i] ?? "");
-  return { settings, status, books: bookMap, approvals };
+  return { settings, status, books: bookMap, approvals, authors };
 }
 async function readAutonomousLogs(root, date) {
   const day = date && /^\d{4}-\d{2}-\d{2}$/.test(date) ? date : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -39948,18 +40050,57 @@ async function writeAutonomous(root, req, by) {
         break;
       }
       case "approvals": {
+        if (req.approved && !req.byIsAdmin) {
+          const authors = await readJsonMap(join15(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(join15(root, APPROVALS_REL), "{}")) ?? {};
-        if (req.approved) map[req.taskId] = { approved: true, by, at: (/* @__PURE__ */ new Date()).toISOString() };
+        if (req.approved) map[req.taskId] = { approved: true, by, byLabel: req.byLabel ?? by, at: (/* @__PURE__ */ new Date()).toISOString() };
         else delete map[req.taskId];
         await writeFile2(join15(root, APPROVALS_REL), JSON.stringify(map, null, 2) + "\n", "utf8");
         break;
       }
+      case "approvalsBatch": {
+        if (!req.byIsAdmin) {
+          const authors = await readJsonMap(join15(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(join15(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 writeFile2(join15(root, APPROVALS_REL), JSON.stringify(map, null, 2) + "\n", "utf8");
+        break;
+      }
       case "userTodo": {
         const cur = await readText(join15(root, BOOK_FILES.userTodo));
-        const trace = `posted by ${tableCell(by)} at ${(/* @__PURE__ */ new Date()).toISOString()}`;
-        const row = `| | ${tableCell(req.content)} | ${trace} |
+        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 writeFile2(join15(root, BOOK_FILES.userTodo), cur.replace(/\s*$/, "\n") + row, "utf8");
+        const authors = await readJsonMap(join15(root, AUTHORS_REL));
+        authors[id] = { by, byLabel: req.byLabel ?? by, at: (/* @__PURE__ */ new Date()).toISOString() };
+        await writeFile2(join15(root, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
+        break;
+      }
+      case "bookSave": {
+        const file = BOOK_FILES[req.book];
+        const prev = tableRowsById(await readText(join15(root, file)));
+        const next = tableRowsById(req.content);
+        const authors = await readJsonMap(join15(root, AUTHORS_REL));
+        const at2 = (/* @__PURE__ */ new Date()).toISOString();
+        const byLabel = req.byLabel ?? by;
+        for (const [id, cells] of next) {
+          if (prev.get(id) !== cells) authors[id] = { by, byLabel, at: at2 };
+        }
+        await writeFile2(join15(root, file), req.content, "utf8");
+        await writeFile2(join15(root, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
         break;
       }
       case "cron": {
@@ -40828,8 +40969,10 @@ function handleCommandChannels(ctx, message, payload) {
     text: `$ ${dispatch.cmd} ${dispatch.args.join(" ")}`.trimEnd()
   });
   ctx.bus.startBusy(dispatch.cmd);
+  const cwd2 = dispatch.path ?? ctx.physicRoot ?? readProfileConfig(ctx.profileDir).physicPath ?? process.cwd();
+  const dispatchInRoot = { ...dispatch, path: cwd2 };
   const cmdStartMs = Date.now();
-  void runCommand(dispatch, (out) => {
+  void runCommand(dispatchInRoot, (out) => {
     if (out.chunk) {
       ctx.bus.push({ source: "server", kind: "out", text: out.chunk });
       appendCommandOutput(out.commandId, out.chunk);
@@ -41293,8 +41436,104 @@ function rejectByReview(ctx, commandId, origin, prompt, reasons) {
   });
 }
 
+// src/core/autonomous-cycle.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function buildAutonomousCyclePrompt() {
+  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).
+
+## 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\`,
+\`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 cron tick owns the run lock; you do NOT manage \`.claude/.autonomous.lock\`.`;
+}
+async function runAutonomousCycle(ctx) {
+  const commandId = randomUUID2();
+  try {
+    await runAiPrompt(ctx, buildAutonomousCyclePrompt(), commandId, "local", false, void 0, void 0, false, true);
+    ctx.bus.autonomousDone(true);
+  } catch (err) {
+    ctx.bus.autonomousDone(false, err instanceof Error ? err.message : String(err));
+  }
+}
+
 // src/core/fs-browse.ts
-import { readdir as readdir3 } from "fs/promises";
+import { readdir as readdir2 } from "fs/promises";
 import { resolve as resolve2, sep as sep2 } from "path";
 async function listDir(path, root) {
   if (!root) return { path: "", entries: [] };
@@ -41302,7 +41541,7 @@ async function listDir(path, root) {
   const requested = resolve2(base, path && path.trim() ? path : ".");
   const target = requested === base || requested.startsWith(base + sep2) ? requested : base;
   try {
-    const dirents = await readdir3(target, { withFileTypes: true });
+    const dirents = await readdir2(target, { withFileTypes: true });
     const entries2 = dirents.map((d) => ({
       name: d.name,
       type: d.isDirectory() ? "dir" : "file"
@@ -41370,7 +41609,7 @@ async function writeWorkerFile(root, relPath, content) {
 }
 
 // src/core/fs-mutate.ts
-import { mkdir as mkdir4, writeFile as writeFile4, rename as rename2, rm as rm2, stat } from "fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile4, rename, rm as rm2, stat } from "fs/promises";
 import { basename as basename3, dirname as dirname5, resolve as resolve5, sep as sep5 } from "path";
 var MAX_BYTES3 = 2 * 1024 * 1024;
 function resolveInRoot3(root, rel) {
@@ -41425,7 +41664,7 @@ async function mutateFs(root, req) {
         if (to2 !== resolve5(root) && !to2.startsWith(resolve5(root) + sep5)) return escaped(req.to ?? "");
         if (await exists(to2)) return { ok: false, path: to2, error: "destination already exists" };
         await mkdir4(dirname5(to2), { recursive: true });
-        await rename2(from, to2);
+        await rename(from, to2);
         return { ok: true, path: to2 };
       }
       case "delete": {
@@ -41724,7 +41963,6 @@ async function manageSshKey(op, profileDir2) {
 }
 
 // src/core/git-history.ts
-import { readdir as readdir4 } from "fs/promises";
 import { execFile as execFile9 } from "child_process";
 import { resolve as resolve8, sep as sep8 } from "path";
 import { promisify as promisify9 } from "util";
@@ -41752,36 +41990,21 @@ async function git(cwd2, args) {
 async function gitRepos(root) {
   if (!root) return { repos: [] };
   const base = resolve8(root);
-  const found = /* @__PURE__ */ new Set();
+  const top = (await git(base, ["rev-parse", "--show-toplevel"])).trim();
+  if (!top || !(top === base || top.startsWith(base + sep8))) return { repos: [] };
   const repos = [];
-  const add = async (dir2) => {
-    const inside = await git(dir2, ["rev-parse", "--show-toplevel"]);
-    const top = inside.trim();
-    if (!top || found.has(top) || !(top === base || top.startsWith(base + sep8))) return;
-    found.add(top);
-    const subdir = top === base ? "" : top.slice(base.length + 1);
-    const remote = (await git(top, ["remote", "get-url", "origin"])).trim();
-    repos.push({ subdir, name: subdir || "", remote: remote || null });
-  };
-  await add(base);
-  try {
-    const lvl1 = await readdir4(base, { withFileTypes: true });
-    for (const d of lvl1) {
-      if (!d.isDirectory() || d.name === ".git" || d.name === "node_modules") continue;
-      const p1 = resolve8(base, d.name);
-      await add(p1);
-      try {
-        const lvl2 = await readdir4(p1, { withFileTypes: true });
-        for (const d2 of lvl2) {
-          if (!d2.isDirectory() || d2.name === ".git" || d2.name === "node_modules") continue;
-          await add(resolve8(p1, d2.name));
-        }
-      } catch {
-      }
-    }
-  } catch {
+  const rootRemote = (await git(base, ["remote", "get-url", "origin"])).trim();
+  repos.push({ subdir: "", name: "", remote: rootRemote || null });
+  const subOut = await git(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 = resolve8(base, subPath);
+    if (!(abs === base || abs.startsWith(base + sep8))) continue;
+    const remote = (await git(abs, ["remote", "get-url", "origin"])).trim();
+    repos.push({ subdir: subPath, name: subPath, remote: remote || null });
   }
-  repos.sort((a, b2) => a.subdir.localeCompare(b2.subdir));
   return { repos };
 }
 async function gitLog(root, repo, skip, limit) {
@@ -42304,7 +42527,7 @@ function handleToolsChannels(ctx, message, payload) {
 }
 
 // src/core/agents.ts
-import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir7, readdir as readdir5, rm as rm4 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir7, readdir as readdir3, rm as rm4 } from "fs/promises";
 import { join as join21 } from "path";
 var AGENTS_REL = ".claude/agents";
 var SKILLS_REL = ".claude/skills";
@@ -42329,7 +42552,7 @@ async function listAgents(root) {
   const subagents = [];
   const skills = [];
   try {
-    for (const e of await readdir5(join21(root, AGENTS_REL), { withFileTypes: true })) {
+    for (const e of await readdir3(join21(root, AGENTS_REL), { withFileTypes: true })) {
       if (!e.isFile() || !e.name.endsWith(".md") || MEMORY_DIRS.has(e.name)) continue;
       const fm = frontmatter(await readText2(join21(root, AGENTS_REL, e.name)));
       subagents.push({ name: e.name.replace(/\.md$/, ""), description: fm.description });
@@ -42337,7 +42560,7 @@ async function listAgents(root) {
   } catch {
   }
   try {
-    for (const e of await readdir5(join21(root, SKILLS_REL), { withFileTypes: true })) {
+    for (const e of await readdir3(join21(root, SKILLS_REL), { withFileTypes: true })) {
       if (!e.isDirectory()) continue;
       const fm = frontmatter(await readText2(join21(root, SKILLS_REL, e.name, "SKILL.md")));
       skills.push({ name: e.name, description: fm.description });
@@ -42489,7 +42712,7 @@ async function writeAgentTools(root, scope, permissions) {
 
 // src/core/packages.ts
 import { createHash as createHash4 } from "crypto";
-import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir9, readdir as readdir6, rm as rm5, stat as stat3 } from "fs/promises";
+import { readFile as readFile10, writeFile as writeFile9, mkdir as mkdir9, readdir as readdir4, rm as rm5, stat as stat3 } from "fs/promises";
 import { dirname as dirname9, join as join24, relative } from "path";
 var AGENTS_REL2 = ".claude/agents";
 var SKILLS_REL2 = ".claude/skills";
@@ -42509,7 +42732,7 @@ async function listFilesRel(dir2) {
   async function walk2(d) {
     let entries2;
     try {
-      entries2 = await readdir6(d, { withFileTypes: true });
+      entries2 = await readdir4(d, { withFileTypes: true });
     } catch {
       return;
     }
@@ -42677,7 +42900,7 @@ async function removePackage(root, slug) {
 }
 
 // src/core/graph.ts
-import { readFile as readFile11, readdir as readdir7 } from "fs/promises";
+import { readFile as readFile11, readdir as readdir5 } from "fs/promises";
 import { join as join25, relative as relative2, dirname as dirname10, resolve as resolve9, extname as extname2, basename as basename6 } from "path";
 var MAX_FILES = 2e3;
 var MAX_NODES = 3e3;
@@ -42690,7 +42913,7 @@ async function walk(root, accept) {
     const dir2 = stack.pop();
     let entries2;
     try {
-      entries2 = await readdir7(dir2, { withFileTypes: true });
+      entries2 = await readdir5(dir2, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -43325,6 +43548,7 @@ var WsClient = class {
     );
     this.hctx = this.buildHandlerCtx();
     context.bus.onLocalSubmit((input) => void runLocalCommand(this.hctx, input));
+    context.bus.onAutonomousRun(() => void runAutonomousCycle(this.hctx));
     context.bus.onReconnect(() => this.reconnectNow());
     context.bus.onTranscript((entry) => this.emitConsole({ kind: "add", entry: toDtoEntry(entry) }));
     context.bus.onTranscriptUpdate(
@@ -43874,7 +44098,7 @@ var WsClient = class {
     }
     const { payload, nonce } = encryptPayload(this.sessionKey, data);
     const envelope = {
-      id: randomUUID2(),
+      id: randomUUID3(),
       replyTo,
       channel,
       wsToken: this.wsToken,
@@ -43895,7 +44119,7 @@ var WsClient = class {
       }
       const { payload, nonce } = encryptPayload(this.sessionKey, data);
       const envelope = {
-        id: randomUUID2(),
+        id: randomUUID3(),
         replyTo: null,
         channel,
         wsToken: this.wsToken,
@@ -44284,7 +44508,7 @@ function releaseInstanceLock(profileDir2) {
 
 // src/core/session-bus.ts
 import { EventEmitter } from "events";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var REPLAY_CAP = 500;
 var SessionBus = class {
   emitter = new EventEmitter();
@@ -44315,7 +44539,7 @@ var SessionBus = class {
   /** Producer → consumers: push one transcript entry. Returns its id (for `updateEntry`). */
   push(input) {
     const entry = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       level: "info",
       ...input,
       ts: Date.now()
@@ -44546,6 +44770,28 @@ var SessionBus = class {
     this.emitter.on("reconnect", fn);
     return () => this.emitter.off("reconnect", fn);
   }
+  /**
+   * Trigger → session: run ONE autonomous cycle (ADR-0319). Sent by `4pm auto-run` over the control
+   * socket so the cron tick runs the cycle through THIS daemon's live WS session — reusing its
+   * profile-failover, token metering (ADR-0072) and folder-scope (ADR-0181) — instead of a raw `claude -p`.
+   */
+  submitAutonomous() {
+    this.emitter.emit("autonomous-run");
+  }
+  /** Subscribe to autonomous-cycle triggers. */
+  onAutonomousRun(fn) {
+    this.emitter.on("autonomous-run", fn);
+    return () => this.emitter.off("autonomous-run", fn);
+  }
+  /** Session → trigger: the autonomous cycle settled (ok + an optional note). */
+  autonomousDone(ok, note) {
+    this.emitter.emit("autonomous-done", ok, note);
+  }
+  /** Subscribe to autonomous-cycle completion. */
+  onAutonomousDone(fn) {
+    this.emitter.on("autonomous-done", fn);
+    return () => this.emitter.off("autonomous-done", fn);
+  }
 };
 
 // src/core/control-server.ts
@@ -44608,7 +44854,9 @@ function startControlServer(bus, profileDir2, info) {
     bus.onWorker((worker) => broadcast({ t: "worker", worker })),
     bus.onProject((project) => broadcast({ t: "project", project })),
     bus.onUsage((usage) => broadcast({ t: "usage", usage })),
-    bus.onTokens((total) => broadcast({ t: "tokens", total }))
+    bus.onTokens((total) => broadcast({ t: "tokens", total })),
+    // Report an autonomous cycle's completion back to the `4pm auto-run` client (ADR-0319).
+    bus.onAutonomousDone((ok, note) => broadcast({ t: "autonomousDone", ok, note }))
   ];
   const server = createServer((sock) => {
     clients.add(sock);
@@ -44631,6 +44879,7 @@ function startControlServer(bus, profileDir2, info) {
       for (const frame of parse(chunk)) {
         if (frame.t === "submit") bus.submitLocal(frame.input);
         else if (frame.t === "reconnect") bus.requestReconnect();
+        else if (frame.t === "autonomousRun") bus.submitAutonomous();
       }
     });
     const drop = () => {
@@ -51167,6 +51416,62 @@ async function runAttach(profileDir2, profileName) {
   }
 }
 
+// src/commands/auto-run.ts
+import { connect as connect3 } from "net";
+import { join as join34 } from "path";
+var AUTO_RUN_TIMEOUT_MS = 3 * 60 * 60 * 1e3;
+async function runAutoRun(profileDir2, profileName) {
+  initI18n(readProfileConfig(profileDir2).locale);
+  const socketPath = join34(profileDir2, CONTROL_SOCKET_FILE);
+  const code = await new Promise((resolve10) => {
+    let settled = false;
+    const done = (c) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve10(c);
+    };
+    const socket = connect3(socketPath);
+    socket.setEncoding("utf8");
+    const timer = setTimeout(() => {
+      console.error(t("autoRun.timeout"));
+      done(1);
+    }, AUTO_RUN_TIMEOUT_MS);
+    timer.unref?.();
+    socket.on("connect", () => {
+      try {
+        socket.write(encodeFrame({ t: "autonomousRun" }));
+      } catch {
+        done(1);
+      }
+    });
+    const parse = createFrameParser();
+    socket.on("data", (chunk) => {
+      for (const frame of parse(chunk)) {
+        if (frame.t === "transcript") {
+          if (frame.entry.text) console.log(frame.entry.text);
+        } else if (frame.t === "update") {
+          if (frame.text) console.log(frame.text);
+        } else if (frame.t === "autonomousDone") {
+          if (frame.ok) console.log(t("autoRun.done"));
+          else console.error(t("autoRun.failed", { note: frame.note ?? "" }));
+          done(frame.ok ? 0 : 1);
+        }
+      }
+    });
+    socket.on("error", () => {
+      console.error(t("autoRun.noDaemon", { profile: profileName }));
+      done(1);
+    });
+    socket.on("close", () => done(1));
+  });
+  process.exitCode = code;
+}
+
 // src/commands/ai-login.ts
 import { spawn as spawn11 } from "child_process";
 import { mkdirSync as mkdirSync8 } from "fs";
@@ -51391,6 +51696,15 @@ async function main() {
       await runAttach(profileDir(name), name);
       break;
     }
+    case "auto-run": {
+      const name = await pickLinkedProfile(explicitProfile, "auto-run");
+      if (!name) {
+        process.exitCode = 1;
+        break;
+      }
+      await runAutoRun(profileDir(name), name);
+      break;
+    }
     case "ai-login": {
       const name = await pickLinkedProfile(explicitProfile, "ai-login");
       if (!name) {
@@ -51431,6 +51745,7 @@ async function main() {
           "  4pm link      Pair with the server (pairing \u2192 confirmation code)",
           "  4pm start     Connect WS, receive commands from the server",
           "  4pm attach    Open the TUI against a running headless daemon (ADR-0192)",
+          "  4pm auto-run  Run one autonomous cycle via the running daemon (cron \u2014 ADR-0319)",
           "  4pm ai-login  Log into a profile's AI CLI (claude/codex) in place (ADR-0199)",
           "  4pm unlink    Delete a link (pick a profile if several)",
           "  4pm version   Show the installed version (+ latest from the server)",