@4pm/cli 1.4.12 → 1.5.0

package/dist/index.js

@@ -28312,14 +28312,45 @@ function defaultProfileConfig() {
     aiFailoverMode: "remember",
     autoUpdate: true,
     commandHistoryUploadMinutes: 10,
-    autoClearIdleMinutes: 10
+    autoClearIdleMinutes: 10,
+    // Terminate a single AI run after 5 min by default (ADR-0243) so a hung/looping AI CLI
+    // (e.g. a heavy spec review/compose) can't spin the dispatcher forever; 0 = no limit.
+    aiRunTimeoutSec: 300,
+    // Shared AI memory (ADR-0245) — off by default (opt-in; costs a compaction call per turn).
+    aiMemoryEnabled: false,
+    aiMemoryBudgetChars: 6e3
   };
 }
+function resolveMemoryConfig(config) {
+  const mode = config.projectAiMemoryMode ?? "inherit";
+  const enabled = mode === "on" ? true : mode === "off" ? false : config.aiMemoryEnabled ?? false;
+  const projectBudget = config.projectAiMemoryBudgetChars ?? 0;
+  const budgetChars = projectBudget > 0 ? projectBudget : config.aiMemoryBudgetChars ?? 6e3;
+  return { enabled, budgetChars };
+}
+function resolveIdleAutoClearMinutes(config) {
+  const project = config.projectAutoClearIdleMinutes ?? 0;
+  return project > 0 ? project : config.autoClearIdleMinutes ?? 10;
+}
 function ensureProfileConfig(dir2) {
   if (existsSync(join(dir2, "config.json"))) return false;
   writeProfileConfig(dir2, defaultProfileConfig());
   return true;
 }
+function backfillProfileConfig(dir2) {
+  if (!existsSync(join(dir2, "config.json"))) return false;
+  const current = readProfileConfig(dir2);
+  const next = { ...current };
+  let changed = false;
+  for (const [key, value] of Object.entries(defaultProfileConfig())) {
+    if (next[key] === void 0) {
+      next[key] = value;
+      changed = true;
+    }
+  }
+  if (changed) overwriteProfileConfig(dir2, next);
+  return changed;
+}
 function readProfileConfig(dir2) {
   const path = join(dir2, "config.json");
   if (!existsSync(path)) return {};
@@ -28557,7 +28588,7 @@ async function runLink(serverUrl, explicitProfile, token = null) {
 }
 
 // src/commands/start.ts
-import { spawn as spawn9 } from "child_process";
+import { spawn as spawn10 } from "child_process";
 import { join as join29 } from "path";
 
 // src/core/update.ts
@@ -28615,6 +28646,9 @@ function readInstalledVersion() {
   }
 }
 function updateViaNpm(version) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error(`Refusing to update: invalid version string "${version}".`);
