@4pm/cli 1.18.0 → 1.19.2

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 });
@@ -28877,7 +28883,8 @@ var en_default = {
   "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.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
@@ -29059,7 +29066,8 @@ var vi_default = {
   "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.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
@@ -29241,7 +29249,8 @@ var ja_default = {
   "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.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
@@ -29423,7 +29432,8 @@ var zh_default = {
   "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.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
@@ -29510,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";
@@ -32723,7 +32733,7 @@ async function checkAndUpdate(serverUrl, autoUpdate) {
 // src/core/ws-client.ts
 init_wrapper();
 import { randomUUID as randomUUID3 } from "crypto";
-import { basename as basename7, join as join28 } from "path";
+import { basename as basename7, join as join31 } from "path";
 import { existsSync as existsSync16, mkdirSync as mkdirSync7 } from "fs";
 
 // vendor/@4pm/utils/helpers.ts
@@ -38022,6 +38032,9 @@ var OutputBatcher = class {
       flushIntervalMs: 200,
       flushSizeKb: 64,
       maxBufferKb: 512,
+      // Well under the cli-server WS maxPayload (8 MiB — ADR-0322) even after the enveloped frame's
+      // AES-256-GCM + base64 + JSON inflation (~1.37×), and small enough to keep SSE replay chunks light.
+      maxFrameKb: 256,
       overflow: "backpressure",
       ...options
     };
@@ -38052,7 +38065,9 @@ var OutputBatcher = class {
     }
   }
   /**
-   * Flush the entire current buffer immediately (one batch).
+   * Flush the current buffer immediately, splitting it into frames no larger than `maxFrameKb`
+   * (ADR-0322) so a single large burst never produces one over-`maxPayload` WS frame. The
+   * `truncated` flag is carried on the last frame only.
    */
   flush() {
     if (this.timer) {
@@ -38060,7 +38075,7 @@ var OutputBatcher = class {
       this.timer = null;
     }
     if (this.buffer.length === 0 && !this.truncated) return;
-    const chunk = this.buffer;
+    const buf = this.buffer;
     const truncated = this.truncated;
     this.buffer = "";
     this.truncated = false;
@@ -38068,7 +38083,16 @@ var OutputBatcher = class {
       this.paused = false;
       this.opts.onPressure?.(false);
     }
-    this.opts.onFlush(chunk, truncated);
+    const max = this.opts.maxFrameKb * 1024;
+    if (buf.length <= max) {
+      this.opts.onFlush(buf, truncated);
+      return;
+    }
+    for (let i = 0; i < buf.length; i += max) {
+      const slice = buf.slice(i, i + max);
+      const isLast = i + max >= buf.length;
+      this.opts.onFlush(slice, isLast && truncated);
+    }
   }
 };
 
@@ -39887,14 +39911,122 @@ 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";
@@ -39906,10 +40038,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;
   }
@@ -39955,7 +40086,7 @@ function tableRowsById(md) {
   return rows;
 }
 function tickScript(root) {
-  return join15(root, TICK_REL);
+  return join17(root, TICK_REL);
 }
 async function crontabList() {
   try {
@@ -39977,28 +40108,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"));
@@ -40007,13 +40138,13 @@ function isAutonomousRunning(root) {
     return false;
   }
 }
-async function readAutonomous(root) {
+async function readAutonomous(root, profileDir2) {
   const [settings, approvals, authors, status, ...books] = await Promise.all([
-    readText(join15(root, SETTINGS_REL)),
-    readText(join15(root, APPROVALS_REL), "{}"),
-    readText(join15(root, AUTHORS_REL), "{}"),
-    getAutonomousStatus(root),
-    ...Object.values(BOOK_FILES).map((f2) => readText(join15(root, f2)))
+    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 = {};
@@ -40022,18 +40153,21 @@ async function readAutonomous(root) {
 }
 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();
@@ -40041,82 +40175,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": {
         if (req.approved && !req.byIsAdmin) {
-          const authors = await readJsonMap(join15(root, AUTHORS_REL));
+          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(join15(root, APPROVALS_REL), "{}")) ?? {};
+        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": {
         if (!req.byIsAdmin) {
-          const authors = await readJsonMap(join15(root, AUTHORS_REL));
+          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(join15(root, APPROVALS_REL), "{}")) ?? {};
+        const map = parseJson(await readText(join17(root, APPROVALS_REL), "{}")) ?? {};
         const at2 = (/* @__PURE__ */ new Date()).toISOString();
         const byLabel = req.byLabel ?? by;
         for (const taskId of req.approve) map[taskId] = { approved: true, by, byLabel, at: at2 };
         for (const taskId of req.unapprove) delete map[taskId];
-        await 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 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");
-        const authors = await readJsonMap(join15(root, AUTHORS_REL));
+        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 writeFile2(join15(root, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
+        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(join15(root, file)));
+        const prev = tableRowsById(await readText(join17(root, file)));
         const next = tableRowsById(req.content);
-        const authors = await readJsonMap(join15(root, AUTHORS_REL));
+        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 writeFile2(join15(root, file), req.content, "utf8");
-        await writeFile2(join15(root, AUTHORS_REL), JSON.stringify(authors, null, 2) + "\n", "utf8");
+        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 },
@@ -40126,7 +40262,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;
@@ -40160,7 +40296,7 @@ function probeInbound() {
   const isExposed = (path, loopbackHexPrefixes) => {
     let body;
     try {
-      body = readFileSync14(path, "utf8");
+      body = readFileSync15(path, "utf8");
     } catch {
       return false;
     }
@@ -40195,7 +40331,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" };
@@ -40213,7 +40349,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;
@@ -40451,7 +40587,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",
@@ -40463,7 +40599,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();
@@ -40598,7 +40734,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"));
@@ -41438,6 +41574,8 @@ 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
@@ -41520,20 +41658,165 @@ non-fast-forward \u21D2 \`git pull --rebase origin "$BASE"\` then push again).
 
 ## Step 8 \u2014 Stop
 Print a one-line summary (task id + PR link or incident). STOP \u2014 the next cron tick runs the next cycle.
-The cron tick owns the run lock; you do NOT manage \`.claude/.autonomous.lock\`.`;
+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 commandId = randomUUID2();
+  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 {
-    await runAiPrompt(ctx, buildAutonomousCyclePrompt(), commandId, "local", false, void 0, void 0, false, true);
-    ctx.bus.autonomousDone(true);
+    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: [] };
@@ -41541,7 +41824,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"
@@ -41556,7 +41839,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) {
@@ -41571,7 +41854,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 };
@@ -41581,7 +41864,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) {
@@ -41600,8 +41883,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) };
@@ -41609,7 +41892,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) {
@@ -41619,14 +41902,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;
@@ -41640,7 +41923,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": {
@@ -41651,8 +41934,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": {
@@ -41663,7 +41946,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 };
       }
@@ -41671,7 +41954,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:
@@ -41683,7 +41966,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;
@@ -41727,8 +42010,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) };
@@ -41738,12 +42021,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),
@@ -41802,7 +42085,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";
@@ -41829,7 +42112,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;
@@ -41896,18 +42179,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;
   }
@@ -41929,9 +42212,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
   });
