claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/index.cjs

@@ -42,6 +42,7 @@ const epicWorktreeMint = require('./lib/epicWorktreeMint.cjs');
 const epicWorktreeMerge = require('./lib/epicWorktreeMerge.cjs');
 const epicWorktreeProjectConfig = require('./lib/epicWorktreeProjectConfig.cjs');
 const agentLibrary = require('./agentLibrary.cjs');
+const macroLibrary = require('./lib/macroLibrary.cjs');
 const agentModelResolve = require('./lib/agentModelResolve.cjs');
 const agentEffortResolve = require('./lib/agentEffortResolve.cjs');
 const { resolveEffectiveModelInfo } = require('./lib/effectiveModelInfo.cjs');
@@ -52,7 +53,6 @@ const upgradeDrain = require('./lib/upgradeDrain.cjs');
 const { writeGuardShims } = require('./lib/guardShims.cjs');
 const { MCP_TOOL_CATALOG, MCP_RECIPES } = require('./lib/mcpToolCatalog.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
-const { resolveBuildTarget } = require('./lib/buildTarget.cjs');
 const crossProjectFeedback = require('./lib/crossProjectFeedback.cjs');
 const adminHttp = createAdminHttp();
 scheduler.registerAdminRoutes(adminHttp);
@@ -88,7 +88,6 @@ const memoryTool = require('./memoryTool.cjs');
 const { registerMemoryAggregateIpc } = require('./memoryAggregate.cjs');
 const { registerProjectBriefIpc } = require('./projectBrief.cjs');
 const { registerProjectPagesIpc, attachWindow: attachProjectPagesWindow, closeAllOutputWatchers: closeAllProjectPagesWatchers } = require('./projectPages.cjs');
-const { registerBilkoHostIpc } = require('./bilkoHost.cjs');
 const promptSessionTranscript = require('./promptSessionTranscript.cjs');
 const { computeEpicDelegationStats } = require('./lib/epicDelegationStats.cjs');
 const agentMemory = require('./agentMemory.cjs');
@@ -551,6 +550,28 @@ ipcMain.handle('agents:remove-override', async (_e, payload) => {
   broadcastAgentsChanged();
   return result;
 });
+// Macro library (macroLibrary.cjs): global machine-local one-click sidebar
+// macros (agent + tag + prompt). Store path is fixed in-module; the renderer
+// never supplies it. Mutations broadcast `macros:changed`.
+function broadcastMacrosChanged() {
+  sendIfAlive(mainWindow, 'macros:changed', {});
+}
+ipcMain.handle('macros:list', () => macroLibrary.listMacros());
+ipcMain.handle('macros:save', validated(schemas.macrosSave, async (payload) => {
+  const macro = await macroLibrary.saveMacro(payload);
+  broadcastMacrosChanged();
+  return macro;
+}));
+ipcMain.handle('macros:delete', validated(schemas.macrosDelete, async (payload) => {
+  const result = await macroLibrary.deleteMacro(payload);
+  broadcastMacrosChanged();
+  return result;
+}));
+ipcMain.handle('macros:set-project', validated(schemas.macrosSetProject, async (payload) => {
+  const result = await macroLibrary.setMacroProject(payload);
+  if (result.ok) broadcastMacrosChanged();
+  return result;
+}));
 // New Epic AIM composer (epicIntake.ts's `agentBody`/`agentPath`): unlike
 // list-personas above (global dir only), this honors the project-overlay-
 // then-global precedence so an Epic's opening prompt carries the persona
@@ -877,13 +898,6 @@ ipcMain.handle('app:git-branch', validated(schemas.appGitBranch, async ({ cwd })
   });
 }));
 
-// Resolves a project's publish target for 'build'-tagged Epics — see
-// lib/buildTarget.cjs. Null means the Build toolbar button should be disabled
-// (no explicit config, no auto-discoverable publishable package.json).
-ipcMain.handle('build:resolve-target', validated(schemas.buildResolveTarget, ({ cwd }) => {
-  return resolveBuildTarget(cwd);
-}));
-
 // Containment check for the open-in-{editor,finder,terminal} handlers lives
 // in lib/insideHome.cjs — single chokepoint for the /home/bilkoEVIL prefix-trap.
 // Editor / finder / terminal logic lives in lib/openExternalApp.cjs.