+  }
   execSync2(`npm i -g @4pm/cli@${version}`, { stdio: "inherit" });
 }
 async function updateViaDownload(tarballUrl, checksum, signature) {
@@ -33699,7 +33733,11 @@ var WsChannels = {
   SUPPORT_ANSWER: "support.answer",
   // AI knowledge distill (ADR-0190): server → project cli request–reply. The worker runs the AI CLI
   // in the project's working dir with a distillation prompt and replies with the composed markdown.
-  KNOWLEDGE_COMPOSE: "knowledge.compose"
+  KNOWLEDGE_COMPOSE: "knowledge.compose",
+  // Shared AI memory (ADR-0245): cli → server one-way write-back of the compacted rolling memory for
+  // the project it serves (persisted per project × machine-user link). The read direction rides
+  // `ws_token` (seeds the cli cache on connect); this channel only carries updates.
+  MEMORY_UPDATE: "memory.update"
 };
 
 // vendor/@4pm/ws/crypto.ts
@@ -33973,7 +34011,8 @@ var UpdateScheduler = class {
 
 // src/core/executor.ts
 import { spawn as spawn2 } from "child_process";
-async function runCommand(dispatch, emit) {
+var KILL_GRACE_MS = 5e3;
+async function runCommand(dispatch, emit, opts) {
   let seq = 0;
   const child = spawn2(dispatch.cmd, dispatch.args ?? [], {
     cwd: dispatch.path,
@@ -33981,6 +34020,27 @@ async function runCommand(dispatch, emit) {
     shell: false
   });
   child.stdin?.end();
+  const timeoutMs = opts?.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 0;
+  let timedOut = false;
+  let hardKillTimer = null;
+  const timeoutTimer = timeoutMs > 0 ? setTimeout(() => {
+    timedOut = true;
+    emit({
+      commandId: dispatch.commandId,
+      seq: seq++,
+      chunk: `
+[4PM] AI run exceeded the ${Math.round(timeoutMs / 1e3)}s time limit \u2014 terminating.
+`
+    });
+    child.kill("SIGTERM");
+    hardKillTimer = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS);
+    hardKillTimer.unref?.();
+  }, timeoutMs) : null;
+  timeoutTimer?.unref?.();
+  const clearTimers = () => {
+    if (timeoutTimer) clearTimeout(timeoutTimer);
+    if (hardKillTimer) clearTimeout(hardKillTimer);
+  };
   const batcher = new OutputBatcher({
     onFlush: (chunk, truncated) => {
       emit({ commandId: dispatch.commandId, seq: seq++, chunk, truncated });
@@ -33999,17 +34059,21 @@ async function runCommand(dispatch, emit) {
   child.stderr?.on("data", (data) => batcher.push(data.toString("utf8")));
   await new Promise((resolve8) => {
     child.on("close", (exitCode) => {
+      clearTimers();
       batcher.flush();
       emit({
         commandId: dispatch.commandId,
         seq: seq++,
         chunk: "",
         done: true,
-        exitCode: exitCode ?? -1
+        // 124 (the conventional timeout code) when we killed it for exceeding the limit, so the
+        // server settles the command as failed and the web surfaces the note instead of spinning.
+        exitCode: timedOut ? 124 : exitCode ?? -1
       });
       resolve8();
     });
     child.on("error", (err) => {
+      clearTimers();
       emit({
         commandId: dispatch.commandId,
         seq: seq++,
@@ -34052,7 +34116,9 @@ function createAiStreamParser(cli) {
   const isJson = isClaude || isCodex;
   let buffer = "";
   const acc = { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+  let sessionId = "";
   function handleClaude(ev) {
+    if (typeof ev.session_id === "string" && ev.session_id) sessionId = ev.session_id;
     if (ev.type === "result" && ev.usage) {
       acc.input = ev.usage.input_tokens ?? 0;
       acc.output = ev.usage.output_tokens ?? 0;
@@ -34118,7 +34184,8 @@ function createAiStreamParser(cli) {
       const handled = handleLine(line);
       return handled === null ? line : handled;
     },
-    usage: () => ({ ...acc })
+    usage: () => ({ ...acc }),
+    sessionId: () => sessionId
   };
 }
 function estimateTokens(text) {
@@ -34136,15 +34203,15 @@ function isSessionLimit(text) {
     text
   );
 }
-function runAttempt(commandId, cmd, args, cwd2, env3, onChunk) {
+function runAttempt(commandId, cmd, args, cwd2, env3, onChunk, timeoutMs) {
   return new Promise((resolve8) => {
     void runCommand({ commandId, cmd, args, path: cwd2, env: env3 }, (out) => {
       if (out.chunk) onChunk(out.chunk);
       if (out.done) resolve8(out.exitCode ?? -1);
-    });
+    }, timeoutMs > 0 ? { timeoutMs } : void 0);
   });
 }
-async function runAiFailover(plan, commandId, cwd2, handlers) {
+async function runAiFailover(plan, commandId, cwd2, handlers, timeoutMs = 0) {
   const total = plan.attempts.length;
   let finalExit = -1;
   let lastCmd = plan.attempts[0]?.cmd ?? "claude";
@@ -34162,7 +34229,7 @@ async function runAiFailover(plan, commandId, cwd2, handlers) {
         handlers.onChunk(text);
       }
     };
-    finalExit = await runAttempt(commandId, attempt.cmd, attempt.args, cwd2, attempt.env, emit);
+    finalExit = await runAttempt(commandId, attempt.cmd, attempt.args, cwd2, attempt.env, emit, timeoutMs);
     const tail = parser.flush();
     if (tail) {
       captured += tail;
@@ -34173,14 +34240,21 @@ async function runAiFailover(plan, commandId, cwd2, handlers) {
       const usage = parser.usage();
       if (usage.tokens === 0) usage.tokens = estimateTokens(captured);
       reportToolResult(attempt.cmd, true);
-      return { exitCode: 0, workedDir: attempt.dir, workedKey: attempt.key, workedCmd: attempt.cmd, usage };
+      return {
+        exitCode: 0,
+        workedDir: attempt.dir,
+        workedKey: attempt.key,
+        workedCmd: attempt.cmd,
+        usage,
+        sessionId: parser.sessionId()
+      };
     }
-    const reason = isAuthFailure(captured) ? "auth" : isSessionLimit(captured) ? "limit" : null;
-    if (!reason || i === total - 1) break;
+    const reason = isAuthFailure(captured) ? "auth" : isSessionLimit(captured) ? "limit" : "other";
+    if (i === total - 1) break;
     handlers.onAttemptFail(attempt.label, reason);
   }
   reportToolResult(lastCmd, false, summarizeAiFailure(lastCaptured, finalExit));
-  return { exitCode: finalExit, workedDir: null, workedKey: null, workedCmd: null, usage: { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 } };
+  return { exitCode: finalExit, workedDir: null, workedKey: null, workedCmd: null, usage: { tokens: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 }, sessionId: "" };
 }
 function summarizeAiFailure(captured, exitCode) {
   if (isAuthFailure(captured)) return "Not logged in";
@@ -34298,11 +34372,12 @@ function folderScopeGuard(folder, prompt) {
     prompt
   ].join("\n");
 }
-function buildRunArgs(profile, cmd, prompt) {
+function buildRunArgs(profile, cmd, prompt, resumeId) {
   const extras = profile.args ?? [];
   const model = profile.model?.trim();
   const modelArgs = model ? ["--model", model] : [];
-  return [...requiredArgs(cmd), ...extras, ...modelArgs, prompt];
+  const resumeArgs = resumeId && cmd.includes("claude") ? ["--resume", resumeId] : [];
+  return [...requiredArgs(cmd), ...resumeArgs, ...extras, ...modelArgs, prompt];
 }
 function claudeHomeDirs(config) {
   const dirs = profileDirs(claudeProfilesOf(config));
@@ -34341,10 +34416,10 @@ function resolveClaudeProfiles(config, workingDir) {
   if (idx > 0) profiles.unshift(profiles.splice(idx, 1)[0]);
   return profiles;
 }
-function planAiRun(prompt, config, hint = {}) {
-  return isUnifiedConfig(config) ? planUnifiedRun(prompt, config, hint.credential ?? null) : planLegacyRun(prompt, config, hint.dir ?? null);
+function planAiRun(prompt, config, hint = {}, resume = /* @__PURE__ */ new Map()) {
+  return isUnifiedConfig(config) ? planUnifiedRun(prompt, config, hint.credential ?? null, resume) : planLegacyRun(prompt, config, hint.dir ?? null, resume);
 }
-function planUnifiedRun(prompt, config, workingCredential) {
+function planUnifiedRun(prompt, config, workingCredential, resume) {
   const baseEnv = config.aiEnv ?? {};
   const active = activeProvider(config);
   const usable = config.aiProfiles.filter(isUsableCredential);
@@ -34371,12 +34446,12 @@ function planUnifiedRun(prompt, config, workingCredential) {
     label: cred.label?.trim() || profileDisplayLabel(dir2),
     dir: dir2,
     key,
-    args: buildRunArgs(cred, cmd, prompt),
+    args: buildRunArgs(cred, cmd, prompt, resume.get(key)),
     env: envVar ? { ...baseEnv, [envVar]: dir2 } : { ...baseEnv }
   }));
   return { cmd: attempts[0]?.cmd ?? DEFAULT_AI_CLI, attempts };
 }
-function planLegacyRun(prompt, config, workingDir) {
+function planLegacyRun(prompt, config, workingDir, resume) {
   const cmd = config.aiCli || DEFAULT_AI_CLI;
   const baseEnv = config.aiEnv ?? {};
   const envVar = profileEnvVar(cmd);
@@ -34393,14 +34468,17 @@ function planLegacyRun(prompt, config, workingDir) {
     resolved.find((r) => r.dir === workingDir),
     ...resolved.filter((r) => r.dir !== workingDir)
   ] : resolved;
-  const attempts = ordered.map(({ profile, dir: dir2 }) => ({
-    cmd,
-    label: profileDisplayLabel(dir2),
-    dir: dir2,
-    key: credentialKey(cmd, dir2),
-    args: buildRunArgs(profile, cmd, prompt),
-    env: { ...baseEnv, [envVar]: dir2 }
-  }));
+  const attempts = ordered.map(({ profile, dir: dir2 }) => {
+    const key = credentialKey(cmd, dir2);
+    return {
+      cmd,
+      label: profileDisplayLabel(dir2),
+      dir: dir2,
+      key,
+      args: buildRunArgs(profile, cmd, prompt, resume.get(key)),
+      env: { ...baseEnv, [envVar]: dir2 }
+    };
+  });
   return { cmd, attempts };
 }
 
@@ -35075,7 +35153,7 @@ async function runClaudeWithFailover(prompt, ai) {
     if (code === 0 && out.trim()) return { text: out.trim(), usage };
     const combined = err || out;
     lastReason = `exited ${code}: ${combined.slice(0, 500)}`;
-    if (!isAuthFailure(combined) && !isSessionLimit(combined) || i === attempts.length - 1) break;
+    if (i === attempts.length - 1) break;
   }
   throw new Error(`claude ${lastReason}`);
 }
@@ -35174,7 +35252,7 @@ async function runKnowledgeCompose(req, ai, physicRoot) {
       }
       const combined = err || out;
       lastReason = `exited ${code}: ${combined.slice(0, 500)}`;
-      if (!isAuthFailure(combined) && !isSessionLimit(combined) || i === attempts.length - 1) break;
+      if (i === attempts.length - 1) break;
     } catch (e) {
       lastReason = String(e);
       break;
@@ -36177,6 +36255,9 @@ async function ragQuery(root, queryText, k = 8) {
   }
 }
 async function ragInstall(root, model) {
+  if (!/^[A-Za-z0-9._/-]+$/.test(model)) {
+    return { ok: false, started: false, error: "invalid model name" };
+  }
   const py = await detectPython();
   if (!py.found) return { ok: false, started: false, error: "python3 not found on the worker" };
   if (existsSync10(join20(root, RAG_REL, ".installing"))) return { ok: true, started: true };
@@ -36587,10 +36668,93 @@ async function addProject(payload, profileDir2, onProgress) {
   }
 }
 
+// src/core/memory-compact.ts
+import { spawn as spawn8 } from "child_process";
+var COMPACT_TIMEOUT_MS = 6e4;
+function buildPrompt3(input) {
+  return [
+    "You maintain a COMPACT running memory of an ongoing assistant conversation so it can continue",
+    "across sessions and accounts. Merge the latest exchange into the existing memory and return the",
+    `UPDATED memory. Keep it UNDER ${input.budgetChars} characters. Use terse Markdown bullets grouped`,
+    "as: Decisions, Constraints, Open tasks, Glossary. Keep durable facts; drop chit-chat and anything",
+    "now obsolete. Output ONLY the updated memory text \u2014 no preamble, no code fences.",
+    "",
+    "=== EXISTING MEMORY ===",
+    input.oldMemory || "(empty)",
+    "",
+    "=== LATEST USER PROMPT ===",
+    input.prompt,
+    "",
+    "=== LATEST ASSISTANT ANSWER ===",
+    input.answer
+  ].join("\n");
+}
+function runOnce2(cmd, profile, prompt, cwd2, extraEnv) {
+  return new Promise((resolve8, reject) => {
+    const args = ["-p", ...profile?.model ? ["--model", profile.model] : []];
+    const env3 = {
+      ...process.env,
+      ...extraEnv,
+      ...profile ? { CLAUDE_CONFIG_DIR: profile.dir } : {}
+    };
+    const child = spawn8(cmd, args, { stdio: ["pipe", "pipe", "pipe"], cwd: cwd2, env: env3 });
+    let out = "";
+    let err = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error("memory compaction timed out"));
+    }, COMPACT_TIMEOUT_MS);
+    timer.unref();
+    child.stdout.on("data", (d) => out += d.toString());
+    child.stderr.on("data", (d) => err += d.toString());
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve8({ code: code ?? -1, out, err });
+    });
+    child.stdin.write(prompt);
+    child.stdin.end();
+  });
+}
+async function runMemoryCompaction(ai, cwd2, input) {
+  const prompt = buildPrompt3(input);
+  const attempts = ai.profiles.length > 0 ? ai.profiles : [null];
+  for (let i = 0; i < attempts.length; i++) {
+    try {
+      const { code, out } = await runOnce2(ai.cmd, attempts[i], prompt, cwd2, ai.env);
+      if (code === 0 && out.trim()) {
+        reportToolResult(ai.cmd, true);
+        return out.trim().slice(0, input.budgetChars);
+      }
+      if (i === attempts.length - 1) break;
+    } catch {
+      break;
+    }
+  }
+  return "";
+}
+
 // src/core/config-sync.ts
 import { existsSync as existsSync11, readFileSync as readFileSync15 } from "fs";
 import { join as join23 } from "path";
-var SERVER_MANAGED_KEYS = ["physicPath", "sessionSwitchPct", "perPromptTokenLimit"];
+var SERVER_MANAGED_KEYS = [
+  "physicPath",
+  "sessionSwitchPct",
+  "perPromptTokenLimit",
+  // Project AI-run timeout override mirror (ADR-0243) — the ws_token refreshes it; a Worker-config
+  // edit must not fight it. NOTE: the machine-user's own `aiRunTimeoutSec` is NOT here (operator-editable).
+  "projectAiRunTimeoutSec",
+  // Project idle auto-clear override mirror (ADR-0244) — same rule; the machine-user's own
+  // `autoClearIdleMinutes` is operator-editable and NOT listed here.
+  "projectAutoClearIdleMinutes",
+  // Project shared-AI-memory override mirrors (ADR-0245) — the machine-user's own `aiMemoryEnabled`
+  // / `aiMemoryBudgetChars` are operator-editable and NOT listed here.
+  "projectAiMemoryMode",
+  "projectAiMemoryBudgetChars"
+];
 function readConfigText(profileDir2) {
   const path = join23(profileDir2, "config.json");
   if (existsSync11(path)) {
@@ -36622,7 +36786,7 @@ function applyConfigText(profileDir2, text) {
 }
 
 // src/core/worker-tools.ts
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn9 } from "child_process";
 var NPM_NAME = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
 function run10(cmd, args, onLine, timeoutMs = 18e4) {
   return new Promise((resolve8) => {
@@ -36653,7 +36817,7 @@ function run10(cmd, args, onLine, timeoutMs = 18e4) {
       }
     };
     try {
-      child = spawn8(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+      child = spawn9(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
       child.stdout?.on("data", feed);
       child.stderr?.on("data", feed);
       child.on("exit", (code) => done(code ?? 0));
@@ -36741,6 +36905,7 @@ async function runWorkerToolOp(op, name, manager, onLine) {
 }
 
 // src/core/ws-client.ts
+var MEMORY_SEED_HEADER = "CONTEXT MEMORY from earlier in this conversation (may span prior sessions/accounts). Use it as background; do not repeat it back unless relevant:";
 var HEARTBEAT_MS = 3e4;
 var USAGE_POLL_MS = 5 * 6e4;
 var LOG_UPLOAD_MS = 10 * 6e4;
@@ -36780,6 +36945,7 @@ var WsClient = class {
       (entry) => this.emitConsole({ kind: "update", entry: toDtoEntry(entry) })
     );
     context.bus.onClear(() => this.emitConsoleClear());
+    context.bus.onClearSession(() => this.resetMemorySession());
   }
   context;
   socket = null;
@@ -36805,6 +36971,13 @@ var WsClient = class {
    * when true the cli prepends a folder-scope guard to every AI prompt. Fed by each ws_token.
    */
   restrictToFolder = false;
+  /**
+   * Shared AI memory (ADR-0245) cache for the served project: the rolling compacted text (seeded by
+   * `ws_token`, updated after each run) + the last native `session_id` per credential key (for
+   * `--resume` on the same profile). Per (project × link) — this cli instance is one link.
+   */
+  aiMemory = "";
+  sessionIdByKey = /* @__PURE__ */ new Map();
   stopped = false;
   /** Resolver to wake the backoff sleep early (set while waiting) — for /reconnect. */
   wakeReconnect = null;
@@ -37015,8 +37188,16 @@ var WsClient = class {
         }
         writeProfileConfig(this.context.profileDir, {
           sessionSwitchPct: token.projectTokens?.sessionSwitchPct ?? 0,
-          perPromptTokenLimit: token.projectTokens?.perPromptTokenLimit ?? 0
+          perPromptTokenLimit: token.projectTokens?.perPromptTokenLimit ?? 0,
+          // Project AI-run timeout override (ADR-0243) — 0 ⇒ inherit the machine-user setting.
+          projectAiRunTimeoutSec: token.projectTokens?.aiRunTimeoutSec ?? 0,
+          // Project idle auto-clear override (ADR-0244) — 0 ⇒ inherit the machine-user setting.
+          projectAutoClearIdleMinutes: token.projectTokens?.autoClearIdleMinutes ?? 0,
+          // Project shared-AI-memory override mirrors (ADR-0245).
+          projectAiMemoryMode: token.aiMemory?.mode ?? "inherit",
+          projectAiMemoryBudgetChars: token.aiMemory?.budgetChars ?? 0
         });
+        if (token.aiMemory && !this.aiMemory) this.aiMemory = token.aiMemory.text;
         this.outboundReviewEnabled = token.outboundReview?.enabled === true;
         this.restrictToFolder = token.aiRestrictToFolder === true;
         applyGitAuth(token.gitAuth ?? null);
@@ -37636,6 +37817,10 @@ var WsClient = class {
    */
   async runAiPrompt(prompt, commandId, origin) {
     const config = readProfileConfig(this.context.profileDir);
+    const projectTimeoutSec = config.projectAiRunTimeoutSec ?? 0;
+    const machineTimeoutSec = config.aiRunTimeoutSec ?? 0;
+    const timeoutSec = projectTimeoutSec > 0 ? projectTimeoutSec : machineTimeoutSec;
+    const aiRunTimeoutMs = timeoutSec > 0 ? timeoutSec * 1e3 : 0;
     const perPromptLimit = config.perPromptTokenLimit ?? 0;
     if (perPromptLimit > 0) {
       const estimated = estimateTokens(prompt);
@@ -37687,12 +37872,22 @@ var WsClient = class {
         text: `session ${this.usageSnapshot?.session.utilizationPct ?? 0}% \u2265 ${config.sessionSwitchPct}% \u2014 switching to Claude profile "${labelFromCredentialKey(startCred)}"`
       });
     }
-    const effectivePrompt = this.restrictToFolder && this.physicRoot ? folderScopeGuard(this.physicRoot, prompt) : prompt;
-    const plan = planAiRun(
-      effectivePrompt,
-      config,
-      unified ? { credential: startCred ?? workingCred } : { dir: startDir ?? workingDir }
-    );
+    const guardedPrompt = this.restrictToFolder && this.physicRoot ? folderScopeGuard(this.physicRoot, prompt) : prompt;
+    const hint = unified ? { credential: startCred ?? workingCred } : { dir: startDir ?? workingDir };
+    const memCfg = resolveMemoryConfig(config);
+    const firstAttempt = planAiRun(guardedPrompt, config, hint).attempts[0];
+    const resumeId = memCfg.enabled && firstAttempt?.key && firstAttempt.cmd === "claude" ? this.sessionIdByKey.get(firstAttempt.key) : void 0;
+    let effectivePrompt = guardedPrompt;
+    let resume = /* @__PURE__ */ new Map();
+    if (resumeId) {
+      resume = this.sessionIdByKey;
+    } else if (memCfg.enabled && this.aiMemory) {
+      effectivePrompt = `${MEMORY_SEED_HEADER}
+${this.aiMemory}
+
+${guardedPrompt}`;
+    }
+    const plan = planAiRun(effectivePrompt, config, hint, resume);
     const markerArgs = plan.attempts[0]?.args ?? [];
     this.bus.push({ source: origin, kind: "aireq", text: `${plan.cmd} \u2039 ${prompt}` });
     logger.info("command.ai", { commandId, origin, cmd: plan.cmd, profiles: plan.attempts.length });
@@ -37714,12 +37909,14 @@ var WsClient = class {
     let displayMode = "pending";
     let resultId = null;
     let resultBuf = "";
-    const result = await runAiFailover(plan, commandId, cwd2, {
+    let answerText = "";
+    const handlers = {
       onChunk: (text) => {
         if (!responseHeaderShown) {
           this.bus.push({ source: origin, kind: "aires", text: `${plan.cmd} \u203A` });
           responseHeaderShown = true;
         }
+        answerText += text;
         appendCommandOutput(commandId, text);
         this.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: text });
         if (displayMode === "result") {
@@ -37754,8 +37951,13 @@ var WsClient = class {
         this.send(WsChannels.COMMAND_OUTPUT, { commandId, seq: seq++, chunk: `${text}
 `, log: true });
       }
-    });
-    this.bus.endBusy(plan.cmd);
+    };
+    let result;
+    try {
+      result = await runAiFailover(plan, commandId, cwd2, handlers, aiRunTimeoutMs);
+    } finally {
+      this.bus.endBusy(plan.cmd);
+    }
     const profileLabel = result.workedDir ? profileDisplayLabel(result.workedDir) : null;
     if (result.workedDir) {
       if (unified && result.workedKey) {
@@ -37819,6 +38021,43 @@ var WsClient = class {
       text: result.exitCode === 0 ? "\u2713 ready \u2014 enter your next prompt" : `\u2717 ${plan.cmd} failed (exit ${result.exitCode}) \u2014 see the error above`,
       level: result.exitCode === 0 ? "info" : "error"
     });
+    if (memCfg.enabled && result.exitCode === 0) {
+      if (result.workedKey && result.sessionId) {
+        this.sessionIdByKey.set(result.workedKey, result.sessionId);
+      }
+      void this.updateSharedMemory(config, prompt, answerText, memCfg.budgetChars).catch(() => {
+      });
+    }
+  }
+  /**
+   * Fold the latest exchange into the shared AI memory (ADR-0245): a background claude compaction to a
+   * budget-bounded summary, cached locally + written back to the server (`memory.update`). Best-effort —
+   * a failed/empty compaction keeps the previous memory (no write). Claude-only (mirrors the design's
+   * native-session focus); a non-claude worker simply never compacts.
+   */
+  async updateSharedMemory(config, userPrompt, answer, budgetChars) {
+    if (!answer.trim()) return;
+    const profiles = resolveClaudeProfiles(config, this.physicRoot);
+    const cwd2 = this.physicRoot ?? process.cwd();
+    const newMemory = await runMemoryCompaction(
+      { cmd: "claude", profiles, env: config.aiEnv },
+      cwd2,
+      { oldMemory: this.aiMemory, prompt: userPrompt, answer, budgetChars }
+    );
+    if (!newMemory) return;
+    this.aiMemory = newMemory;
+    this.send(WsChannels.MEMORY_UPDATE, { text: newMemory });
+  }
+  /**
+   * Reset the shared AI memory + native sessions for a "new conversation" (ADR-0245) — a manual
+   * `/clear`. Drops the cached memory + every remembered `session_id` (so the next run starts a fresh
+   * native session) and clears the server-stored memory. Idle auto-clear does NOT call this
+   * (display-only — ADR-0244).
+   */
+  resetMemorySession() {
+    this.aiMemory = "";
+    this.sessionIdByKey.clear();
+    this.send(WsChannels.MEMORY_UPDATE, { text: "" });
   }
   /**
    * Pick the Claude profile to try first when under session pressure (ADR-0081). Returns
@@ -38379,6 +38618,18 @@ var SessionBus = class {
     this.emitter.on("clear", fn);
     return () => this.emitter.off("clear", fn);
   }
+  /**
+   * Signal a "new conversation" (a MANUAL `/clear`, ADR-0245) — distinct from `clear()`, which the
+   * idle auto-clear (ADR-0244) also calls. Consumers reset the shared AI memory + native session.
+   */
+  clearSession() {
+    this.emitter.emit("clearSession");
+  }
+  /** Subscribe to a manual `/clear` reset (shared-memory + native-session reset — ADR-0245). */
+  onClearSession(fn) {
+    this.emitter.on("clearSession", fn);
+    return () => this.emitter.off("clearSession", fn);
+  }
   /** The current transcript entries (a copy) — the console-sync snapshot source (ADR-0150). */
   snapshot() {
     return [...this.history];
@@ -38684,14 +38935,13 @@ function startControlServer(bus, profileDir2, info) {
 
 // src/core/idle-auto-clear.ts
 function startIdleAutoClear(bus, idleMinutes) {
-  const idleMs = Math.max(0, idleMinutes) * 6e4;
-  if (idleMs <= 0) return () => {
-  };
   let lastActivity = Date.now();
   const off = bus.onTranscript(() => {
     lastActivity = Date.now();
   });
   const timer = setInterval(() => {
+    const idleMs = Math.max(0, idleMinutes()) * 6e4;
+    if (idleMs <= 0) return;
     if (bus.busy !== null || bus.snapshot().length === 0) return;
     if (Date.now() - lastActivity < idleMs) return;
     bus.clear();
@@ -45083,10 +45333,6 @@ function App2({
   const [history, setHistory] = (0, import_react26.useState)(() => loadInputHistory(info.profileDir));
   const [startedAt] = (0, import_react26.useState)(() => Date.now());
   const [pendingConfirm, setPendingConfirm] = (0, import_react26.useState)(null);
-  const [autoClearIdleMs] = (0, import_react26.useState)(() => {
-    const min = readProfileConfig(info.profileDir).autoClearIdleMinutes ?? 10;
-    return min > 0 ? min * 6e4 : 0;
-  });
   const lastActivityRef = (0, import_react26.useRef)(startedAt);
   const busyRef = (0, import_react26.useRef)(busy);
   busyRef.current = busy;
@@ -45151,20 +45397,21 @@ function App2({
     };
   }, [bus, flushUpdates]);
   (0, import_react26.useEffect)(() => {
-    if (autoClearIdleMs <= 0) return;
     const timer = setInterval(() => {
+      const idleMs = resolveIdleAutoClearMinutes(readProfileConfig(info.profileDir)) * 6e4;
+      if (idleMs <= 0) return;
       if (busyRef.current !== null || pendingConfirmRef.current || entriesLenRef.current === 0) return;
-      if (Date.now() - lastActivityRef.current < autoClearIdleMs) return;
+      if (Date.now() - lastActivityRef.current < idleMs) return;
       clearTranscript();
       bus.push({
         source: "system",
         kind: "log",
-        text: `Transcript auto-cleared after ${Math.round(autoClearIdleMs / 6e4)} min idle.`
+        text: `Transcript auto-cleared after ${Math.round(idleMs / 6e4)} min idle.`
       });
       lastActivityRef.current = Date.now();
     }, 6e4);
     return () => clearInterval(timer);
-  }, [autoClearIdleMs, bus, clearTranscript]);
+  }, [info.profileDir, bus, clearTranscript]);
   const frameRows = Math.max(4, rows - 1);
   const bodyHeight = Math.max(3, frameRows - CHROME_ROWS);
   const textWidth = Math.max(10, cols - 1 - 8);
@@ -45207,7 +45454,12 @@ function App2({
       runSlashCommand(trimmed, {
         info,
         print: (text, level) => bus.push({ source: "local", kind: "log", text, level }),
-        clear: clearTranscript,
+        // A manual `/clear` also resets the shared AI memory + native session (ADR-0245); the idle
+        // auto-clear path calls clearTranscript() directly (display-only), so it does NOT reset.
+        clear: () => {
+          clearTranscript();
+          bus.clearSession();
+        },
         quit: () => exit(),
         confirm: (prompt, onYes) => {
           bus.push({ source: "local", kind: "log", text: prompt });
@@ -45285,6 +45537,7 @@ async function runStart(profileDir2, profileName) {
   });
   logger.info("cli.start", { serverUrl: credential.serverUrl });
   ensureProfileConfig(profileDir2);
+  backfillProfileConfig(profileDir2);
   const config = readProfileConfig(profileDir2);
   const autoUpdate = config.autoUpdate !== false && process.env.FOURPM_NO_UPDATE !== "1";
   const result = await checkAndUpdate(credential.serverUrl, autoUpdate);
@@ -45299,7 +45552,7 @@ async function runStart(profileDir2, profileName) {
   if (result.action === "updated") {
     logger.info("update.updated", { version: result.version });
     console.log("Restarting with the new version\u2026");
-    const child = spawn9(process.execPath, process.argv.slice(1), {
+    const child = spawn10(process.execPath, process.argv.slice(1), {
       stdio: "inherit",
       env: { ...process.env, FOURPM_NO_UPDATE: "1" }
     });
@@ -45373,7 +45626,10 @@ async function runStart(profileDir2, profileName) {
       await tui;
     } else {
       attachConsoleSink(bus);
-      stopIdleClear = startIdleAutoClear(bus, config.autoClearIdleMinutes ?? 10);
+      stopIdleClear = startIdleAutoClear(
+        bus,
+        () => resolveIdleAutoClearMinutes(readProfileConfig(profileDir2))
+      );
       bus.log(`Connecting to ${credential.serverUrl} (profile: ${profileName})\u2026`);
       await runResilient();
     }
@@ -45516,12 +45772,12 @@ async function runAttach(profileDir2, profileName) {
 }
 
 // src/commands/ai-login.ts
-import { spawn as spawn10 } from "child_process";
+import { spawn as spawn11 } from "child_process";
 import { mkdirSync as mkdirSync6 } from "fs";
 import { basename as basename5 } from "path";
 function runProviderLogin(cmd, envVar, dir2) {
   return new Promise((resolve8) => {
-    const child = spawn10(cmd, [], {
+    const child = spawn11(cmd, [], {
       stdio: "inherit",
       env: { ...process.env, [envVar]: dir2 }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4pm/cli",
-  "version": "1.4.12",
+  "version": "1.5.0",
   "private": false,
   "description": "4PM CLI — drives Claude/Codex CLIs on AI worker machines (Node + TypeScript)",
   "license": "LicenseRef-4PM-Source-Available",