@@ -41940,8 +42223,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
   );
@@ -42115,7 +42398,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) {
@@ -42197,7 +42480,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;
     }
@@ -42229,14 +42512,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);
@@ -42258,7 +42541,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);
@@ -42527,8 +42810,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"]);
@@ -42537,7 +42820,7 @@ function safeName(name) {
 }
 async function readText2(path, fallback = "") {
   try {
-    return await readFile7(path, "utf8");
+    return await readFile10(path, "utf8");
   } catch {
     return fallback;
   }
@@ -42552,17 +42835,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 {
@@ -42573,15 +42856,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 } };
 }
@@ -42590,14 +42873,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) };
@@ -42605,21 +42888,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 {};
@@ -42638,8 +42921,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)]);
@@ -42652,14 +42935,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) {
@@ -42668,18 +42951,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 {};
@@ -42702,8 +42985,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) };
@@ -42712,8 +42995,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";
@@ -42722,7 +43005,7 @@ function safeName2(name) {
 }
 async function readMaybe(path) {
   try {
-    return await readFile10(path);
+    return await readFile13(path);
   } catch {
     return null;
   }
@@ -42732,12 +43015,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));
     }
@@ -42748,16 +43031,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") });
     }
   }
@@ -42775,16 +43058,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"));
@@ -42793,35 +43076,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);
     }
   }
 }
