@4pm/cli 1.17.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";
 
@@ -37117,6 +37133,13 @@ var autonomousWriteRequestSchema = external_exports.discriminatedUnion("kind", [
     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({
@@ -39873,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 = {
@@ -39901,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);
 }
@@ -39955,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);
@@ -39996,26 +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();
-        for (const taskId of req.approve) map[taskId] = { approved: true, by, at: at2 };
+        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": {
@@ -41351,6 +41436,102 @@ 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 readdir2 } from "fs/promises";
 import { resolve as resolve2, sep as sep2 } from "path";
@@ -43367,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(
@@ -43916,7 +44098,7 @@ var WsClient = class {
     }
     const { payload, nonce } = encryptPayload(this.sessionKey, data);
     const envelope = {
-      id: randomUUID2(),
+      id: randomUUID3(),
       replyTo,
       channel,
       wsToken: this.wsToken,
@@ -43937,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,
@@ -44326,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();
@@ -44357,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()
@@ -44588,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
@@ -44650,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);
@@ -44673,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 = () => {
@@ -51209,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";
@@ -51433,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) {
@@ -51473,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)",

package/dist/project-sample/.claude/.autonomous.settings.json

@@ -1,22 +1,20 @@
 {
-  "_about": "Autonomous workflow config. autonomous-tick.sh READS this file EVERY cron tick, so edits take effect from the next tick. Keys starting with '_' are comments and are ignored by the script.",
+  "_about": "Autonomous workflow config (ADR-0152 + ADR-0319). autonomous-tick.sh READS this file EVERY cron tick, so edits take effect from the next tick. Keys starting with '_' are comments and are ignored by the script.",
   "paused": true,
-  "_paused": "true = PAUSED: the tick still runs but skips immediately, without invoking Claude. A quick brake without removing the crontab entry.",
-  "max_session_pct": 80,
-  "max_weekly_pct": 90,
-  "_quota": "Only run when session_pct < max_session_pct AND weekly_pct < max_weekly_pct (read from the usage skill).",
+  "_paused": "true = PAUSED: the tick still runs but skips immediately, without waking the daemon. A quick brake without removing the crontab entry.",
   "cron_schedule": "*/5 * * * *",
   "_cron_schedule": "Standard 5-field cron. When you change this, the tick rewrites the crontab line pointing at autonomous-tick.sh on the next run (only if the crontab already has the autonomous line — install it once manually first).",
-  "command": "/auto-cycle",
-  "_command": "The headless slash-command each tick invokes.",
-  "model": "",
-  "_model": "Empty = Claude Code's default model. Or set an id (e.g. 'claude-sonnet-4-6') to force a cheaper/faster model for the autonomous loop.",
+  "command": "auto-run",
+  "_command": "The cli subcommand each tick runs. `4pm auto-run` asks the running `4pm start` daemon to run one cycle through its live session (ADR-0319).",
+  "profile": "",
+  "_profile": "Optional profile name for `4pm auto-run --profile <name>`. Empty = the cli resolves the single linked profile (set this only on a worker serving multiple projects).",
+  "_quota_moved": "The session/weekly token gate + account selection moved OUT of this shell into the cli (ADR-0319) — they need the daemon's live usage snapshot. Configure quota-based profile failover in the cli's own config, not here.",
   "quiet_hours": "",
   "_quiet_hours": "Empty = run ALL DAY. Or 'HH:MM-HH:MM' (e.g. '00:00-06:00') to SKIP within that window; a window crossing midnight is valid (e.g. '22:00-06:00').",
   "max_ticks_per_day": -1,
-  "_max_ticks_per_day": "-1 = NO limit. >0 = cap on the number of ticks that actually invoke Claude in one (local) day. The count is stored under ticks{day,count} in .claude/.autonomous.histories.json.",
+  "_max_ticks_per_day": "-1 = NO limit. >0 = cap on the number of ticks that actually wake the daemon in one (local) day. The count is stored under ticks{day,count} in .claude/.autonomous.histories.json.",
   "stop_on_consecutive_failures": 3,
-  "_stop_on_consecutive_failures": "After N consecutive FAILED command runs -> set paused=true to stop safely. 0 = off. The count is stored under consecutive_fails in .claude/.autonomous.histories.json (reset on success).",
+  "_stop_on_consecutive_failures": "After N consecutive FAILED runs (no daemon / dispatch error) -> set paused=true to stop safely. 0 = off. The count is stored under consecutive_fails in .claude/.autonomous.histories.json (reset on success).",
   "log_retention_days": 14,
   "_log_retention_days": "Logs are written per DAY: .claude/logs/autonomous-tick-YYYY-MM-DD.log. Delete log files older than N days. 0 = keep forever.",
   "notify_webhook": "",

package/dist/project-sample/.claude/AUTONOMOUS-CRON.md

@@ -1,9 +1,9 @@
 # Set up a 10-minute cron for `autonomous-tick.sh`
 
 How to install the **autonomous cycle** on **WSL (Ubuntu)**: cron calls
-[`autonomous-tick.sh`](autonomous-tick.sh) every **10 minutes**; each run does one `claude -p /auto-cycle`
-cycle then exits. A file lock (`.claude/.autonomous.lock`) ensures **no two runs overlap** (a later tick
-that sees the lock skips).
+[`autonomous-tick.sh`](autonomous-tick.sh) every **10 minutes**; each run does one **`4pm auto-run`**
+cycle (the running `4pm start` daemon executes it — ADR-0319) then exits. A file lock
+(`.claude/.autonomous.lock`) ensures **no two runs overlap** (a later tick that sees the lock skips).
 
 > All commands below run in a **WSL shell** (Ubuntu) unless noted as PowerShell/Windows. Call the project
 > root `$PROJECT` (e.g. `~/projects/<your-project>`).
@@ -18,9 +18,10 @@ cd "$PROJECT"
 Every line must print a path/version (not "not found"):
 ```bash
 command -v cron   || echo "missing cron"
-command -v claude || echo "missing claude (install natively in WSL)"
+command -v 4pm    || echo "missing 4pm cli (install natively in WSL; a '4pm start' daemon must be running)"
 command -v git    || echo "missing git"
 command -v python3 || echo "missing python3"
+command -v gh     || command -v glab || echo "missing gh/glab (needed for the PR step)"
 ```
 
 ## 2. Make the tick executable + install the cron line

package/dist/project-sample/.claude/AUTONOMOUS.md

@@ -1,34 +1,36 @@
 # Autonomous mode — how it's assembled
 
 > **Sample project — defines the workflow only, does NOT run on its own.** The files below describe an
-> unattended work loop, intended to run on **WSL** (an isolated environment where the AI can be given
-> full permissions).
+> unattended work loop (ADR-0152 + **ADR-0319**), intended to run on **WSL** (an isolated environment
+> where the AI can be given full permissions). Under ADR-0319 the cycle runs **through the 4PM cli**,
+> not a raw `claude -p`.
 
 ## The pieces
 | File | Role |
 |------|------|
-| `.claude/hooks/autonomous-tick.sh` | Cron tick (every ~10 min); a lock so **busy ⇒ skip, idle ⇒ run**; calls `claude -p /auto-cycle`. |
-| `.claude/commands/auto-cycle.md` | Defines **one cycle**: token gate → sync `${ai_dev_branch}$` → generate tasks → do one task → test → merge into `${ai_dev_branch}$`. |
-| `.claude/skills/check-usage/check_usage.py` | The `check-usage` skill: prints token % and writes `output/last-usage-check.json` (deleted + recreated each run) for the token gate to read. |
-| `.claude/.autonomous.approvals.json` | Approval source of truth (ADR-0152): `{ "<TSK-id>": {approved, by, at} }` — the web VERIFY tab writes it; `/auto-cycle` reads it. |
-| `USER_TODO.md` | The user writes requests here; the cycle reads then clears it. |
+| `.claude/hooks/autonomous-tick.sh` | Cron tick (every ~5–10 min): a run lock + the CHEAP local gates (pause / quiet-hours / max-ticks / **has-work**), then runs **`4pm auto-run`**. No token spend when there's no approved work. |
+| `4pm auto-run` (cli) | Asks the running **`4pm start`** daemon to run **one** cycle over the control socket; the cycle rides the daemon's live WS session (failover ADR-0182, metering ADR-0072, folder-scope ADR-0181, timeout ADR-0243). |
+| cli `buildAutonomousCyclePrompt` | The cli-owned cycle instructions (was `.claude/commands/auto-cycle.md`, now retired): sync branch → analyse **approved** USER_TODO → fold **approved** USER_QA → do ONE approved task → **PR** into the base branch. |
+| `.claude/.autonomous.approvals.json` | Approval source of truth (ADR-0152): `{ "<REQ/QA/TSK-id>": {approved, by, at} }` — the web AI-content grids write it; the cycle reads it. |
+| `USER_TODO.md` / `USER_QA.md` | User requests / the AI's questions back — each row approved before the cycle acts on it (ADR-0319). |
 | `AI_TODO.md` / `AI_PROGRESS.md` / `AI_DONE.md` | The task books: queue → in progress → done (ID `TSK-{group:0000}-{task:0000}`). |
-| `.claude/templates/<NAME>.{empty,sample}.md` | Canonical templates for the 5 books. The "has work" gate + `/auto-cycle` **compare against `*.empty.md`** to tell empty/has-work and reset correctly (see `README.md` in that folder). |
+| `.claude/templates/<NAME>.{empty,sample}.md` | Canonical templates for the books. The has-work gate + the cycle **compare against `*.empty.md`** to tell empty/has-work and reset correctly. |
 | `.claude/settings.json` | The "bypass all" permission profile for autonomous mode (see the note below). |
 
 ## Lifecycle (1 tick)
 ```
-cron ~10min → autonomous-tick.sh
-  ├─ locked?  → log "skip", exit (wait for the next tick)
-  └─ idle → claude -p /auto-cycle
-       0. usage: session<80% & weekly<90%?  (no → stop)
-       1. checkout/fetch/pull the `${ai_dev_branch}$` branch
-       2. USER_TODO.md → generate tasks into AI_TODO.md (with IDs) → clear USER_TODO.md
-       3. pick one APPROVED task (approvals + dependencies) → AI_PROGRESS.md, remove from AI_TODO.md, commit
-       4. task/TSK-… branch → implement → commit → run the project's tests
-       5. back to `${ai_dev_branch}$` → merge task (resolve conflicts if any) → AI_DONE.md, remove from AI_PROGRESS.md, commit
-       6. report on the `conversation` branch (CONVERSATION.md, ≤50 entries) for later agents
-       7. recheck usage → stop
+cron ~5–10min → autonomous-tick.sh
+  ├─ locked? / paused? / quiet-hours? / max-ticks? → log "skip", exit
+  ├─ has-work? (approved USER_TODO/USER_QA/AI_TODO, or AI_PROGRESS non-empty) — no → skip (daemon NOT woken)
+  └─ 4pm auto-run → the running daemon runs ONE cycle:
+       1. sync the primary repo's current branch (base branch — ADR-0292)
+       2. analyse APPROVED USER_TODO requests → AI_TODO tasks (unclear ⇒ ask via USER_QA)
+       3. fold APPROVED USER_QA answers back into AI_TODO
+       4. take ONE approved task (deps met) → AI_PROGRESS, commit
+       5. implement + test on task/TSK-… branch
+       6. rebase + push + open a PULL REQUEST into the base branch (no direct merge)
+       7. update the books (AI_DONE), commit + push the base branch
+  └─ record success/failure (N consecutive failures → pause); the EXIT trap releases the lock
 ```
 
 ## Install on WSL
@@ -40,13 +42,11 @@ crontab -e
 # watch:
 tail -f .claude/logs/autonomous-tick-$(date +%F).log
 ```
-Requirements: `claude` logged in (has `~/.claude/.credentials.json`), plus `git` and `python3`, and the
-project's test tooling (per `CLAUDE.md`).
+Requirements: the **`4pm`** cli on PATH with a **running `4pm start` daemon** serving this project (it
+holds the AI credentials + WS session), plus `git`, `python3`, and `gh`/`glab` for the PR step.
 
 ## Note on permissions (important)
-- Claude Code only auto-loads `.claude/settings.json` and `.claude/settings.local.json`. To make a
-  full-permission profile take effect, one of:
-  1. The tick already passes `--permission-mode bypassPermissions --dangerously-skip-permissions` (in use).
-  2. Or copy the profile into `.claude/settings.local.json`.
-  3. Or point `CLAUDE_CONFIG_DIR` at the profile dir when running headless.
+- The daemon runs the cycle as a **write-capable agent** (`--permission-mode bypassPermissions`,
+  ADR-0271) so file + git/`gh`/`glab` writes run headless. It stays bounded by the folder-scope guard
+  (ADR-0181) + the AI-run timeout (ADR-0243).
 - Only enable full permissions in an isolated environment (WSL/CI). Never on a machine with sensitive data.