@@ -983,7 +997,6 @@ epicWorktreeProjectConfig.registerEpicWorktreeProjectConfigHandlers();
 registerMemoryAggregateIpc();
 registerProjectBriefIpc();
 registerProjectPagesIpc();
-registerBilkoHostIpc();
 ipcMain.handle('promptSessionTranscript:append', validated(schemas.promptSessionTranscriptAppend, async ({ cwd, epicId, role, text, at, eventId }) => {
   const ok = await promptSessionTranscript.appendTurn(cwd, epicId, { role, text, at, eventId });
   return { ok };

package/src/main/ipcSchemas.cjs

@@ -13,6 +13,7 @@ const { PromptSessionSchema, EpicTagSchema, EpicSourceSchema, EpicIntakeSectionS
 const { PrdWorkTypeSchema } = require('./lib/workTypeLibrary.cjs');
 const { PERSONA_NAME_RE } = require('./agentLibrary.cjs');
 const { AgentPersonaSaveSchema } = require('./lib/agentPersonaSchema.cjs');
+const { MacroSaveSchema, MacroDeleteSchema, MacroSetProjectSchema } = require('./lib/macroLibrary.cjs');
 
 // ──────────────────────────────────────────── PTY
 const ptySpawn = z.object({
@@ -282,6 +283,15 @@ const scheduleSlug = z.object({
   slug: z.string().regex(SCHEDULE_SLUG_RE),
 });
 
+// reset-job: slug + optional cwd — narrows the match to one project's job
+// row so two different projects' slugs that happen to collide (slugs carry
+// no cwd salt) don't cross-reset. Mirrors remote.resetJob's own cwd filter
+// in scheduler.cjs.
+const scheduleResetJob = z.object({
+  slug: z.string().regex(SCHEDULE_SLUG_RE),
+  cwd: z.string().min(1).max(4096).optional(),
+});
+
 const scheduleReadLog = z.object({
   slug: z.string().regex(SCHEDULE_SLUG_RE),
   runId: z.string().regex(SCHEDULE_RUN_ID_RE),
@@ -409,6 +419,17 @@ const schedulerCreatePrd = z.object({
   // invalidate. See prdCreate.cjs's buildPrdBody and schedulerBatch.cjs's
   // pickNextBatch.
   quietMachine: z.boolean().optional(),
+  // Commands that prove this PRD is done (gate-and-files-in-PRD-body unit) —
+  // rendered verbatim as the `# Gate` body section's ```gate fence and read
+  // back by definitionOfDone.cjs's resolveGate/parseChain. ['none'] opts out
+  // for docs/config PRDs with no runnable check. Shape-validated (length,
+  // chars, no-shell, none-is-alone) by prdGateFiles.cjs's validateGate, not
+  // here — this schema only bounds array size and element type.
+  gate: z.array(z.string()).min(1).max(10).optional(),
+  // Repo-relative files/folders this PRD may change — rendered verbatim as
+  // the `# Files` body section. Validated (repo-relative, no .., no globs)
+  // by prdGateFiles.cjs's validateFiles, not here.
+  files: z.array(z.string()).min(1).max(50).optional(),
 });
 
 // Renderer-facing counterpart to adminPrdFrontmatterPatch's dependsOn/
@@ -588,6 +609,9 @@ const setSessionSlotsSchema = z.object({
 // Full field-level rules live in lib/agentPersonaSchema.cjs, mirroring
 // AgentPersonaSaveInput (src/preload/api.d.ts) field-for-field.
 const agentsSavePersona = AgentPersonaSaveSchema;
+const macrosSave = MacroSaveSchema;
+const macrosDelete = MacroDeleteSchema;
+const macrosSetProject = MacroSetProjectSchema;
 
 // ──────────────────────────────────────────── Memory tool (Bundle C, cycle 3)
 // Workspace-scoped markdown store at ~/.claude/projects/<ws>/memory/.
@@ -706,30 +730,6 @@ const projectHomeAdminWriteBody = z.object({
   html: z.string(),
 }).strict();
 
-// ──────────────────────────────────────────── Host on Bilko.run
-// Same validation split: real path validation is config.cjs's validatePath
-// at first fs access in bilkoHost.cjs — these schemas only bound wire shape.
-const bilkoHostCwd = z.object({
-  cwd: z.string().min(1).max(4096),
-}).strict();
-const bilkoHostPrepareBundle = z.object({
-  cwd: z.string().min(1).max(4096),
-  slug: z.string().min(1).max(64).regex(/^[a-z0-9-]+$/, 'slug must be lowercase kebab-case'),
-}).strict();
-const BILKO_HOST_DOCUMENT_SOURCE = z.union([
-  z.object({ kind: z.literal('project-page-lens'), lens: z.enum(['home', 'marketing', 'feature', 'architecture']) }).strict(),
-  z.object({ kind: z.literal('file'), path: z.string().min(1).max(4096) }).strict(),
-]);
-const bilkoHostAddDocument = z.object({
-  cwd: z.string().min(1).max(4096),
-  subpath: z.string().min(1).max(200),
-  title: z.string().min(1).max(200),
-  source: BILKO_HOST_DOCUMENT_SOURCE,
-}).strict();
-const bilkoHostRemoveDocument = z.object({
-  cwd: z.string().min(1).max(4096),
-  id: z.string().min(1).max(200),
-}).strict();
 const projectBriefSetPin = z.object({
   cwd: z.string().min(1).max(4096),
   block: PROJECT_BRIEF_BLOCK,
@@ -993,12 +993,6 @@ const appGitBranch = z.object({
   cwd: z.string().min(1).max(4096),
 }).passthrough();
 
-// build:resolve-target — see src/main/lib/buildTarget.cjs. cwd is a trusted
-// TAB cwd, not validatePath'd here (same invariant as appGitBranch above).
-const buildResolveTarget = z.object({
-  cwd: z.string().min(1).max(4096),
-}).passthrough();
-
 // git:status / git:file-status — see src/main/git.cjs. cwd is validatePath'd
 // inside the handler (allowedRoots = home), so the schema only enforces shape.
 const gitStatus = z.object({
@@ -1100,6 +1094,7 @@ module.exports = {
     sessionsPayload,
     layoutEnvelope,
     scheduleSlug,
+    scheduleResetJob,
     scheduleReadLog,
     scheduleWritePrd,
     schedulerCreatePrd,
@@ -1122,7 +1117,6 @@ module.exports = {
     voiceSetRecording,
     appTestFireHook,
     appGitBranch,
-    buildResolveTarget,
     gitStatus,
     gitFileStatus,
     repoAnalyze,
@@ -1138,10 +1132,6 @@ module.exports = {
     projectBriefCwd,
     projectPagesCwd,
     projectHomeAdminWriteBody,
-    bilkoHostCwd,
-    bilkoHostPrepareBundle,
-    bilkoHostAddDocument,
-    bilkoHostRemoveDocument,
     projectBriefSetPin,
     projectBriefUpdate,
     promptSessionTranscriptAppend,
@@ -1172,6 +1162,9 @@ module.exports = {
     chatExternalSend,
     exchangesList,
     agentsSavePersona,
+    macrosSave,
+    macrosDelete,
+    macrosSetProject,
     agentsGetPersonaBody,
     agentsResolveModelInfo,
     modelsCatalog,

package/src/main/lib/agentPersonaSchema.cjs

@@ -23,7 +23,7 @@
 'use strict';
 
 const { z } = require('zod');
-const { WorkTypeSchema } = require('./workTypeLibrary.cjs');
+const { WorkTypeSchema, LEGACY_WORK_TYPES } = require('./workTypeLibrary.cjs');
 const { PERSONA_NAME_RE, ALL_PROJECTS } = require('../agentLibrary.cjs');
 
 // Bounded free-text fields — generous for legitimate persona authoring while
@@ -53,13 +53,24 @@ const AgentPersonaSaveSchema = z.object({
   model: BoundedString,
   effort: BoundedString.optional(),
   color: BoundedString,
-  tags: z.array(WorkTypeSchema),
+  // A legacy tag value (e.g. the retired 'bilko-host-publisher') must keep
+  // loading on an old on-disk persona — dropped silently, never thrown. Any
+  // other unknown value still fails via WorkTypeSchema.
+  tags: z.preprocess(
+    (v) => (Array.isArray(v) ? v.filter((t) => !(typeof t === 'string' && LEGACY_WORK_TYPES.includes(t))) : v),
+    z.array(WorkTypeSchema),
+  ),
   projects: z.array(ProjectEntrySchema).optional(),
   action: z.string().max(20000).optional(),
   actionLabel: BoundedString.optional(),
   title: BoundedString.optional(),
   // Set = write this project's frontmatter-only override (model/effort only) instead of the global file.
   projectName: BoundedString.optional(),
+  // Bundled-persona version stamp (seedAgentPersonas.cjs). Omit to carry over
+  // the existing file's stamp unchanged — see agentLibrary.cjs's savePersona.
+  // Without this field zod's default "strip unknown keys" behavior would
+  // silently drop it from a save payload that did carry one.
+  seedVersion: z.number().int().optional(),
   // Unbounded — a persona's body is arbitrary system-prompt prose.
   body: z.string(),
 });

package/src/main/lib/atomicFs.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+/**
+ * atomicFs.cjs — canonical tmp+rename file-IO primitives, extracted out of
+ * config.cjs so non-Electron modules (lib/*.cjs) can reuse the exact same
+ * atomic-write recipe without importing config.cjs's electron-adjacent
+ * validation layer. NO electron import here, intentionally — this module is
+ * pure Node and must stay requirable from any process.
+ *
+ * Recipe (unchanged from the original config.cjs copies this consolidates):
+ * write to `<file>.tmp-<pid>-<ts>-<rand>` in the SAME directory, then rename
+ * over the real path. mkdir -p the parent first. On write/rename failure,
+ * best-effort unlink the tmp file before rethrowing.
+ */
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+
+function tmpPathFor(file) {
+  return `${file}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+/**
+ * opts.mode: optional POSIX permission bits applied to the tmp file before
+ * rename (chmod'd explicitly too — some platforms ignore the mode arg on
+ * writeFile when the file pre-exists).
+ * opts.fsync: fsync the tmp file's fd before rename (durability for callers
+ * that need the write to survive a crash immediately after it returns).
+ */
+async function writeTextAtomic(file, text, opts = {}) {
+  const dir = path.dirname(file);
+  await fsp.mkdir(dir, { recursive: true });
+  const tmp = tmpPathFor(file);
+  try {
+    const handle = await fsp.open(tmp, 'w', opts.mode);
+    try {
+      await handle.writeFile(text, 'utf8');
+      if (opts.mode) {
+        try { await handle.chmod(opts.mode); } catch { /* umask may have already applied it */ }
+      }
+      if (opts.fsync) await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await fsp.rename(tmp, file);
+  } catch (e) {
+    try { await fsp.unlink(tmp); } catch { /* tmp never created or already gone */ }
+    throw e;
+  }
+}
+
+function writeTextAtomicSync(file, text, opts = {}) {
+  const dir = path.dirname(file);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = tmpPathFor(file);
+  try {
+    const fd = fs.openSync(tmp, 'w', opts.mode);
+    try {
+      fs.writeSync(fd, text, null, 'utf8');
+      if (opts.mode) {
+        try { fs.chmodSync(tmp, opts.mode); } catch { /* umask may have already applied it */ }
+      }
+      if (opts.fsync) fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch { /* tmp never created or already gone */ }
+    throw e;
+  }
+}
+
+function serializeJson(obj, { space = 2, newline = true } = {}) {
+  const json = JSON.stringify(obj, null, space);
+  return newline ? `${json}\n` : json;
+}
+
+async function writeJsonAtomic(file, obj, opts = {}) {
+  await writeTextAtomic(file, serializeJson(obj, opts), opts);
+}
+
+function writeJsonAtomicSync(file, obj, opts = {}) {
+  writeTextAtomicSync(file, serializeJson(obj, opts), opts);
+}
+
+async function readJsonOr(file, fallback) {
+  try {
+    const raw = await fsp.readFile(file, 'utf8');
+    if (raw.trim() === '') return fallback;
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+function readJsonOrSync(file, fallback) {
+  try {
+    const raw = fs.readFileSync(file, 'utf8');
+    if (raw.trim() === '') return fallback;
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+module.exports = {
+  tmpPathFor,
+  writeTextAtomic,
+  writeTextAtomicSync,
+  writeJsonAtomic,
+  writeJsonAtomicSync,
+  readJsonOr,
+  readJsonOrSync,
+};

package/src/main/lib/branchSweep.cjs

@@ -19,20 +19,13 @@
  */
 'use strict';
 
-const { execFile } = require('node:child_process');
 const gitWorktree = require('./gitWorktree.cjs');
+const { execGit: sharedExecGit } = require('./gitExec.cjs');
 
+// Thin re-shape over the shared gitExec.execGit — kept so call sites below
+// (positional `timeout`, no `-C` prefix needed) don't all need touching.
 function execGit(cwd, args, timeout = 20_000) {
-  return new Promise((resolve, reject) => {
-    execFile('git', ['-C', cwd, ...args], { timeout, windowsHide: true, encoding: 'utf8' }, (err, stdout, stderr) => {
-      if (err) {
-        err.stderrText = stderr;
-        reject(err);
-        return;
-      }
-      resolve(stdout || '');
-    });
-  });
+  return sharedExecGit(cwd, args, { timeout });
 }
 
 /** List every local branch under `refs/heads/sm-job/*`. Never throws. */
@@ -114,7 +107,15 @@ async function sweepStrandedJobBranches({ cwd, jobs, attemptedBranches }) {
       continue;
     }
     attempted.add(attemptKey);
-    const integration = await gitWorktree.integrateJobBranch({ cwd, branch, slug: slug || branch });
+    // baseBranch: read off the job row when one still exists (the crash-between-
+    // commit-and-integrate case this sweep exists for) so integration targets the
+    // SAME branch the checkout was actually on when the worktree was created —
+    // not whatever cwd happens to sit on during this sweep pass. A fully orphaned
+    // branch (no row at all) has nothing to read, so it falls back to
+    // resolveDefaultBranch(cwd), same as before.
+    const integration = await gitWorktree.integrateJobBranch({
+      cwd, branch, slug: slug || branch, baseBranch: (row && row.worktreeBaseBranch) || null,
+    });
     results.push({ branch, slug, action: integration.ok ? 'integrated' : 'conflict', integration });
   }
   return { results };

package/src/main/lib/buildTarget.cjs

@@ -21,9 +21,9 @@
  * daemon whose "release" is bump VERSION, write the changelog, tag, and flag
  * that the live server needs a restart. That requires reading CLAUDE.md and
  * git history and exercising judgment, so discovery lives in the agent: a
- * `null` here means **not configured yet**, and the UI turns it into a
- * "Set Up Build" bootstrap session (`src/renderer/lib/buildAction.ts`) that
- * probes the project and writes the config, rather than a disabled button.
+ * `null` here means **not configured yet**; the builder skill probes the
+ * project and writes the config. No IPC or UI calls this resolver today;
+ * builds start from a user-created Macro (e.g. agent `builder`, tag `build`).
  */
 'use strict';
 

package/src/main/lib/claudeCliCaps.cjs

@@ -0,0 +1,129 @@
+'use strict';
+
+/**
+ * claudeCliCaps.cjs — probes the installed `claude` CLI for
+ * `--permission-prompts` support once per process, caches the result.
+ *
+ * Headless spawns (scheduler/supervisor/docEdit/runClaudeP) have no human
+ * attached, so a tool that waits on AskUserQuestion or a permission prompt
+ * would stall the job forever. `--permission-prompts none` (CLI v2.1.285+)
+ * auto-denies those prompts and removes human-requiring tools. Older CLIs
+ * don't recognize the flag, so it's only appended when `claude --help`
+ * confirms support.
+ *
+ * Only a SUCCESSFUL probe (a real supported/unsupported determination from
+ * actual `--help` text) is cached for the rest of the process — an error
+ * (ENOENT, timeout, a throw) is never cached: this call returns [] (the safe
+ * default: omit the flag) but a LATER call re-probes, subject to a
+ * once-per-60s backoff so a persistently broken binary doesn't turn every
+ * headless spawn attempt into a fresh probe.
+ *
+ * The probe spawns the SAME binary/spawn target every real headless spawn
+ * site uses — `claudeSpawnTarget('aux', ...)` from claudeBin.cjs — not a raw
+ * `resolveClaudeBin()` result, so what gets probed is provably what later
+ * gets spawned (aliasing/argv0 labeling included).
+ */
+
+const claudeBinLib = require('./claudeBin.cjs');
+
+const PROBE_TIMEOUT_MS = 10_000;
+const FLAG_ARGS = ['--permission-prompts', 'none'];
+const DEFAULT_REPROBE_AFTER_ERROR_MS = 60_000;
+
+let _execFile = require('node:child_process').execFile;
+
+/** Test hook — inject a stub execFile(file, args, opts, cb) instead of spawning the real CLI. */
+function _setExecFileForTest(fn) {
+  _execFile = fn || require('node:child_process').execFile;
+}
+
+/** Test hook — forget the cached probe result and any error backoff so the next call re-probes immediately. */
+function _resetForTest() {
+  cachedArgs = null;
+  inflight = null;
+  lastErrorAt = 0;
+  reprobeAfterErrorMs = DEFAULT_REPROBE_AFTER_ERROR_MS;
+}
+
+/** Test hook — shrink the once-per-60s error backoff so a re-probe-after-error test doesn't need to sleep 60s. */
+function _setReprobeBackoffMsForTest(ms) {
+  reprobeAfterErrorMs = typeof ms === 'number' && ms >= 0 ? ms : DEFAULT_REPROBE_AFTER_ERROR_MS;
+}
+
+let cachedArgs = null; // set ONLY by a successful probe — never by an error path
+let inflight = null;
+let lastErrorAt = 0;
+let reprobeAfterErrorMs = DEFAULT_REPROBE_AFTER_ERROR_MS;
+
+/**
+ * Probes `claude --help` once per process (successful result only); every
+ * call (including concurrent/later ones) resolves the same cached arg array
+ * once a successful probe has landed. A probe error is never cached — this
+ * call still resolves [] for the caller, but the NEXT call re-probes for
+ * real once `reprobeAfterErrorMs` has elapsed since the last error.
+ */
+function ensureCliCapsProbed() {
+  if (cachedArgs) return Promise.resolve(cachedArgs);
+  if (inflight) return inflight;
+  if (lastErrorAt && Date.now() - lastErrorAt < reprobeAfterErrorMs) {
+    return Promise.resolve([]);
+  }
+
+  let bin;
+  try { bin = claudeBinLib.resolveClaudeBin(); } catch { bin = 'claude'; }
+  let target;
+  try { target = claudeBinLib.claudeSpawnTarget('aux', 'cli-caps-probe', bin); } catch { target = { command: bin }; }
+
+  // NOTE: `inflight` is cleared via `.finally()` below, never directly
+  // inside this executor. A real `execFile` callback is always async, but a
+  // TEST stub firing its callback synchronously would otherwise run
+  // `succeed`/`fail` (and their `inflight = null`) to completion BEFORE the
+  // `inflight = promise` assignment two lines down ever runs — leaving
+  // `inflight` wedged at a stale, already-settled promise forever, so this
+  // function would never re-probe again regardless of the cache/backoff
+  // state. `.finally()` callbacks always run as a microtask, strictly after
+  // the synchronous assignment below, so this ordering hazard can't recur.
+  const promise = new Promise((resolve) => {
+    const succeed = (args) => {
+      cachedArgs = args;
+      resolve(args);
+    };
+    const fail = () => {
+      lastErrorAt = Date.now();
+      resolve([]);
+    };
+    try {
+      const execOpts = { timeout: PROBE_TIMEOUT_MS, windowsHide: true };
+      if (target.argv0) execOpts.argv0 = target.argv0;
+      _execFile(target.command, ['--help'], execOpts, (err, stdout) => {
+        if (err) {
+          console.warn('[claudeCliCaps] claude --help probe failed; headless spawns will omit --permission-prompts:', err?.message || err);
+          fail();
+          return;
+        }
+        succeed(String(stdout || '').includes('--permission-prompts') ? FLAG_ARGS.slice() : []);
+      });
+    } catch (e) {
+      console.warn('[claudeCliCaps] claude --help probe threw; headless spawns will omit --permission-prompts:', e?.message || e);
+      fail();
+    }
+  });
+  inflight = promise;
+  promise.finally(() => {
+    if (inflight === promise) inflight = null;
+  });
+  return promise;
+}
+
+/** Sync accessor for the cached probe result — [] until ensureCliCapsProbed() has resolved successfully at least once. */
+function headlessPermissionArgs() {
+  return cachedArgs ? cachedArgs.slice() : [];
+}
+
+module.exports = {
+  headlessPermissionArgs,
+  ensureCliCapsProbed,
+  _setExecFileForTest,
+  _resetForTest,
+  _setReprobeBackoffMsForTest,
+};

package/src/main/lib/credentials.cjs

@@ -6,6 +6,7 @@ const path = require('node:path');
 const os = require('node:os');
 const { spawn, execFileSync } = require('node:child_process');
 const { cleanChildEnv, pathWithUserBins } = require('./cleanEnv.cjs');
+const atomicFs = require('./atomicFs.cjs');
 const { resolveClaudeBin, claudeSpawnTarget } = require('./claudeBin.cjs');
 
 const CREDS_PATH = path.join(os.homedir(), '.claude', '.credentials.json');
@@ -160,10 +161,7 @@ async function writeCredentials(rawData, freshOauth, source = 'file') {
     writeKeychainRaw(JSON.stringify(next));
     return;
   }
-  const tmp = `${CREDS_PATH}.${process.pid}.${Date.now()}.tmp`;
-  await fsp.writeFile(tmp, JSON.stringify(next, null, 2), { encoding: 'utf8', mode: 0o600 });
-  try { await fsp.chmod(tmp, 0o600); } catch { /* umask may have already set it */ }
-  await fsp.rename(tmp, CREDS_PATH);
+  await atomicFs.writeJsonAtomic(CREDS_PATH, next, { mode: 0o600, newline: false });
 }
 
 function appendRefreshLog(entry) {

package/src/main/lib/crossProjectFeedback.cjs

@@ -69,9 +69,9 @@ const { OPS_ROOT_DIR } = require('./opsOwnership.cjs');
 const { resolveProjectContext } = require('./projectRootResolve.cjs');
 
 /** Only these three Epic tags make sense for an inbound report — they are
- *  exactly the tags that route through /develop (tagLibrary.ts). 'build',
- *  'project-home-builder' and 'bilko-host-publisher' name dedicated local
- *  pipelines and are meaningless as a request from another project. */
+ *  exactly the tags that route through /develop (tagLibrary.ts). 'build' and
+ *  'project-home-builder' name dedicated local pipelines and are meaningless
+ *  as a request from another project. */
 const FEEDBACK_TAGS = Object.freeze(['bug', 'feature', 'discussion']);
 const DEFAULT_FEEDBACK_TAG = 'discussion';
 

package/src/main/lib/cwdClassify.cjs

@@ -115,7 +115,9 @@ function inspectGit(start) {
   } catch {
     return { shape: 'unknown', dir: entry.dir, mainRoot: null, reason: `worktree admin back-reference missing (${adminGitdirFile})` };
   }
-  if (path.resolve(backRef) !== path.resolve(gitPath)) {
+  // git records realpaths, so compare canonical spellings (macOS /var -> /private/var).
+  const canon = (q) => { try { return fs.realpathSync(q); } catch { return path.resolve(q); } };
+  if (path.resolve(backRef) !== path.resolve(gitPath) && canon(backRef) !== canon(gitPath)) {
     return { shape: 'unknown', dir: entry.dir, mainRoot: null, reason: `worktree admin back-reference points elsewhere (${adminGitdirFile})` };
   }
   return { shape: 'worktree', dir: entry.dir, mainRoot: candidateMain, reason: 'linked worktree, back-reference verified' };
@@ -133,12 +135,22 @@ function worktreeMainRootOf(cwd) {
   return null;
 }
 
+// A root may be a symlink (macOS os.tmpdir() is /var -> /private/var) while callers hand us
+// either spelling (config.validatePath returns realpaths). Match on both the raw and the
+// canonical spelling of the root.
+function rootSpellings(root) {
+  const abs = path.resolve(root);
+  let real = abs;
+  try { real = fs.realpathSync(abs); } catch { /* root not created yet — raw spelling only */ }
+  return real === abs ? [abs] : [abs, real];
+}
+
 function isExactlyTmpdir(absCwd) {
-  return absCwd === path.resolve(os.tmpdir());
+  return rootSpellings(os.tmpdir()).includes(absCwd);
 }
 
 function isUnderManagedWorktreeRoot(absCwd) {
-  return ['job', 'epic'].map((k) => path.resolve(schedulerPaths.worktreeRoot(k))).some((root) => {
+  return ['job', 'epic'].flatMap((k) => rootSpellings(schedulerPaths.worktreeRoot(k))).some((root) => {
     const rel = path.relative(root, absCwd);
     return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
   });