@4pm/cli 1.17.0 → 1.19.0

package/dist/index.js

@@ -2283,7 +2283,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash5 } = __require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash5 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2821,7 +2821,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes3(16).toString("base64");
+      const key = randomBytes4(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -28199,7 +28199,7 @@ import { createInterface } from "readline/promises";
 
 // src/core/credential.ts
 import {
-  chmodSync,
+  chmodSync as chmodSync2,
   existsSync as existsSync2,
   readFileSync as readFileSync2,
   rmSync as rmSync2,
@@ -28220,11 +28220,17 @@ import { homedir } from "os";
 import { join } from "path";
 
 // src/common/io/ensure-dir.ts
-import { mkdirSync } from "fs";
+import { chmodSync, mkdirSync } from "fs";
 var CLI_IMAGE = "ghcr.io/4azuo/4pm-cli:full";
-function ensureDir(dir2) {
+function ensureDir(dir2, mode) {
   try {
-    mkdirSync(dir2, { recursive: true });
+    mkdirSync(dir2, { recursive: true, ...mode !== void 0 ? { mode } : {} });
+    if (mode !== void 0) {
+      try {
+        chmodSync(dir2, mode);
+      } catch {
+      }
+    }
   } catch (err) {
     const code = err.code;
     if (code === "EACCES" || code === "EPERM") {
@@ -28255,7 +28261,7 @@ function defaultProfileName() {
   return DEFAULT_PROFILE;
 }
 function writeDefaultProfile(userId) {
-  ensureDir(join(homedir(), ".4pm"));
+  ensureDir(join(homedir(), ".4pm"), 448);
   writeFileSync(defaultPointerPath(), userId, "utf8");
 }
 function clearDefaultProfileIf(name) {
@@ -28292,7 +28298,7 @@ function listProfiles() {
 }
 function profileDir(name) {
   const dir2 = join(homedir(), ".4pm", "profiles", name);
-  ensureDir(dir2);
+  ensureDir(dir2, 448);
   return dir2;
 }
 function defaultProfileConfig() {
@@ -28417,7 +28423,7 @@ function readCredential(profileDir2, profileName) {
 function writeCredential(profileDir2, credential) {
   const path = credentialPath(profileDir2);
   writeFileSync2(path, JSON.stringify(credential, null, 2), "utf8");
-  chmodSync(path, 384);
+  chmodSync2(path, 384);
 }
 function deleteCredential(profileDir2) {
   rmSync2(credentialPath(profileDir2), { force: true });
@@ -28873,7 +28879,12 @@ 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.",
+  "autoRun.authFailed": "Control-channel authentication failed \u2014 the daemon rejected the token."
 };
 
 // src/i18n/messages/vi.json
@@ -29051,7 +29062,12 @@ 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.",
+  "autoRun.authFailed": "X\xE1c th\u1EF1c k\xEAnh \u0111i\u1EC1u khi\u1EC3n th\u1EA5t b\u1EA1i \u2014 daemon t\u1EEB ch\u1ED1i token."
 };
 
 // src/i18n/messages/ja.json
@@ -29229,7 +29245,12 @@ 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",
+  "autoRun.authFailed": "\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB\u30C1\u30E3\u30CD\u30EB\u306E\u8A8D\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F \u2014 \u30C7\u30FC\u30E2\u30F3\u304C\u30C8\u30FC\u30AF\u30F3\u3092\u62D2\u5426\u3057\u307E\u3057\u305F\u3002"
 };
 
 // src/i18n/messages/zh.json
@@ -29407,7 +29428,12 @@ 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",
+  "autoRun.authFailed": "\u63A7\u5236\u901A\u9053\u8BA4\u8BC1\u5931\u8D25 \u2014 \u5B88\u62A4\u8FDB\u7A0B\u62D2\u7EDD\u4E86\u4EE4\u724C\u3002"
 };
 
 // src/i18n/messages/index.ts
@@ -29494,7 +29520,7 @@ async function runLink(serverUrl, explicitProfile, token = null) {
 
 // src/commands/start.ts
 import { spawn as spawn10 } from "child_process";
-import { join as join32 } from "path";
+import { join as join36 } from "path";
 
 // src/core/update.ts
 import { execSync as execSync2 } from "child_process";
@@ -32706,8 +32732,8 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
 
 // src/core/ws-client.ts
 init_wrapper();
-import { randomUUID as randomUUID2 } from "crypto";
-import { basename as basename7, join as join28 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
+import { basename as basename7, join as join31 } from "path";
 import { existsSync as existsSync16, mkdirSync as mkdirSync7 } from "fs";
 
 // vendor/@4pm/utils/helpers.ts
@@ -37117,6 +37143,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({
@@ -39864,15 +39897,124 @@ function reportToolResult(tool, ok, message) {
 }
 
 // src/core/autonomous.ts
-import { readFile as readFile2, writeFile as writeFile2, chmod } from "fs/promises";
-import { readFileSync as readFileSync13 } from "fs";
+import { readFile as readFile4, writeFile as writeFile4, chmod } from "fs/promises";
+import { readFileSync as readFileSync14 } from "fs";
 import { execFile as execFile4, spawn as spawn5 } from "child_process";
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 import { promisify as promisify4 } from "util";
-var run4 = promisify4(execFile4);
-var SETTINGS_REL = ".claude/.autonomous.settings.json";
+
+// src/core/autonomous-config.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFileSync as readFileSync13 } from "fs";
+import { join as join15 } from "path";
+var DEFAULT_AUTONOMOUS_CONFIG = {
+  paused: true,
+  cronSchedule: "*/10 * * * *",
+  quietHours: "",
+  maxTicksPerDay: -1,
+  stopOnConsecutiveFailures: 3,
+  logRetentionDays: 14,
+  model: "",
+  maxSessionPct: 80,
+  maxWeeklyPct: 90
+};
+function autonomousConfigPath(profileDir2) {
+  return join15(profileDir2, "autonomous.config.json");
+}
+function coerce2(raw) {
+  const o = raw && typeof raw === "object" ? raw : {};
+  const d = DEFAULT_AUTONOMOUS_CONFIG;
+  const num = (v2, def) => typeof v2 === "number" && Number.isFinite(v2) ? v2 : def;
+  const str = (v2, def) => typeof v2 === "string" ? v2 : def;
+  return {
+    paused: typeof o.paused === "boolean" ? o.paused : d.paused,
+    cronSchedule: str(o.cronSchedule, d.cronSchedule),
+    quietHours: str(o.quietHours, d.quietHours),
+    maxTicksPerDay: num(o.maxTicksPerDay, d.maxTicksPerDay),
+    stopOnConsecutiveFailures: num(o.stopOnConsecutiveFailures, d.stopOnConsecutiveFailures),
+    logRetentionDays: num(o.logRetentionDays, d.logRetentionDays),
+    model: str(o.model, d.model),
+    maxSessionPct: num(o.maxSessionPct, d.maxSessionPct),
+    maxWeeklyPct: num(o.maxWeeklyPct, d.maxWeeklyPct)
+  };
+}
+async function readAutonomousConfig(profileDir2) {
+  try {
+    return coerce2(JSON.parse(await readFile2(autonomousConfigPath(profileDir2), "utf8")));
+  } catch {
+    return { ...DEFAULT_AUTONOMOUS_CONFIG };
+  }
+}
+function readAutonomousConfigSync(profileDir2) {
+  try {
+    return coerce2(JSON.parse(readFileSync13(autonomousConfigPath(profileDir2), "utf8")));
+  } catch {
+    return { ...DEFAULT_AUTONOMOUS_CONFIG };
+  }
+}
+async function readAutonomousConfigText(profileDir2) {
+  try {
+    return await readFile2(autonomousConfigPath(profileDir2), "utf8");
+  } catch {
+    return JSON.stringify(DEFAULT_AUTONOMOUS_CONFIG, null, 2) + "\n";
+  }
+}
+async function writeAutonomousConfig(profileDir2, raw) {
+  const cfg = coerce2(raw);
+  await writeFile2(autonomousConfigPath(profileDir2), JSON.stringify(cfg, null, 2) + "\n", "utf8");
+}
+function isInQuietHours(quietHours, now = /* @__PURE__ */ new Date()) {
+  const m2 = /^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/.exec(quietHours.trim());
+  if (!m2) return false;
+  const toMin = (h, mi2) => Number(h) * 60 + Number(mi2);
+  const start = toMin(m2[1], m2[2]);
+  const end = toMin(m2[3], m2[4]);
+  const cur = now.getHours() * 60 + now.getMinutes();
+  return start <= end ? cur >= start && cur < end : cur >= start || cur < end;
+}
+
+// src/core/autonomous-history.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join16 } from "path";
 var HISTORIES_REL = ".claude/.autonomous.histories.json";
+var MAX_RECORDS = 50;
+var SKELETON = { cronApplied: "", consecutiveFails: 0, ticks: { day: "", count: 0 }, records: [] };
+function historiesPath(root) {
+  return join16(root, HISTORIES_REL);
+}
+async function readHistories(root) {
+  try {
+    const d = JSON.parse(await readFile3(historiesPath(root), "utf8"));
+    const ticks = d.ticks ?? {};
+    return {
+      cronApplied: typeof d.cronApplied === "string" ? d.cronApplied : typeof d.cron_applied === "string" ? d.cron_applied : "",
+      consecutiveFails: typeof d.consecutiveFails === "number" ? d.consecutiveFails : typeof d.consecutive_fails === "number" ? d.consecutive_fails : 0,
+      ticks: { day: typeof ticks.day === "string" ? ticks.day : "", count: typeof ticks.count === "number" ? ticks.count : 0 },
+      records: Array.isArray(d.records) ? d.records : []
+    };
+  } catch {
+    return { ...SKELETON, ticks: { ...SKELETON.ticks }, records: [] };
+  }
+}
+async function writeHistories(root, h) {
+  try {
+    await writeFile3(historiesPath(root), JSON.stringify(h, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+function todayTickCount(h, today) {
+  return h.ticks.day === today ? h.ticks.count : 0;
+}
+function pushRecord(h, rec) {
+  h.records.push(rec);
+  if (h.records.length > MAX_RECORDS) h.records = h.records.slice(-MAX_RECORDS);
+  return h;
+}
+
+// src/core/autonomous.ts
+var run4 = promisify4(execFile4);
 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 = {
@@ -39882,10 +40024,9 @@ var BOOK_FILES = {
   aiDone: "AI_DONE.md",
   userQa: "USER_QA.md"
 };
-var DEFAULT_CRON = "*/10 * * * *";
 async function readText(path, fallback = "") {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile4(path, "utf8");
   } catch {
     return fallback;
   }
@@ -39901,8 +40042,37 @@ 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);
+  return join17(root, TICK_REL);
 }
 async function crontabList() {
   try {
@@ -39924,28 +40094,28 @@ async function cronInstalled(root) {
   const script = tickScript(root);
   return (await crontabList()).split("\n").some((l) => l.includes(script) && !l.trim().startsWith("#"));
 }
-async function getAutonomousStatus(root) {
-  const settings = parseJson(await readText(join15(root, SETTINGS_REL))) ?? {};
-  const hist = parseJson(await readText(join15(root, HISTORIES_REL))) ?? {};
-  const records = Array.isArray(hist.records) ? hist.records : [];
-  const last = records[records.length - 1];
-  const ticks = hist.ticks ?? {};
+async function getAutonomousStatus(root, profileDir2) {
+  const [cfg, hist, installed] = await Promise.all([
+    readAutonomousConfig(profileDir2),
+    readHistories(root),
+    cronInstalled(root)
+  ]);
+  const last = hist.records[hist.records.length - 1];
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   return {
-    installed: await cronInstalled(root),
-    paused: settings.paused === true,
-    cronSchedule: typeof settings.cron_schedule === "string" ? settings.cron_schedule : DEFAULT_CRON,
-    lastTickAt: last && typeof last.ts === "string" ? last.ts : null,
-    lastResult: last && typeof last.status === "string" ? last.status : null,
-    consecutiveFails: typeof hist.consecutive_fails === "number" ? hist.consecutive_fails : 0,
-    todayTicks: ticks.day === today && typeof ticks.count === "number" ? ticks.count : 0
+    installed,
+    paused: cfg.paused,
+    cronSchedule: cfg.cronSchedule,
+    lastTickAt: last?.ts ?? null,
+    lastResult: last?.status ?? null,
+    consecutiveFails: hist.consecutiveFails,
+    todayTicks: hist.ticks.day === today ? hist.ticks.count : 0
   };
 }
-function isAutonomousRunning(root) {
+function isAutonomousRunning(root, profileDir2) {
   try {
-    const s3 = JSON.parse(readFileSync13(join15(root, SETTINGS_REL), "utf8"));
-    if (s3.paused === true) return false;
-    const h = JSON.parse(readFileSync13(join15(root, HISTORIES_REL), "utf8"));
+    if (readAutonomousConfigSync(profileDir2).paused) return false;
+    const h = JSON.parse(readFileSync14(join17(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"));
@@ -39954,32 +40124,36 @@ function isAutonomousRunning(root) {
     return false;
   }
 }
-async function readAutonomous(root) {
-  const [settings, approvals, status, ...books] = await Promise.all([
-    readText(join15(root, SETTINGS_REL)),
-    readText(join15(root, APPROVALS_REL), "{}"),
-    getAutonomousStatus(root),
-    ...Object.values(BOOK_FILES).map((f2) => readText(join15(root, f2)))
+async function readAutonomous(root, profileDir2) {
+  const [settings, approvals, authors, status, ...books] = await Promise.all([
+    readAutonomousConfigText(profileDir2),
+    readText(join17(root, APPROVALS_REL), "{}"),
+    readText(join17(root, AUTHORS_REL), "{}"),
+    getAutonomousStatus(root, profileDir2),
+    ...Object.values(BOOK_FILES).map((f2) => readText(join17(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);
-  const text = await readText(join15(root, LOG_DIR_REL, `autonomous-tick-${day}.log`));
+  const text = await readText(join17(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 };
 }
-async function installCron(root) {
+async function installCron(root, profileDir2) {
   const script = tickScript(root);
-  const status = await getAutonomousStatus(root);
+  const cfg = await readAutonomousConfig(profileDir2);
   await chmod(script, 493).catch(() => void 0);
   const kept = (await crontabList()).split("\n").filter((l) => l.trim() && !l.includes(script));
-  kept.push(`${status.cronSchedule} ${script}`);
+  kept.push(`${cfg.cronSchedule} ${script}`);
   await crontabSet(kept.join("\n"));
 }
+async function syncCron(root, profileDir2) {
+  if (await cronInstalled(root)) await installCron(root, profileDir2);
+}
 async function uninstallCron(root) {
   const script = tickScript(root);
   const cur = await crontabList();
@@ -39987,51 +40161,84 @@ async function uninstallCron(root) {
   const kept = cur.split("\n").filter((l) => l.trim() && !l.includes(script));
   await crontabSet(kept.join("\n"));
 }
-async function writeAutonomous(root, req, by) {
+async function writeAutonomous(root, profileDir2, req, by) {
   try {
     switch (req.kind) {
       case "settings": {
-        if (!parseJson(req.settings)) return { ok: false, error: "settings is not valid JSON" };
-        await writeFile2(join15(root, SETTINGS_REL), req.settings, "utf8");
+        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": {
-        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 && !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 writeFile2(join15(root, APPROVALS_REL), JSON.stringify(map, null, 2) + "\n", "utf8");
+        await writeFile4(join17(root, APPROVALS_REL), JSON.stringify(map, null, 2) + "\n", "utf8");
         break;
       }
       case "approvalsBatch": {
-        const map = parseJson(await readText(join15(root, APPROVALS_REL), "{}")) ?? {};
+        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();
-        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");
+        await writeFile4(join17(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 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 writeFile2(join15(root, BOOK_FILES.userTodo), cur.replace(/\s*$/, "\n") + row, "utf8");
+        await writeFile4(join17(root, BOOK_FILES.userTodo), cur.replace(/\s*$/, "\n") + row, "utf8");
+        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;
+        for (const [id, cells] of next) {
+          if (prev.get(id) !== cells) authors[id] = { by, byLabel, at: at2 };
+        }
+        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);
+        if (req.action === "install") await installCron(root, profileDir2);
         else await uninstallCron(root);
         break;
       }
     }
-    return { ok: true, status: await getAutonomousStatus(root) };
+    return { ok: true, status: await getAutonomousStatus(root, profileDir2) };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
 
 // src/core/network-probe.ts
-import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync15 } from "fs";
 import { connect } from "net";
 var CANARY_TARGETS = [
   { host: "1.1.1.1", port: 443 },
@@ -40041,7 +40248,7 @@ var PROBE_TIMEOUT_MS = 2500;
 function detectContainerized() {
   try {
     if (existsSync11("/.dockerenv")) return true;
-    const cgroup = readFileSync14("/proc/1/cgroup", "utf8");
+    const cgroup = readFileSync15("/proc/1/cgroup", "utf8");
     return /docker|containerd|kubepods|libpod/.test(cgroup);
   } catch {
     return false;
@@ -40075,7 +40282,7 @@ function probeInbound() {
   const isExposed = (path, loopbackHexPrefixes) => {
     let body;
     try {
-      body = readFileSync14(path, "utf8");
+      body = readFileSync15(path, "utf8");
     } catch {
       return false;
     }
@@ -40110,7 +40317,7 @@ async function probeNetwork() {
 // src/core/git-auth.ts
 import { writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 function tokenTarget(method) {
   if (method === "gitlab-group-token") {
     return { host: process.env.FOURPM_GIT_HOST || "gitlab.com", user: "oauth2" };
@@ -40128,7 +40335,7 @@ function applyGitAuth(method) {
   try {
     const line = `https://${target.user}:${token}@${target.host}
 `;
-    writeFileSync8(join16(homedir4(), ".git-credentials"), line, { encoding: "utf8", mode: 384 });
+    writeFileSync8(join18(homedir4(), ".git-credentials"), line, { encoding: "utf8", mode: 384 });
     return true;
   } catch {
     return false;
@@ -40366,7 +40573,7 @@ function formatTimestampInZone(date, timeZone) {
 
 // src/ui/slash-commands.ts
 import { existsSync as existsSync12 } from "fs";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 var CONFIG_KEYS = [
   "aiCli",
   "claudeHome",
@@ -40378,7 +40585,7 @@ var CONFIG_KEYS = [
   "aiEnv"
 ];
 function configPath(profileDir2) {
-  return join17(profileDir2, "config.json");
+  return join19(profileDir2, "config.json");
 }
 function parseConfigAssignment(key, valueTokens) {
   const value = valueTokens.join(" ").trim();
@@ -40513,7 +40720,7 @@ function runOutput(ctx) {
 }
 function runLogs(ctx) {
   const n = Math.max(1, Math.min(200, Number(ctx.args[0]) || 20));
-  const dir2 = join17(ctx.info.profileDir, "logs");
+  const dir2 = join19(ctx.info.profileDir, "logs");
   const lines = readRecentLogLines(dir2, n);
   if (lines.length === 0) {
     ctx.print(t("slash.logs.none"));
@@ -41351,8 +41558,251 @@ function rejectByReview(ctx, commandId, origin, prompt, reasons) {
   });
 }
 
+// src/core/autonomous-cycle.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile5, readdir as readdir2, rm as rm2, stat } from "fs/promises";
+import { join as join20 } from "path";
+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 4PM cli serializes cycles (one at a time); you do NOT manage any run lock.`;
+}
+var running = /* @__PURE__ */ new Set();
+async function runAutonomousCycle(ctx) {
+  const root = ctx.physicRoot;
+  const profileDir2 = ctx.profileDir;
+  if (!root) {
+    ctx.bus.autonomousDone(false, "no served project");
+    return;
+  }
+  if (running.has(root)) {
+    ctx.bus.autonomousDone(false, "a cycle is already running");
+    return;
+  }
+  running.add(root);
+  const log = (line) => dayLog(root, line);
+  try {
+    const cfg = await readAutonomousConfig(profileDir2);
+    await pruneLogs(root, cfg.logRetentionDays);
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    if (!ctx.isReady) {
+      await log("[skip] cli offline (no WS connection)");
+      ctx.bus.autonomousDone(false, "cli offline");
+      return;
+    }
+    if (cfg.paused) {
+      await log("[skip] paused");
+      ctx.bus.autonomousDone(false, "paused");
+      return;
+    }
+    if (isInQuietHours(cfg.quietHours)) {
+      await log("[skip] within quiet hours");
+      ctx.bus.autonomousDone(false, "quiet hours");
+      return;
+    }
+    let hist = await readHistories(root);
+    if (cfg.maxTicksPerDay > 0 && todayTickCount(hist, today) >= cfg.maxTicksPerDay) {
+      await log(`[skip] reached max ticks/day (${cfg.maxTicksPerDay})`);
+      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");
+      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 recordRun(root, hist, "skip", "all AI profiles over usage limit", today);
+      ctx.bus.autonomousDone(false, "usage limit");
+      return;
+    }
+    hist.ticks = { day: today, count: todayTickCount(hist, today) + 1 };
+    await writeHistories(root, hist);
+    await log(`[run] cycle (tick ${hist.ticks.count}/${today})`);
+    const commandId = randomUUID2();
+    const override = cfg.model ? { model: cfg.model } : void 0;
+    try {
+      await runAiPrompt(ctx, buildAutonomousCyclePrompt(), commandId, "local", false, void 0, override, false, true);
+      hist = await readHistories(root);
+      hist.consecutiveFails = 0;
+      await recordRun(root, hist, "success", "cycle complete", today);
+      await log("[done] cycle complete");
+      ctx.bus.autonomousDone(true);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      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);
+    }
+  } catch (err) {
+    ctx.bus.autonomousDone(false, err instanceof Error ? err.message : String(err));
+  } finally {
+    running.delete(root);
+  }
+}
+async function dayLog(root, line) {
+  try {
+    const dir2 = join20(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(join20(dir2, `autonomous-tick-${day}.log`), `${ts2} ${line}
+`, "utf8");
+  } catch {
+  }
+}
+async function pruneLogs(root, retentionDays) {
+  if (!(retentionDays > 0)) return;
+  try {
+    const dir2 = join20(root, ".claude", "logs");
+    const cutoff = Date.now() - retentionDays * 864e5;
+    for (const f2 of await readdir2(dir2)) {
+      if (!/^autonomous-tick-.*\.log$/.test(f2)) continue;
+      const st2 = await stat(join20(dir2, f2)).catch(() => null);
+      if (st2 && st2.mtimeMs < cutoff) await rm2(join20(dir2, f2), { force: true }).catch(() => void 0);
+    }
+  } catch {
+  }
+}
+async function recordRun(root, hist, status, note, today) {
+  const ts2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+  pushRecord(hist, { ts: ts2, status, note, tick: `${today} #${hist.ticks.count}` });
+  await writeHistories(root, hist);
+}
+async function readJsonObject(path) {
+  try {
+    return JSON.parse(await readFile5(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function hasWork(root) {
+  const approvals = await readJsonObject(join20(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) => readFile5(join20(root, f2), "utf8").catch(() => "");
+  const [userTodo, userQa, aiTodo, aiProgress] = await Promise.all([
+    read("USER_TODO.md"),
+    read("USER_QA.md"),
+    read("AI_TODO.md"),
+    read("AI_PROGRESS.md")
+  ]);
+  const anyApproved = (prefix, text) => approved.some((id) => id.startsWith(prefix) && text.includes(id));
+  return anyApproved("REQ-", userTodo) || anyApproved("QA-", userQa) || anyApproved("TSK-", aiTodo) || /TSK-\d{4}-\d{4}/.test(aiProgress);
+}
+function hasUsableCodex(config) {
+  const mixed = config.aiProfiles?.some(
+    (c) => c.provider === "codex" && c.enabled !== false && Boolean(c.profile?.trim())
+  );
+  const legacy = (config.codexHome ?? []).some((p2) => p2.enabled !== false && Boolean(p2.profile?.trim()));
+  return Boolean(mixed || legacy);
+}
+async function allAiProfilesExhausted(ctx, cfg) {
+  const config = readProfileConfig(ctx.profileDir);
+  const active = activeProvider(config);
+  if (active === "codex" || active === "antigravity") return false;
+  if (active === null && hasUsableCodex(config)) return false;
+  const dirs = claudeHomeDirs(config);
+  if (dirs.length === 0) return false;
+  const usages = await Promise.all(dirs.map((d) => checkClaudeUsage([d]).catch(() => null)));
+  let readAny = false;
+  for (const u2 of usages) {
+    if (!u2) continue;
+    readAny = true;
+    if (u2.session.utilizationPct < cfg.maxSessionPct && u2.weekly.utilizationPct < cfg.maxWeeklyPct) {
+      return false;
+    }
+  }
+  return readAny;
+}
+
 // src/core/fs-browse.ts
-import { readdir as readdir2 } from "fs/promises";
+import { readdir as readdir3 } from "fs/promises";
 import { resolve as resolve2, sep as sep2 } from "path";
 async function listDir(path, root) {
   if (!root) return { path: "", entries: [] };
@@ -41360,7 +41810,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 readdir2(target, { withFileTypes: true });
+    const dirents = await readdir3(target, { withFileTypes: true });
     const entries2 = dirents.map((d) => ({
       name: d.name,
       type: d.isDirectory() ? "dir" : "file"
@@ -41375,7 +41825,7 @@ async function listDir(path, root) {
 }
 
 // src/core/fs-read.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { resolve as resolve3, sep as sep3 } from "path";
 var MAX_BYTES = 256 * 1024;
 function resolveInRoot(root, relPath) {
@@ -41390,7 +41840,7 @@ async function readWorkerFile(root, path) {
     return { path, content: "", truncated: false };
   }
   try {
-    const buf = await readFile3(target);
+    const buf = await readFile6(target);
     const truncated = buf.byteLength > MAX_BYTES;
     const content = buf.subarray(0, MAX_BYTES).toString("utf8");
     return { path: target, content, truncated };
@@ -41400,7 +41850,7 @@ async function readWorkerFile(root, path) {
 }
 
 // src/core/fs-write.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
 import { dirname as dirname4, resolve as resolve4, sep as sep4 } from "path";
 var MAX_BYTES2 = 2 * 1024 * 1024;
 function resolveInRoot2(root, relPath) {
@@ -41419,8 +41869,8 @@ async function writeWorkerFile(root, relPath, content) {
     return { ok: false, path: target, bytes: 0, error: `content too large (max ${MAX_BYTES2} bytes)` };
   }
   try {
-    await mkdir3(dirname4(target), { recursive: true });
-    await writeFile3(target, content, "utf8");
+    await mkdir4(dirname4(target), { recursive: true });
+    await writeFile5(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) };
@@ -41428,7 +41878,7 @@ async function writeWorkerFile(root, relPath, content) {
 }
 
 // src/core/fs-mutate.ts
-import { mkdir as mkdir4, writeFile as writeFile4, rename, rm as rm2, stat } from "fs/promises";
+import { mkdir as mkdir5, writeFile as writeFile6, rename, rm as rm3, stat as stat2 } 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) {
@@ -41438,14 +41888,14 @@ function resolveInRoot3(root, rel) {
 }
 async function isDir(p2) {
   try {
-    return (await stat(p2)).isDirectory();
+    return (await stat2(p2)).isDirectory();
   } catch {
     return false;
   }
 }
 async function exists(p2) {
   try {
-    await stat(p2);
+    await stat2(p2);
     return true;
   } catch {
     return false;
@@ -41459,7 +41909,7 @@ async function mutateFs(root, req) {
       case "mkdir": {
         const target = resolveInRoot3(root, req.path ?? "");
         if (!target || target === resolve5(root)) return escaped(req.path ?? "");
-        await mkdir4(target, { recursive: true });
+        await mkdir5(target, { recursive: true });
         return { ok: true, path: target };
       }
       case "create": {
@@ -41470,8 +41920,8 @@ async function mutateFs(root, req) {
         if (Buffer.byteLength(content, "utf8") > MAX_BYTES3) {
           return { ok: false, path: target, error: `content too large (max ${MAX_BYTES3} bytes)` };
         }
-        await mkdir4(dirname5(target), { recursive: true });
-        await writeFile4(target, content, "utf8");
+        await mkdir5(dirname5(target), { recursive: true });
+        await writeFile6(target, content, "utf8");
         return { ok: true, path: target };
       }
       case "move": {
@@ -41482,7 +41932,7 @@ async function mutateFs(root, req) {
         if (await isDir(to2)) to2 = resolve5(to2, basename3(from));
         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 mkdir5(dirname5(to2), { recursive: true });
         await rename(from, to2);
         return { ok: true, path: to2 };
       }
@@ -41490,7 +41940,7 @@ async function mutateFs(root, req) {
         const target = resolveInRoot3(root, req.path ?? "");
         if (!target) return escaped(req.path ?? "");
         if (target === resolve5(root)) return { ok: false, path: target, error: "cannot delete the project root" };
-        await rm2(target, { recursive: true, force: true });
+        await rm3(target, { recursive: true, force: true });
         return { ok: true, path: target };
       }
       default:
@@ -41502,7 +41952,7 @@ async function mutateFs(root, req) {
 }
 
 // src/core/fs-transfer.ts
-import { mkdir as mkdir5, readFile as readFile4, stat as stat2, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile7, stat as stat3, writeFile as writeFile7 } from "fs/promises";
 import { basename as basename4, dirname as dirname6, extname, resolve as resolve6, sep as sep6 } from "path";
 function resolveInRoot4(root, relPath) {
   if (!root) return null;
@@ -41546,8 +41996,8 @@ async function uploadBinaryFile(root, relPath, contentBase64) {
     return { ok: false, path: target, bytes: 0, error: `file too large (max ${FS_TRANSFER_MAX_BYTES} bytes)` };
   }
   try {
-    await mkdir5(dirname6(target), { recursive: true });
-    await writeFile5(target, buf);
+    await mkdir6(dirname6(target), { recursive: true });
+    await writeFile7(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) };
@@ -41557,12 +42007,12 @@ async function downloadBinaryFile(root, relPath) {
   const target = resolveInRoot4(root, relPath);
   if (!target) return { error: "path escapes the project root" };
   try {
-    const info = await stat2(target);
+    const info = await stat3(target);
     if (!info.isFile()) return { error: "not a file" };
     if (info.size > FS_TRANSFER_MAX_BYTES) {
       return { error: `file too large (max ${FS_TRANSFER_MAX_BYTES} bytes)` };
     }
-    const buf = await readFile4(target);
+    const buf = await readFile7(target);
     return {
       contentBase64: buf.toString("base64"),
       contentType: guessMime(target),
@@ -41621,7 +42071,7 @@ function handleFsChannels(ctx, message, payload) {
 }
 
 // src/core/git-diff.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { execFile as execFile6 } from "child_process";
 import { basename as basename5, dirname as dirname7, resolve as resolve7, sep as sep7 } from "path";
 import { promisify as promisify6 } from "util";
@@ -41648,7 +42098,7 @@ async function gitDiff(root, path) {
   const base = basename5(target);
   let newBuf = null;
   try {
-    newBuf = await readFile5(target);
+    newBuf = await readFile8(target);
   } catch {
   }
   let oldBuf = null;
@@ -41715,18 +42165,18 @@ ${stderr}`;
 
 // src/core/git-ssh-key.ts
 import { execFile as execFile8 } from "child_process";
-import { readFile as readFile6, rm as rm3, mkdir as mkdir6 } from "fs/promises";
-import { join as join18 } from "path";
+import { readFile as readFile9, rm as rm4, mkdir as mkdir7 } from "fs/promises";
+import { join as join21 } from "path";
 import { promisify as promisify8 } from "util";
 var run8 = promisify8(execFile8);
 function keyPaths(profileDir2) {
-  const dir2 = join18(profileDir2, ".ssh");
-  const key = join18(dir2, "id_4pm");
+  const dir2 = join21(profileDir2, ".ssh");
+  const key = join21(dir2, "id_4pm");
   return { dir: dir2, key, pub: `${key}.pub` };
 }
 async function readPublicKey(pub) {
   try {
-    return (await readFile6(pub, "utf8")).trim();
+    return (await readFile9(pub, "utf8")).trim();
   } catch {
     return null;
   }
@@ -41748,9 +42198,9 @@ async function configureGit(key) {
 }
 async function generate(profileDir2) {
   const { dir: dir2, key, pub } = keyPaths(profileDir2);
-  await mkdir6(dir2, { recursive: true });
-  await rm3(key, { force: true });
-  await rm3(pub, { force: true });
+  await mkdir7(dir2, { recursive: true });
+  await rm4(key, { force: true });
+  await rm4(pub, { force: true });
   await run8("ssh-keygen", ["-t", "ed25519", "-f", key, "-N", "", "-C", "4pm-deploy-key"], {
     timeout: 15e3
   });
@@ -41759,8 +42209,8 @@ async function generate(profileDir2) {
 }
 async function remove(profileDir2) {
   const { key, pub } = keyPaths(profileDir2);
-  await rm3(key, { force: true });
-  await rm3(pub, { force: true });
+  await rm4(key, { force: true });
+  await rm4(pub, { force: true });
   await run8("git", ["config", "--global", "--unset", "core.sshCommand"], { timeout: 5e3 }).catch(
     () => void 0
   );
@@ -41934,7 +42384,7 @@ function handleGitChannels(ctx, message, payload) {
 }
 
 // src/core/ws-client/handlers/misc.ts
-import { join as join19 } from "path";
+import { join as join22 } from "path";
 
 // src/core/outbound-review.ts
 function compilePatterns(sources, fallback) {
@@ -42016,7 +42466,7 @@ function handleMiscChannels(ctx, message, payload) {
     }
     case WsChannels.LOG_READ: {
       const limit = Math.min(Math.max(payload.limit ?? 200, 1), 2e3);
-      const lines = readRecentLogLines(join19(ctx.profileDir, "logs"), limit);
+      const lines = readRecentLogLines(join22(ctx.profileDir, "logs"), limit);
       ctx.send(WsChannels.LOG_READ, { lines }, message.id);
       return true;
     }
@@ -42048,14 +42498,14 @@ function handleMiscChannels(ctx, message, payload) {
 
 // src/core/ws-client/handlers/project.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync6, renameSync, rmSync as rmSync6 } from "fs";
-import { join as join20 } from "path";
+import { join as join23 } from "path";
 function handleProjectChannels(ctx, message, payload) {
   switch (message.channel) {
     case WsChannels.PHYSIC_SYNC: {
       const sync = payload;
       const oldName = sync.oldName;
-      const oldPath = oldName ? join20(ctx.profileDir, oldName) : null;
-      const newPath = join20(ctx.profileDir, sync.newName);
+      const oldPath = oldName ? join23(ctx.profileDir, oldName) : null;
+      const newPath = join23(ctx.profileDir, sync.newName);
       if (oldName) {
         const oldRoot = ctx.physicFolderPath(oldName);
         if (oldRoot) void uninstallCron(oldRoot).catch(() => void 0);
@@ -42077,7 +42527,7 @@ function handleProjectChannels(ctx, message, payload) {
       if (del.name) {
         const delRoot = ctx.physicFolderPath(del.name);
         if (delRoot) void uninstallCron(delRoot).catch(() => void 0);
-        rmSync6(join20(ctx.profileDir, del.name), { recursive: true, force: true });
+        rmSync6(join23(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);
@@ -42346,8 +42796,8 @@ function handleToolsChannels(ctx, message, payload) {
 }
 
 // src/core/agents.ts
-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";
+import { readFile as readFile10, writeFile as writeFile8, mkdir as mkdir8, readdir as readdir4, rm as rm5 } from "fs/promises";
+import { join as join24 } from "path";
 var AGENTS_REL = ".claude/agents";
 var SKILLS_REL = ".claude/skills";
 var MEMORY_DIRS = /* @__PURE__ */ new Set(["short-memory", "long-memory"]);
@@ -42356,7 +42806,7 @@ function safeName(name) {
 }
 async function readText2(path, fallback = "") {
   try {
-    return await readFile7(path, "utf8");
+    return await readFile10(path, "utf8");
   } catch {
     return fallback;
   }
@@ -42371,17 +42821,17 @@ async function listAgents(root) {
   const subagents = [];
   const skills = [];
   try {
-    for (const e of await readdir3(join21(root, AGENTS_REL), { withFileTypes: true })) {
+    for (const e of await readdir4(join24(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)));
+      const fm = frontmatter(await readText2(join24(root, AGENTS_REL, e.name)));
       subagents.push({ name: e.name.replace(/\.md$/, ""), description: fm.description });
     }
   } catch {
   }
   try {
-    for (const e of await readdir3(join21(root, SKILLS_REL), { withFileTypes: true })) {
+    for (const e of await readdir4(join24(root, SKILLS_REL), { withFileTypes: true })) {
       if (!e.isDirectory()) continue;
-      const fm = frontmatter(await readText2(join21(root, SKILLS_REL, e.name, "SKILL.md")));
+      const fm = frontmatter(await readText2(join24(root, SKILLS_REL, e.name, "SKILL.md")));
       skills.push({ name: e.name, description: fm.description });
     }
   } catch {
@@ -42392,15 +42842,15 @@ async function listAgents(root) {
 }
 function itemPath(root, kind, name) {
   const n = safeName(name);
-  return kind === "subagent" ? join21(root, AGENTS_REL, `${n}.md`) : join21(root, SKILLS_REL, n, "SKILL.md");
+  return kind === "subagent" ? join24(root, AGENTS_REL, `${n}.md`) : join24(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(join21(root, AGENTS_REL, "short-memory", `${n}.md`)),
-    readText2(join21(root, AGENTS_REL, "long-memory", `${n}.md`))
+    readText2(join24(root, AGENTS_REL, "short-memory", `${n}.md`)),
+    readText2(join24(root, AGENTS_REL, "long-memory", `${n}.md`))
   ]);
   return { content, memory: { short, long } };
 }
@@ -42409,14 +42859,14 @@ async function writeAgent(root, req) {
   if (!n) return { ok: false, error: "invalid name" };
   try {
     if (req.action === "delete") {
-      if (req.kind === "subagent") await rm4(itemPath(root, "subagent", n), { force: true });
-      else await rm4(join21(root, SKILLS_REL, n), { recursive: true, force: true });
+      if (req.kind === "subagent") await rm5(itemPath(root, "subagent", n), { force: true });
+      else await rm5(join24(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 mkdir7(join21(path, ".."), { recursive: true });
-    await writeFile6(path, req.content, "utf8");
+    await mkdir8(join24(path, ".."), { recursive: true });
+    await writeFile8(path, req.content, "utf8");
     return { ok: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
@@ -42424,21 +42874,21 @@ async function writeAgent(root, req) {
 }
 
 // src/core/secrets.ts
-import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
-import { join as join22 } from "path";
+import { readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
+import { join as join25 } 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 readFile8(path, "utf8");
+    return await readFile11(path, "utf8");
   } catch {
     return fallback;
   }
 }
 async function readSecretsObject(root) {
   try {
-    const v2 = JSON.parse(await readFile8(join22(root, SECRETS_REL), "utf8"));
+    const v2 = JSON.parse(await readFile11(join25(root, SECRETS_REL), "utf8"));
     return v2 && typeof v2 === "object" ? v2 : {};
   } catch {
     return {};
@@ -42457,8 +42907,8 @@ function placeholderKeys(text) {
 }
 async function readSecrets(root) {
   const [security, placeholder, secrets] = await Promise.all([
-    readText3(join22(root, SECURITY_REL)),
-    readText3(join22(root, PLACEHOLDER_REL)),
+    readText3(join25(root, SECURITY_REL)),
+    readText3(join25(root, PLACEHOLDER_REL)),
     readSecretsObject(root)
   ]);
   const names = /* @__PURE__ */ new Set([...placeholderKeys(placeholder), ...Object.keys(secrets)]);
@@ -42471,14 +42921,14 @@ async function readSecrets(root) {
 async function writeSecrets(root, req) {
   try {
     if (req.kind === "security") {
-      await writeFile7(join22(root, SECURITY_REL), req.content, "utf8");
+      await writeFile9(join25(root, SECURITY_REL), req.content, "utf8");
     } else if (req.kind === "placeholder") {
-      await writeFile7(join22(root, PLACEHOLDER_REL), req.content, "utf8");
+      await writeFile9(join25(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 writeFile7(join22(root, SECRETS_REL), JSON.stringify(secrets, null, 2) + "\n", "utf8");
+      await writeFile9(join25(root, SECRETS_REL), JSON.stringify(secrets, null, 2) + "\n", "utf8");
     }
     return { ok: true };
   } catch (err) {
@@ -42487,18 +42937,18 @@ async function writeSecrets(root, req) {
 }
 
 // src/core/agent-tools.ts
-import { readFile as readFile9, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
-import { dirname as dirname8, join as join23 } from "path";
+import { readFile as readFile12, writeFile as writeFile10, mkdir as mkdir9 } from "fs/promises";
+import { dirname as dirname8, join as join26 } from "path";
 var SHARED_REL = ".claude/settings.json";
 var LOCAL_REL = ".claude/settings.local.json";
 var SECRETS_DENY = "Read(./project.secrets.json)";
 var MODES = ["default", "acceptEdits", "plan", "bypassPermissions"];
 function fileFor(root, scope) {
-  return join23(root, scope === "shared" ? SHARED_REL : LOCAL_REL);
+  return join26(root, scope === "shared" ? SHARED_REL : LOCAL_REL);
 }
 async function readSettingsObject(path) {
   try {
-    const v2 = JSON.parse(await readFile9(path, "utf8"));
+    const v2 = JSON.parse(await readFile12(path, "utf8"));
     return v2 && typeof v2 === "object" ? v2 : {};
   } catch {
     return {};
@@ -42521,8 +42971,8 @@ async function writeAgentTools(root, scope, permissions) {
     const next = normalizePermissions(permissions);
     if (scope === "shared" && !next.deny.includes(SECRETS_DENY)) next.deny = [...next.deny, SECRETS_DENY];
     obj.permissions = next;
-    await mkdir8(dirname8(path), { recursive: true });
-    await writeFile8(path, JSON.stringify(obj, null, 2) + "\n", "utf8");
+    await mkdir9(dirname8(path), { recursive: true });
+    await writeFile10(path, JSON.stringify(obj, null, 2) + "\n", "utf8");
     return { ok: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
@@ -42531,8 +42981,8 @@ 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 readdir4, rm as rm5, stat as stat3 } from "fs/promises";
-import { dirname as dirname9, join as join24, relative } from "path";
+import { readFile as readFile13, writeFile as writeFile11, mkdir as mkdir10, readdir as readdir5, rm as rm6, stat as stat4 } from "fs/promises";
+import { dirname as dirname9, join as join27, relative } from "path";
 var AGENTS_REL2 = ".claude/agents";
 var SKILLS_REL2 = ".claude/skills";
 var MANIFEST_REL = ".claude/.4pm-packages.json";
@@ -42541,7 +42991,7 @@ function safeName2(name) {
 }
 async function readMaybe(path) {
   try {
-    return await readFile10(path);
+    return await readFile13(path);
   } catch {
     return null;
   }
@@ -42551,12 +43001,12 @@ async function listFilesRel(dir2) {
   async function walk2(d) {
     let entries2;
     try {
-      entries2 = await readdir4(d, { withFileTypes: true });
+      entries2 = await readdir5(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries2) {
-      const full = join24(d, e.name);
+      const full = join27(d, e.name);
       if (e.isDirectory()) await walk2(full);
       else if (e.isFile()) out.push(relative(dir2, full));
     }
@@ -42567,16 +43017,16 @@ async function listFilesRel(dir2) {
 async function readArtifactFiles(root, kind, slug) {
   const files = [];
   if (kind === "subagent") {
-    const agent = await readMaybe(join24(root, AGENTS_REL2, `${slug}.md`));
+    const agent = await readMaybe(join27(root, AGENTS_REL2, `${slug}.md`));
     if (agent) files.push({ path: "agent.md", contentBase64: agent.toString("base64") });
-    const short = await readMaybe(join24(root, AGENTS_REL2, "short-memory", `${slug}.md`));
+    const short = await readMaybe(join27(root, AGENTS_REL2, "short-memory", `${slug}.md`));
     if (short) files.push({ path: "short-memory.md", contentBase64: short.toString("base64") });
-    const long = await readMaybe(join24(root, AGENTS_REL2, "long-memory", `${slug}.md`));
+    const long = await readMaybe(join27(root, AGENTS_REL2, "long-memory", `${slug}.md`));
     if (long) files.push({ path: "long-memory.md", contentBase64: long.toString("base64") });
   } else {
-    const base = join24(root, SKILLS_REL2, slug);
+    const base = join27(root, SKILLS_REL2, slug);
     for (const rel of await listFilesRel(base)) {
-      const buf = await readMaybe(join24(base, rel));
+      const buf = await readMaybe(join27(base, rel));
       if (buf) files.push({ path: rel.split("\\").join("/"), contentBase64: buf.toString("base64") });
     }
   }
@@ -42594,16 +43044,16 @@ async function artifactSha256(root, kind, slug) {
   return h.digest("hex");
 }
 async function artifactExists(root, kind, slug) {
-  const target = kind === "subagent" ? join24(root, AGENTS_REL2, `${slug}.md`) : join24(root, SKILLS_REL2, slug);
+  const target = kind === "subagent" ? join27(root, AGENTS_REL2, `${slug}.md`) : join27(root, SKILLS_REL2, slug);
   try {
-    await stat3(target);
+    await stat4(target);
     return true;
   } catch {
     return false;
   }
 }
 async function readManifest(root) {
-  const buf = await readMaybe(join24(root, MANIFEST_REL));
+  const buf = await readMaybe(join27(root, MANIFEST_REL));
   if (!buf) return {};
   try {
     return JSON.parse(buf.toString("utf8"));
@@ -42612,35 +43062,35 @@ async function readManifest(root) {
   }
 }
 async function writeManifest(root, manifest) {
-  const path = join24(root, MANIFEST_REL);
-  await mkdir9(dirname9(path), { recursive: true });
-  await writeFile9(path, JSON.stringify(manifest, null, 2), "utf8");
+  const path = join27(root, MANIFEST_REL);
+  await mkdir10(dirname9(path), { recursive: true });
+  await writeFile11(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 mkdir9(join24(root, AGENTS_REL2), { recursive: true });
-      await writeFile9(join24(root, AGENTS_REL2, `${slug}.md`), agent);
+      await mkdir10(join27(root, AGENTS_REL2), { recursive: true });
+      await writeFile11(join27(root, AGENTS_REL2, `${slug}.md`), agent);
     }
     const short = byPath.get("short-memory.md");
     if (short) {
-      await mkdir9(join24(root, AGENTS_REL2, "short-memory"), { recursive: true });
-      await writeFile9(join24(root, AGENTS_REL2, "short-memory", `${slug}.md`), short);
+      await mkdir10(join27(root, AGENTS_REL2, "short-memory"), { recursive: true });
+      await writeFile11(join27(root, AGENTS_REL2, "short-memory", `${slug}.md`), short);
     }
     const long = byPath.get("long-memory.md");
     if (long) {
-      await mkdir9(join24(root, AGENTS_REL2, "long-memory"), { recursive: true });
-      await writeFile9(join24(root, AGENTS_REL2, "long-memory", `${slug}.md`), long);
+      await mkdir10(join27(root, AGENTS_REL2, "long-memory"), { recursive: true });
+      await writeFile11(join27(root, AGENTS_REL2, "long-memory", `${slug}.md`), long);
     }
   } else {
-    const base = join24(root, SKILLS_REL2, slug);
+    const base = join27(root, SKILLS_REL2, slug);
     for (const [rel, buf] of byPath) {
       if (rel.includes("..") || rel.startsWith("/")) continue;
-      const dest = join24(base, rel);
-      await mkdir9(dirname9(dest), { recursive: true });
-      await writeFile9(dest, buf);
+      const dest = join27(base, rel);
+      await mkdir10(dirname9(dest), { recursive: true });
+      await writeFile11(dest, buf);
     }
   }
 }
@@ -42704,11 +43154,11 @@ async function removePackage(root, slug) {
     const entry = manifest[n];
     if (!entry) return { ok: false, error: "not installed" };
     if (entry.kind === "subagent") {
-      await rm5(join24(root, AGENTS_REL2, `${n}.md`), { force: true });
-      await rm5(join24(root, AGENTS_REL2, "short-memory", `${n}.md`), { force: true });
-      await rm5(join24(root, AGENTS_REL2, "long-memory", `${n}.md`), { force: true });
+      await rm6(join27(root, AGENTS_REL2, `${n}.md`), { force: true });
+      await rm6(join27(root, AGENTS_REL2, "short-memory", `${n}.md`), { force: true });
+      await rm6(join27(root, AGENTS_REL2, "long-memory", `${n}.md`), { force: true });
     } else {
-      await rm5(join24(root, SKILLS_REL2, n), { recursive: true, force: true });
+      await rm6(join27(root, SKILLS_REL2, n), { recursive: true, force: true });
     }
     delete manifest[n];
     await writeManifest(root, manifest);
@@ -42719,8 +43169,8 @@ async function removePackage(root, slug) {
 }
 
 // src/core/graph.ts
-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";
+import { readFile as readFile14, readdir as readdir6 } from "fs/promises";
+import { join as join28, 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;
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "out", "coverage", ".turbo"]);
@@ -42732,7 +43182,7 @@ async function walk(root, accept) {
     const dir2 = stack.pop();
     let entries2;
     try {
-      entries2 = await readdir5(dir2, { withFileTypes: true });
+      entries2 = await readdir6(dir2, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -42740,7 +43190,7 @@ async function walk(root, accept) {
       if (e.name.startsWith(".") && e.name !== ".claude") {
         if (e.isDirectory()) continue;
       }
-      const full = join25(dir2, e.name);
+      const full = join28(dir2, e.name);
       if (e.isDirectory()) {
         if (!SKIP_DIRS.has(e.name)) stack.push(full);
       } else if (accept(full)) {
@@ -42768,7 +43218,7 @@ async function buildDocs(root) {
     const rel = relative2(root, f2).split("\\").join("/");
     let text = "";
     try {
-      text = await readFile11(f2, "utf8");
+      text = await readFile14(f2, "utf8");
     } catch {
       continue;
     }
@@ -42807,7 +43257,7 @@ async function buildCode(root) {
     const rel = relative2(root, f2).split("\\").join("/");
     let text = "";
     try {
-      text = await readFile11(f2, "utf8");
+      text = await readFile14(f2, "utf8");
     } catch {
       continue;
     }
@@ -42859,11 +43309,11 @@ async function buildGraph(root, mode) {
 }
 
 // src/core/rag.ts
-import { readFile as readFile12, writeFile as writeFile10, statfs as statfs2, mkdir as mkdir10 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile12, statfs as statfs2, mkdir as mkdir11 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
 import { execFile as execFile10, spawn as spawn9 } from "child_process";
 import { totalmem as totalmem2, cpus as cpus2 } from "os";
-import { join as join26 } from "path";
+import { join as join29 } from "path";
 import { promisify as promisify10 } from "util";
 var run10 = promisify10(execFile10);
 var RAG_REL = ".claude/rag";
@@ -42884,7 +43334,7 @@ async function detectPython() {
 }
 async function installLog(root) {
   try {
-    const text = await readFile12(join26(root, RAG_REL, "install.log"), "utf8");
+    const text = await readFile15(join29(root, RAG_REL, "install.log"), "utf8");
     return text.split("\n").filter((l) => l.length > 0).slice(-200);
   } catch {
     return [];
@@ -42946,14 +43396,14 @@ async function ragStatus(root) {
   };
   let modelName = "";
   try {
-    modelName = (await readFile12(join26(root, RAG_REL, ".installed"), "utf8")).trim();
+    modelName = (await readFile15(join29(root, RAG_REL, ".installed"), "utf8")).trim();
   } catch {
     modelName = "";
   }
   const modelPresent = modelName.length > 0;
   return {
     installed: fastembed && sqliteVec && modelPresent,
-    installing: existsSync14(join26(root, RAG_REL, ".installing")),
+    installing: existsSync14(join29(root, RAG_REL, ".installing")),
     python: { found: py.found, version: py.version },
     deps: { pip, fastembed, sqliteVec },
     model: { present: modelPresent, name: modelName },
@@ -42964,9 +43414,9 @@ async function ragStatus(root) {
   };
 }
 async function readIndexMeta(root) {
-  const indexing = existsSync14(join26(root, RAG_REL, ".indexing"));
+  const indexing = existsSync14(join29(root, RAG_REL, ".indexing"));
   try {
-    const m2 = JSON.parse(await readFile12(join26(root, RAG_REL, ".index.json"), "utf8"));
+    const m2 = JSON.parse(await readFile15(join29(root, RAG_REL, ".index.json"), "utf8"));
     return {
       present: true,
       indexing,
@@ -43033,14 +43483,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 mkdir10(join26(root, RAG_REL), { recursive: true }).catch(() => void 0);
-  await writeFile10(join26(root, RAG_REL, "rag_engine.py"), RAG_ENGINE_PY, "utf8");
+  await mkdir11(join29(root, RAG_REL), { recursive: true }).catch(() => void 0);
+  await writeFile12(join29(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 (!existsSync14(join26(root, RAG_REL, ".installed"))) return { ok: false, started: false, error: "RAG is not installed" };
-  if (existsSync14(join26(root, RAG_REL, ".indexing"))) return { ok: true, started: true };
+  if (!existsSync14(join29(root, RAG_REL, ".installed"))) return { ok: false, started: false, error: "RAG is not installed" };
+  if (existsSync14(join29(root, RAG_REL, ".indexing"))) return { ok: true, started: true };
   await ensureEngine(root);
   const script = `
 set +e
@@ -43060,12 +43510,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 (!existsSync14(join26(root, RAG_REL, "index.db"))) return { results: [], error: "no index \u2014 reindex first" };
+  if (!existsSync14(join29(root, RAG_REL, "index.db"))) return { results: [], error: "no index \u2014 reindex first" };
   await ensureEngine(root);
   try {
     const { stdout } = await run10(
       py.bin,
-      [join26(RAG_REL, "rag_engine.py"), "query", queryText, String(Math.min(Math.max(k2, 1), 20))],
+      [join29(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":[]}');
@@ -43080,9 +43530,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 (existsSync14(join26(root, RAG_REL, ".installing"))) return { ok: true, started: true };
+  if (existsSync14(join29(root, RAG_REL, ".installing"))) return { ok: true, started: true };
   try {
-    await mkdir10(join26(root, RAG_REL), { recursive: true });
+    await mkdir11(join29(root, RAG_REL), { recursive: true });
   } catch {
   }
   const script = `
@@ -43109,8 +43559,8 @@ rm -f "${RAG_REL}/.installing"
 }
 
 // src/core/config-sync.ts
-import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync16 } from "fs";
+import { join as join30 } from "path";
 var SERVER_MANAGED_KEYS = [
   "physicPath",
   "sessionSwitchPct",
@@ -43127,10 +43577,10 @@ var SERVER_MANAGED_KEYS = [
   "projectAiMemoryBudgetChars"
 ];
 function readConfigText(profileDir2) {
-  const path = join27(profileDir2, "config.json");
+  const path = join30(profileDir2, "config.json");
   if (existsSync15(path)) {
     try {
-      return readFileSync15(path, "utf8");
+      return readFileSync16(path, "utf8");
     } catch {
     }
   }
@@ -43161,7 +43611,7 @@ function handleWorkerChannels(ctx, message, payload) {
   switch (message.channel) {
     case WsChannels.AUTONOMOUS_READ:
       if (ctx.physicRoot) {
-        void readAutonomous(ctx.physicRoot).then(
+        void readAutonomous(ctx.physicRoot, ctx.profileDir).then(
           (reply) => ctx.send(WsChannels.AUTONOMOUS_READ, reply, message.id)
         );
       }
@@ -43178,7 +43628,7 @@ function handleWorkerChannels(ctx, message, payload) {
     case WsChannels.AUTONOMOUS_WRITE: {
       const req = payload;
       if (ctx.physicRoot) {
-        void writeAutonomous(ctx.physicRoot, req, req.by ?? "unknown").then(
+        void writeAutonomous(ctx.physicRoot, ctx.profileDir, req, req.by ?? "unknown").then(
           (reply) => ctx.send(WsChannels.AUTONOMOUS_WRITE, reply, message.id)
         );
       }
@@ -43367,6 +43817,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 +44367,7 @@ var WsClient = class {
     }
     const { payload, nonce } = encryptPayload(this.sessionKey, data);
     const envelope = {
-      id: randomUUID2(),
+      id: randomUUID3(),
       replyTo,
       channel,
       wsToken: this.wsToken,
@@ -43937,7 +44388,7 @@ var WsClient = class {
       }
       const { payload, nonce } = encryptPayload(this.sessionKey, data);
       const envelope = {
-        id: randomUUID2(),
+        id: randomUUID3(),
         replyTo: null,
         channel,
         wsToken: this.wsToken,
@@ -44019,7 +44470,7 @@ var WsClient = class {
    */
   physicFolderPath(projectName) {
     const safe = projectName.replace(/[/\\]/g, "_").replace(/\.\./g, "_").trim();
-    return safe ? join28(this.context.profileDir, safe) : null;
+    return safe ? join31(this.context.profileDir, safe) : null;
   }
   /**
    * Report machine.status: version + the state of the physic project being served
@@ -44036,7 +44487,7 @@ var WsClient = class {
       physicPath,
       physicPathExists: physicPath ? existsSync16(physicPath) : void 0,
       // Real coarse state (ADR-0152): !paused and a recent tick (was hard-coded false).
-      autonomousRunning: physicPath ? isAutonomousRunning(physicPath) : 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
       // effective timeout and derive the SSE reply windows server-side (ADR-0256).
       aiRunTimeoutSec: config.aiRunTimeoutSec ?? 0,
@@ -44128,7 +44579,7 @@ var WsClient = class {
    */
   uploadLog() {
     try {
-      const upload = readLogUpload(join28(this.context.profileDir, "logs"));
+      const upload = readLogUpload(join31(this.context.profileDir, "logs"));
       if (!upload) return;
       const sig = `${upload.fileName}:${upload.totalBytes}`;
       if (sig === this.lastLogSig) return;
@@ -44290,10 +44741,10 @@ var WsClient = class {
 };
 
 // src/core/instance-lock.ts
-import { readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "fs";
-import { join as join29 } from "path";
+import { readFileSync as readFileSync17, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "fs";
+import { join as join32 } from "path";
 function lockPath(profileDir2) {
-  return join29(profileDir2, "start.lock");
+  return join32(profileDir2, "start.lock");
 }
 function isAlive(pid) {
   try {
@@ -44305,7 +44756,7 @@ function isAlive(pid) {
 }
 function lockHolder(profileDir2) {
   try {
-    const pid = Number.parseInt(readFileSync16(lockPath(profileDir2), "utf8").trim(), 10);
+    const pid = Number.parseInt(readFileSync17(lockPath(profileDir2), "utf8").trim(), 10);
     if (Number.isInteger(pid) && pid > 0 && pid !== process.pid && isAlive(pid)) return pid;
   } catch {
   }
@@ -44318,7 +44769,7 @@ function acquireInstanceLock(profileDir2) {
 }
 function releaseInstanceLock(profileDir2) {
   try {
-    const pid = Number.parseInt(readFileSync16(lockPath(profileDir2), "utf8").trim(), 10);
+    const pid = Number.parseInt(readFileSync17(lockPath(profileDir2), "utf8").trim(), 10);
     if (pid === process.pid) rmSync7(lockPath(profileDir2), { force: true });
   } catch {
   }
@@ -44326,7 +44777,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 +44808,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,15 +45039,38 @@ 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
 import { createServer } from "net";
-import { rmSync as rmSync8 } from "fs";
-import { join as join30 } from "path";
+import { chmodSync as chmodSync4, rmSync as rmSync8 } from "fs";
+import { join as join34 } from "path";
 
 // src/core/control-protocol.ts
 var CONTROL_SOCKET_FILE = "control.sock";
+var CONTROL_TOKEN_FILE = "control.token";
 function encodeFrame(frame) {
   return `${JSON.stringify(frame)}
 `;
@@ -44620,9 +45094,41 @@ function createFrameParser() {
   };
 }
 
+// src/core/control-token.ts
+import { chmodSync as chmodSync3, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
+import { randomBytes as randomBytes3, timingSafeEqual } from "crypto";
+import { join as join33 } from "path";
+function controlTokenPath(profileDir2) {
+  return join33(profileDir2, CONTROL_TOKEN_FILE);
+}
+function writeControlToken(profileDir2) {
+  const token = randomBytes3(32).toString("hex");
+  const path = controlTokenPath(profileDir2);
+  writeFileSync10(path, token, { mode: 384 });
+  try {
+    chmodSync3(path, 384);
+  } catch {
+  }
+  return token;
+}
+function readControlToken(profileDir2) {
+  try {
+    const v2 = readFileSync18(controlTokenPath(profileDir2), "utf8").trim();
+    return v2.length > 0 ? v2 : null;
+  } catch {
+    return null;
+  }
+}
+function tokenMatches(expected, given) {
+  if (!given) return false;
+  const a = Buffer.from(expected, "utf8");
+  const b2 = Buffer.from(given, "utf8");
+  return a.length === b2.length && timingSafeEqual(a, b2);
+}
+
 // src/core/control-server.ts
 function startControlServer(bus, profileDir2, info) {
-  const socketPath = join30(profileDir2, CONTROL_SOCKET_FILE);
+  const socketPath = join34(profileDir2, CONTROL_SOCKET_FILE);
   try {
     rmSync8(socketPath, { force: true });
   } catch {
@@ -44650,29 +45156,44 @@ 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 token = writeControlToken(profileDir2);
+  const sendSnapshot = (sock) => send(sock, {
+    t: "snapshot",
+    info,
+    status: bus.status,
+    busy: bus.busy,
+    activeProfile: bus.activeProfile,
+    scope: bus.scope,
+    worker: bus.worker,
+    project: bus.project,
+    usage: bus.usage,
+    tokens: bus.sessionTokens,
+    transcript: bus.snapshot()
+  });
   const server = createServer((sock) => {
-    clients.add(sock);
-    send(sock, {
-      t: "snapshot",
-      info,
-      status: bus.status,
-      busy: bus.busy,
-      activeProfile: bus.activeProfile,
-      scope: bus.scope,
-      worker: bus.worker,
-      project: bus.project,
-      usage: bus.usage,
-      tokens: bus.sessionTokens,
-      transcript: bus.snapshot()
-    });
-    const parse = createFrameParser();
     sock.setEncoding("utf8");
+    let authed = false;
+    const parse = createFrameParser();
     sock.on("data", (chunk) => {
       for (const frame of parse(chunk)) {
+        if (!authed) {
+          if (frame.t === "auth" && tokenMatches(token, frame.token)) {
+            authed = true;
+            clients.add(sock);
+            sendSnapshot(sock);
+          } else {
+            send(sock, { t: "authError" });
+            sock.destroy();
+          }
+          continue;
+        }
         if (frame.t === "submit") bus.submitLocal(frame.input);
         else if (frame.t === "reconnect") bus.requestReconnect();
+        else if (frame.t === "autonomousRun") bus.submitAutonomous();
       }
     });
     const drop = () => {
@@ -44683,7 +45204,12 @@ function startControlServer(bus, profileDir2, info) {
   });
   server.on("error", () => {
   });
-  server.listen(socketPath);
+  server.listen(socketPath, () => {
+    try {
+      chmodSync4(socketPath, 384);
+    } catch {
+    }
+  });
   return () => {
     for (const un2 of unsubs) un2();
     for (const sock of clients) sock.destroy();
@@ -44691,6 +45217,7 @@ function startControlServer(bus, profileDir2, info) {
     server.close();
     try {
       rmSync8(socketPath, { force: true });
+      rmSync8(controlTokenPath(profileDir2), { force: true });
     } catch {
     }
   };
@@ -50353,17 +50880,17 @@ var import_react21 = __toESM(require_react(), 1);
 var import_react26 = __toESM(require_react(), 1);
 
 // src/core/input-history.ts
-import { existsSync as existsSync18, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
+import { join as join35 } from "path";
 var MAX_HISTORY = 200;
 function historyPath(profileDir2) {
-  return join31(profileDir2, "input-history.json");
+  return join35(profileDir2, "input-history.json");
 }
 function loadInputHistory(profileDir2) {
   const path = historyPath(profileDir2);
   if (!existsSync18(path)) return [];
   try {
-    const data = JSON.parse(readFileSync18(path, "utf8"));
+    const data = JSON.parse(readFileSync20(path, "utf8"));
     return Array.isArray(data) ? data.filter((x) => typeof x === "string") : [];
   } catch {
     return [];
@@ -50374,7 +50901,7 @@ function appendInputHistory(profileDir2, line, current2) {
   if (!trimmed || current2[current2.length - 1] === trimmed) return current2;
   const next = [...current2, trimmed].slice(-MAX_HISTORY);
   try {
-    writeFileSync10(historyPath(profileDir2), JSON.stringify(next), "utf8");
+    writeFileSync11(historyPath(profileDir2), JSON.stringify(next), "utf8");
   } catch {
   }
   return next;
@@ -50971,7 +51498,7 @@ async function runStart(profileDir2, profileName) {
     return;
   }
   logger.configure({
-    dir: join32(profileDir2, "logs"),
+    dir: join36(profileDir2, "logs"),
     level: resolveLogLevel(),
     base: { version: CLI_VERSION, profile: profileName, scope: credential.scope }
   });
@@ -51080,15 +51607,21 @@ async function runStart(profileDir2, profileName) {
 }
 
 // src/commands/attach.ts
-import { join as join33 } from "path";
+import { join as join37 } from "path";
 
 // src/core/control-client.ts
 import { connect as connect2 } from "net";
-function connectControl(socketPath, bus) {
+function connectControl(socketPath, bus, token) {
   return new Promise((resolve10, reject) => {
     const socket = connect2(socketPath);
     socket.setEncoding("utf8");
     let ready = false;
+    socket.on("connect", () => {
+      try {
+        socket.write(encodeFrame({ t: "auth", token: token ?? "" }));
+      } catch {
+      }
+    });
     const forwardSubmit = bus.onLocalSubmit((input) => {
       try {
         socket.write(encodeFrame({ t: "submit", input }));
@@ -51167,6 +51700,9 @@ function connectControl(socketPath, bus) {
         case "tokens":
           bus.setTokens(frame.total);
           break;
+        case "authError":
+          if (!ready) reject(new Error("control-channel auth failed"));
+          break;
       }
     }
   });
@@ -51180,11 +51716,11 @@ async function runAttach(profileDir2, profileName) {
     process.exitCode = 1;
     return;
   }
-  const socketPath = join33(profileDir2, CONTROL_SOCKET_FILE);
+  const socketPath = join37(profileDir2, CONTROL_SOCKET_FILE);
   const bus = new SessionBus();
   let conn;
   try {
-    conn = await connectControl(socketPath, bus);
+    conn = await connectControl(socketPath, bus, readControlToken(profileDir2));
   } catch {
     console.error(t("attach.noDaemon", { profile: profileName }));
     process.exitCode = 1;
@@ -51209,6 +51745,67 @@ async function runAttach(profileDir2, profileName) {
   }
 }
 
+// src/commands/auto-run.ts
+import { connect as connect3 } from "net";
+import { join as join38 } from "path";
+var AUTO_RUN_TIMEOUT_MS = 3 * 60 * 60 * 1e3;
+async function runAutoRun(profileDir2, profileName) {
+  initI18n(readProfileConfig(profileDir2).locale);
+  const socketPath = join38(profileDir2, CONTROL_SOCKET_FILE);
+  const token = readControlToken(profileDir2);
+  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: "auth", token: token ?? "" }));
+        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);
+        } else if (frame.t === "authError") {
+          console.error(t("autoRun.authFailed"));
+          done(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 +52030,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 +52079,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)",