@@ -42885,11 +43168,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);
@@ -42900,8 +43183,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"]);
@@ -42913,7 +43196,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;
     }
@@ -42921,7 +43204,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)) {
@@ -42949,7 +43232,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;
     }
@@ -42988,7 +43271,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;
     }
@@ -43040,11 +43323,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";
@@ -43065,7 +43348,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 [];
@@ -43127,14 +43410,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 },
@@ -43145,9 +43428,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,
@@ -43214,14 +43497,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
@@ -43241,12 +43524,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":[]}');
@@ -43261,9 +43544,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 = `
@@ -43290,8 +43573,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",
@@ -43308,10 +43591,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 {
     }
   }
@@ -43342,7 +43625,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)
         );
       }
@@ -43359,7 +43642,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)
         );
       }
@@ -44201,7 +44484,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
@@ -44218,7 +44501,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,
@@ -44310,7 +44593,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;
@@ -44472,10 +44755,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 {
@@ -44487,7 +44770,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 {
   }
@@ -44500,7 +44783,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 {
   }
@@ -44796,11 +45079,12 @@ var SessionBus = class {
 
 // 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)}
 `;
@@ -44824,9 +45108,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 {
@@ -44858,25 +45174,37 @@ function startControlServer(bus, profileDir2, info) {
     // 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();
@@ -44890,7 +45218,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();
@@ -44898,6 +45231,7 @@ function startControlServer(bus, profileDir2, info) {
     server.close();
     try {
       rmSync8(socketPath, { force: true });
+      rmSync8(controlTokenPath(profileDir2), { force: true });
     } catch {
     }
   };
@@ -50560,17 +50894,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 [];
@@ -50581,7 +50915,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;
@@ -51178,7 +51512,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 }
   });
@@ -51287,15 +51621,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 }));
@@ -51374,6 +51714,9 @@ function connectControl(socketPath, bus) {
         case "tokens":
           bus.setTokens(frame.total);
           break;
+        case "authError":
+          if (!ready) reject(new Error("control-channel auth failed"));
+          break;
       }
     }
   });
@@ -51387,11 +51730,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;
@@ -51418,11 +51761,12 @@ async function runAttach(profileDir2, profileName) {
 
 // src/commands/auto-run.ts
 import { connect as connect3 } from "net";
-import { join as join34 } from "path";
+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 = join34(profileDir2, CONTROL_SOCKET_FILE);
+  const socketPath = join38(profileDir2, CONTROL_SOCKET_FILE);
+  const token = readControlToken(profileDir2);
   const code = await new Promise((resolve10) => {
     let settled = false;
     const done = (c) => {
@@ -51444,6 +51788,7 @@ async function runAutoRun(profileDir2, profileName) {
     timer.unref?.();
     socket.on("connect", () => {
       try {
+        socket.write(encodeFrame({ t: "auth", token: token ?? "" }));
         socket.write(encodeFrame({ t: "autonomousRun" }));
       } catch {
         done(1);
@@ -51460,6 +51805,9 @@ async function runAutoRun(profileDir2, profileName) {
           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);
         }
       }
     });