claude-code-session-manager 0.119.1 → 0.121.0

package/src/main/lib/git/worktreeDeps.cjs

@@ -9,12 +9,40 @@
  * `info/exclude` as `/<name>` — otherwise the link shows as untracked and the
  * job parks as `uncommitted_changes`.
  *
+ * pnpm projects are the exception for node_modules: `pnpm install` purges and
+ * rebuilds the modules dir THROUGH a symlink, wiping the main checkout's
+ * node_modules. So a pnpm worktree gets its own node_modules, installed
+ * offline from the shared store (`installed`); the main checkout is never
+ * touched. `node_modules/` (any depth) is excluded so nested workspace
+ * node_modules stay untracked.
+ *
+ * Relative `file:`/`link:` deps that point OUTSIDE the repo (e.g.
+ * `file:../Bilko/packages/host-kit`) cannot resolve from a worktree, which lives
+ * under the session-manager state dir rather than next to the sibling repo — the
+ * offline install would ENOENT and leave no node_modules. So before installing,
+ * `linkOutOfRepoLocalDeps` creates a symlink at the equivalent location relative
+ * to the worktree (first path segment past the `..` hops, e.g.
+ * `<worktrees>/<hash>/Bilko -> ~/Projects/Bilko`). That link may therefore sit
+ * OUTSIDE the worktree; it is only created where nothing exists, never inside
+ * the main checkout, and never overwrites anything.
+ *
+ * uv projects (`uv.lock`) are the exception for .venv/venv: `uv run` and
+ * `uv sync` re-sync the project env, and for an editable project install that
+ * rewrites site-packages/<pkg>.pth to the CURRENT tree's src. Through a shared
+ * symlink that silently repoints the main checkout's imports at the worktree
+ * (social-signals-trader, 2026-10-18), and worktree tests import whichever
+ * tree synced last. So a uv worktree gets its own env, built by an offline
+ * frozen `uv sync` (hardlinks from uv's cache — cheap); the main env is never
+ * linked. If that sync fails the name is skipped and the executor's own `uv`
+ * call builds a worktree-local env — never the main one.
+ *
  * Never throws; failures land in `skipped`.
  */
 'use strict';
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { execFile } = require('node:child_process');
 const { execGit } = require('./gitExec.cjs');
 
 const DEFAULT_DEP_DIRS = ['node_modules', '.venv', 'venv'];
@@ -34,27 +62,141 @@ async function isIgnored(cwd, name) {
   } catch { return false; }
 }
 
-async function addExcludes(mainCwd, names) {
+/** True when mainCwd is a pnpm project (lockfile or pnpm modules manifest). Never throws. */
+function isPnpmProject(mainCwd) {
+  try {
+    return fs.existsSync(path.join(mainCwd, 'pnpm-lock.yaml'))
+      || fs.existsSync(path.join(mainCwd, 'node_modules', '.modules.yaml'));
+  } catch { return false; }
+}
+
+/** True when mainCwd is a uv project (uv.lock). Never throws. */
+function isUvProject(mainCwd) {
+  try { return fs.existsSync(path.join(mainCwd, 'uv.lock')); } catch { return false; }
+}
+
+/** Offline frozen `uv sync` into worktreeCwd/<name>. Resolves true on exit 0; never throws. */
+function installUvEnv(worktreeCwd, name) {
+  return new Promise((resolve) => {
+    try {
+      const env = { ...process.env, UV_PROJECT_ENVIRONMENT: path.join(worktreeCwd, name) };
+      delete env.VIRTUAL_ENV;
+      execFile(
+        'uv',
+        ['sync', '--frozen', '--offline'],
+        { cwd: worktreeCwd, env, timeout: 180_000, maxBuffer: 16 * 1024 * 1024 },
+        (err) => resolve(!err),
+      );
+    } catch { resolve(false); }
+  });
+}
+
+/** Top-level importer dirs from pnpm-lock.yaml (`.` is the root). Simple line scan; never throws. */
+function lockImporters(cwd) {
+  const out = ['.'];
+  try {
+    let inImporters = false;
+    for (const line of fs.readFileSync(path.join(cwd, 'pnpm-lock.yaml'), 'utf8').split('\n')) {
+      if (/^importers:\s*$/.test(line)) { inImporters = true; continue; }
+      if (!inImporters) continue;
+      if (/^\S/.test(line)) break;
+      const m = /^ {2}(\S[^:]*):\s*$/.exec(line);
+      if (m) out.push(m[1].replace(/^(['"])(.*)\1$/, '$2'));
+    }
+  } catch { /* no lockfile */ }
+  return [...new Set(out)];
+}
+
+/** Relative file:/link: specifiers of a package.json. Never throws. */
+function localSpecs(pkgJson) {
+  const specs = [];
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgJson, 'utf8'));
+    for (const f of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+      for (const v of Object.values(pkg[f] || {})) {
+        const m = typeof v === 'string' && /^(?:file|link):(.+)$/.exec(v);
+        if (m && !path.isAbsolute(m[1])) specs.push(m[1]);
+      }
+    }
+  } catch { /* unreadable */ }
+  return specs;
+}
+
+const within = (parent, p) => p === parent || p.startsWith(parent + path.sep);
+
+/**
+ * Best-effort: link out-of-repo relative file:/link: dep targets at their
+ * worktree-relative location so the offline install can resolve them. Never throws.
+ */
+function linkOutOfRepoLocalDeps(mainCwd, worktreeCwd) {
+  try {
+    for (const importer of lockImporters(worktreeCwd)) {
+      const mainDir = path.resolve(mainCwd, importer);
+      const wtDir = path.resolve(worktreeCwd, importer);
+      for (const spec of localSpecs(path.join(mainDir, 'package.json'))) {
+        try {
+          const target = path.resolve(mainDir, spec);
+          if (within(mainCwd, target) || !exists(target)) continue;
+          const segs = path.normalize(spec).split(path.sep).filter((x) => x && x !== '.');
+          let ups = 0;
+          while (segs[ups] === '..') ups++;
+          const rest = segs.slice(ups);
+          if (!rest.length) continue;
+          // Link the first segment past the `..` hops, to the matching target ancestor.
+          let wtBase = wtDir;
+          for (let i = 0; i < ups; i++) wtBase = path.dirname(wtBase);
+          const linkPath = path.join(wtBase, rest[0]);
+          let linkTarget = target;
+          for (let i = 1; i < rest.length; i++) linkTarget = path.dirname(linkTarget);
+          if (within(mainCwd, linkPath) || within(worktreeCwd, linkPath) || exists(linkPath)) continue;
+          fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+          fs.symlinkSync(linkTarget, linkPath, isDir(linkTarget) ? 'dir' : 'file');
+        } catch { /* best-effort per dep */ }
+      }
+    }
+  } catch { /* best-effort */ }
+}
+
+/** Offline frozen install in the worktree. Resolves true on exit 0; never throws. */
+function installPnpmModules(worktreeCwd) {
+  return new Promise((resolve) => {
+    try {
+      execFile(
+        'pnpm',
+        ['install', '--offline', '--frozen-lockfile', '--config.confirmModulesPurge=false'],
+        { cwd: worktreeCwd, env: { ...process.env, CI: '1' }, timeout: 180_000, maxBuffer: 16 * 1024 * 1024 },
+        (err) => resolve(!err),
+      );
+    } catch { resolve(false); }
+  });
+}
+
+async function addExcludeLines(mainCwd, lines) {
   const out = (await execGit(mainCwd, ['rev-parse', '--git-common-dir'], { timeout: 10_000 })).trim();
   const commonDir = path.resolve(mainCwd, out);
   const file = path.join(commonDir, 'info', 'exclude');
   let existing = '';
   try { existing = fs.readFileSync(file, 'utf8'); } catch { /* absent */ }
   const have = new Set(existing.split('\n').map((l) => l.trim()));
-  const missing = names.map((n) => `/${n}`).filter((l) => !have.has(l));
+  const missing = lines.filter((l) => !have.has(l));
   if (!missing.length) return;
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const sep = existing && !existing.endsWith('\n') ? '\n' : '';
   fs.appendFileSync(file, `${sep}${missing.join('\n')}\n`);
 }
 
+function addExcludes(mainCwd, names) {
+  return addExcludeLines(mainCwd, names.map((n) => `/${n}`));
+}
+
 /**
  * @param {{ mainCwd: string, worktreeCwd: string, names?: string[] }} opts
- * @returns {Promise<{ linked: string[], skipped: string[] }>}
+ * @returns {Promise<{ linked: string[], skipped: string[], installed: string[] }>}
  */
 async function linkDependencyDirs({ mainCwd, worktreeCwd, names = DEFAULT_DEP_DIRS }) {
   const linked = [];
   const skipped = [];
+  const installed = [];
   for (const name of names) {
     try {
       const src = path.join(mainCwd, name);
@@ -63,6 +205,17 @@ async function linkDependencyDirs({ mainCwd, worktreeCwd, names = DEFAULT_DEP_DI
         skipped.push(name);
         continue;
       }
+      if (name === 'node_modules' && isPnpmProject(mainCwd)) {
+        await addExcludeLines(mainCwd, ['node_modules/']);
+        linkOutOfRepoLocalDeps(mainCwd, worktreeCwd);
+        (await installPnpmModules(worktreeCwd) ? installed : skipped).push(name);
+        continue;
+      }
+      if ((name === '.venv' || name === 'venv') && isUvProject(mainCwd)) {
+        await addExcludes(mainCwd, [name]);
+        (await installUvEnv(worktreeCwd, name) ? installed : skipped).push(name);
+        continue;
+      }
       // Exclude first: a link without its exclude line would dirty status.
       await addExcludes(mainCwd, [name]);
       fs.symlinkSync(src, dest, 'dir');
@@ -71,7 +224,7 @@ async function linkDependencyDirs({ mainCwd, worktreeCwd, names = DEFAULT_DEP_DI
       skipped.push(name);
     }
   }
-  return { linked, skipped };
+  return { linked, skipped, installed };
 }
 
-module.exports = { linkDependencyDirs, DEFAULT_DEP_DIRS };
+module.exports = { linkDependencyDirs, isPnpmProject, isUvProject, DEFAULT_DEP_DIRS };

package/src/main/lib/machineProfile.cjs

@@ -117,6 +117,8 @@ async function buildMachineProfile(opts = {}) {
   let appPath = null;
   if (electronApp) {
     try { appVersion = electronApp.getVersion(); } catch { /* not ready / not a real app object */ }
+    // Unpackaged launch with a script path makes getVersion() return Electron's own version.
+    if (appVersion && process.versions && appVersion === process.versions.electron) appVersion = null;
     try { appPath = electronApp.getAppPath(); } catch { /* not ready / not a real app object */ }
   }
   if (!appVersion) appVersion = resolvePackageVersion();

package/src/main/lib/mcpToolCatalog.cjs

@@ -193,7 +193,9 @@ const MCP_TOOL_CATALOG = [
     purpose: "THE ONLY SUPPORTED WAY to cancel a not-yet-terminal scheduler job via the session-manager app's admin "
       + 'API. A running job is SIGTERM\'d; a pending job is simply retired. There is no "cancelled" job status, so a '
       + 'cancelled job lands as "failed" with an error naming the cause. Refuses a slug whose job is already terminal '
-      + '(completed/failed/needs_review) — nothing to cancel.',
+      + '(completed/failed/needs_review) — nothing to cancel. A cancelled running job\'s commits are never landed on '
+      + 'the base branch; they stay on the job branch, reported in the result as landed:false plus '
+      + 'jobBranch/jobBranchSha.',
     whenToUse: 'Use to stop a running or pending job that should not continue (e.g. it was queued in error, or scope changed underneath it).',
     whenNotToUse: 'Do not use on an already-terminal job (completed/failed/needs_review) — use scheduler_reset_job if it should run again.',
     exampleArgs: { slug: 'add-mcp-tool-catalog' },

package/src/main/lib/opsRetentionSettings.cjs

@@ -0,0 +1,183 @@
+/**
+ * opsRetentionSettings — machine-level retention policy for the ops sweeps.
+ *
+ * Storage: ~/.claude/session-manager/ops-retention.json
+ * Shape (DEFAULTS): { runLogs:{maxAgeDays,keepPerSlug}, runsArchiveDays, auditLogMonths,
+ *   reservedMarkersKeep }
+ * Archived transcripts are kept forever (fixed policy, not a setting).
+ *
+ * Top-level in lib/ (no domain fits: read by scheduler, telemetry and epic sweeps alike).
+ * preview() runs the sweeps' own eligibility code in dry-run mode — it deletes nothing.
+ * Modelled on updaterSettings.cjs: frozen DEFAULTS, never-throwing read, strict write.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const atomicFs = require('./util/atomicFs.cjs');
+
+const DEFAULTS = Object.freeze({
+  runLogs: Object.freeze({ maxAgeDays: 14, keepPerSlug: 3 }),
+  runsArchiveDays: 30,
+  auditLogMonths: 6,
+  reservedMarkersKeep: 100,
+});
+
+// [min, max] per integer field; out-of-range values clamp, non-integers round.
+const BOUNDS = Object.freeze({
+  'runLogs.maxAgeDays': [3, 3650],
+  'runLogs.keepPerSlug': [1, 1000],
+  runsArchiveDays: [1, 3650],
+  auditLogMonths: [1, 120],
+  reservedMarkersKeep: [1, 100000],
+});
+
+function storePath() {
+  return path.join(require('./scheduler/schedulerPaths.cjs').claudeHome(), 'session-manager', 'ops-retention.json');
+}
+
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+
+function clamp(key, v) {
+  const [min, max] = BOUNDS[key];
+  return Math.min(max, Math.max(min, Math.round(v)));
+}
+
+/**
+ * Strict patch validation (used by write() and the IPC set handler). Returns a
+ * partial settings object with clamped integers; throws on unknown keys,
+ * or wrong types.
+ */
+function validatePatch(patch) {
+  if (!isObj(patch)) throw new Error('Invalid ops retention config');
+  const out = {};
+  const num = (key, v) => {
+    if (typeof v !== 'number' || !Number.isFinite(v)) throw new Error(`Invalid ops retention config: ${key}`);
+    return clamp(key, v);
+  };
+  for (const [k, v] of Object.entries(patch)) {
+    if (k === 'runLogs') {
+      if (!isObj(v)) throw new Error('Invalid ops retention config: runLogs');
+      out.runLogs = {};
+      for (const [rk, rv] of Object.entries(v)) {
+        if (rk !== 'maxAgeDays' && rk !== 'keepPerSlug') throw new Error(`Invalid ops retention config: runLogs.${rk}`);
+        out.runLogs[rk] = num(`runLogs.${rk}`, rv);
+      }
+    } else if (k === 'runsArchiveDays' || k === 'auditLogMonths' || k === 'reservedMarkersKeep') {
+      out[k] = num(k, v);
+    } else {
+      throw new Error(`Invalid ops retention config: unknown key ${k}`);
+    }
+  }
+  return out;
+}
+
+/** Lenient field-by-field sanitize of on-disk data: bad fields are dropped, not fatal. */
+function sanitizeStored(data) {
+  if (!isObj(data)) return null;
+  const out = {};
+  const int = (key, v) => (typeof v === 'number' && Number.isFinite(v) ? clamp(key, v) : undefined);
+  if (isObj(data.runLogs)) {
+    const m = int('runLogs.maxAgeDays', data.runLogs.maxAgeDays);
+    const k = int('runLogs.keepPerSlug', data.runLogs.keepPerSlug);
+    if (m !== undefined || k !== undefined) {
+      out.runLogs = {
+        maxAgeDays: m !== undefined ? m : DEFAULTS.runLogs.maxAgeDays,
+        keepPerSlug: k !== undefined ? k : DEFAULTS.runLogs.keepPerSlug,
+      };
+    }
+  }
+  for (const key of ['runsArchiveDays', 'auditLogMonths', 'reservedMarkersKeep']) {
+    const v = int(key, data[key]);
+    if (v !== undefined) out[key] = v;
+  }
+  return out;
+}
+
+/** What is explicitly stored (sanitized), or null when absent/corrupt. Never throws. */
+function readStored() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(storePath(), 'utf8'));
+    return sanitizeStored(raw);
+  } catch (e) {
+    if (e.code !== 'ENOENT') console.warn('[opsRetentionSettings] read failed:', e.message);
+    return null;
+  }
+}
+
+function withDefaults(stored) {
+  const s = stored || {};
+  return {
+    runLogs: { ...DEFAULTS.runLogs, ...(s.runLogs || {}) },
+    runsArchiveDays: s.runsArchiveDays ?? DEFAULTS.runsArchiveDays,
+    auditLogMonths: s.auditLogMonths ?? DEFAULTS.auditLogMonths,
+    reservedMarkersKeep: s.reservedMarkersKeep ?? DEFAULTS.reservedMarkersKeep,
+  };
+}
+
+/** Effective settings. Never throws: missing/corrupt file yields DEFAULTS. */
+function read() {
+  return withDefaults(readStored());
+}
+
+/** Validate + merge `patch` over the current settings and persist the full object. */
+function write(patch) {
+  const valid = validatePatch(patch);
+  const cur = read();
+  const next = {
+    ...cur,
+    ...valid,
+    runLogs: { ...cur.runLogs, ...(valid.runLogs || {}) },
+  };
+  atomicFs.writeJsonAtomicSync(storePath(), next, { mode: 0o600 });
+  return next;
+}
+
+/**
+ * Dry-run report of what each policy would free, via the sweeps' own
+ * eligibility code. Read-only. opts: { now, runsDir, plansRoot, jobs, liveKeys }.
+ */
+function preview(opts) {
+  const o = opts || {};
+  const schedulerPaths = require('./scheduler/schedulerPaths.cjs');
+  const runLogRetention = require('./scheduler/runLogRetention.cjs');
+  const staleTmpSweep = require('./scheduler/staleTmpSweep.cjs');
+  const s = read();
+  const now = typeof o.now === 'number' ? o.now : Date.now();
+  const runsDir = o.runsDir || schedulerPaths.runsDir();
+  const plansRoot = o.plansRoot || schedulerPaths.scheduledPlansRoot();
+
+  let liveKeys = o.liveKeys;
+  if (!liveKeys) {
+    let jobs = o.jobs;
+    if (!jobs) {
+      try {
+        jobs = require('./scheduler/queueStore.cjs').readMergedSync().jobs || [];
+      } catch {
+        jobs = [];
+      }
+    }
+    liveKeys = runLogRetention.liveKeysFromJobs(jobs, { runsDir });
+  }
+  const report = runLogRetention.computeReport(runsDir, { ...s.runLogs }, { now, liveKeys });
+  const archive = staleTmpSweep.pruneRunsArchive(path.join(plansRoot, 'runs-archive'), {
+    maxAgeDays: s.runsArchiveDays,
+    now,
+    dryRun: true,
+  });
+  const tmp = staleTmpSweep.sweepStaleTmp(plansRoot, { now, dryRun: true });
+  return {
+    runLogs: { files: report.eligible.reduce((n, e) => n + e.removeFiles.length, 0) + report.dodFiles.length, bytes: report.eligibleSummary.bytes },
+    runsArchive: { entries: archive.removedFiles, bytes: archive.freedBytes },
+    tmp: { files: tmp.removedFiles, bytes: tmp.freedBytes },
+  };
+}
+
+function registerIpc(ipcMain) {
+  ipcMain.handle('opsRetention:get', () => read());
+  ipcMain.handle('opsRetention:set', (_e, patch) => write(patch));
+  ipcMain.handle('opsRetention:preview', () => preview());
+}
+
+module.exports = { storePath, read, readStored, write, validatePatch, preview, registerIpc, DEFAULTS, BOUNDS };

package/src/main/lib/persona-macro/macroLibrary.cjs

@@ -93,6 +93,61 @@ function refineInputs(value, ctx) {
   }
 }
 
+/** Distinct `{{name}}` placeholder names in first-seen order. */
+function macroPlaceholders(prompt) {
+  const names = [];
+  for (const m of String(prompt).matchAll(new RegExp(MACRO_PLACEHOLDER_RE.source, 'g'))) {
+    if (!names.includes(m[1])) names.push(m[1]);
+  }
+  return names;
+}
+
+/** `{ [name]: default ?? '' }` for every declared input. */
+function defaultMacroValues(inputs) {
+  const out = {};
+  for (const i of inputs || []) out[i.name] = i.default ?? '';
+  return out;
+}
+
+function sanitizeMacroValue(v) {
+  // eslint-disable-next-line no-control-regex
+  return v.replace(/[\r\n\t]+/g, ' ').replace(/[\u0000-\u001f\u007f]/g, '').trim();
+}
+
+const MACRO_PROMPT_RENDERED_MAX_LEN = 8000;
+
+/**
+ * Mirrors `src/renderer/lib/macroPrompt.ts` renderMacroPrompt, but strict for macros
+ * without inputs: a placeholder with no declared input is always an error.
+ * @returns {{ ok: true, prompt: string } | { ok: false, error: string }}
+ */
+function renderMacroPrompt(prompt, inputs, values) {
+  const vals = values && typeof values === 'object' ? values : {};
+  const clean = Object.create(null);
+  for (const input of inputs || []) {
+    const own = Object.prototype.hasOwnProperty.call(vals, input.name) && typeof vals[input.name] === 'string';
+    const v = sanitizeMacroValue(own ? vals[input.name] : (input.default ?? ''));
+    if (v === '') {
+      if (input.required) return { ok: false, error: `"${input.label}" is required` };
+    } else if (v.length > MACRO_INPUT_MAX_LEN) {
+      return { ok: false, error: `"${input.label}" is longer than ${MACRO_INPUT_MAX_LEN} characters` };
+    } else if (input.options && input.options.length > 0 && !input.options.includes(v)) {
+      return { ok: false, error: `"${input.label}" must be one of: ${input.options.join(', ')}` };
+    }
+    clean[input.name] = v;
+  }
+
+  for (const name of macroPlaceholders(prompt)) {
+    if (!(name in clean)) return { ok: false, error: `prompt uses undeclared input {{${name}}}` };
+  }
+
+  const rendered = String(prompt).replace(new RegExp(MACRO_PLACEHOLDER_RE.source, 'g'), (_m, n) => clean[n]);
+  if (rendered.length > MACRO_PROMPT_RENDERED_MAX_LEN) {
+    return { ok: false, error: `rendered prompt is longer than ${MACRO_PROMPT_RENDERED_MAX_LEN} characters` };
+  }
+  return { ok: true, prompt: rendered };
+}
+
 const MacroSchema = z.object({
   id: MacroIdSchema,
   label: MacroLabelSchema,
@@ -151,6 +206,12 @@ function normalizeCwd(cwd) {
   return collapsed.replace(/\/+$/, '');
 }
 
+/** True iff the macro is shown for `cwd`: its projects include '*' or the normalized cwd. */
+function macroVisibleIn(macro, cwd) {
+  const projects = (macro && macro.projects) || [];
+  return projects.includes(ALL_PROJECTS) || projects.includes(normalizeCwd(cwd));
+}
+
 function normalizeProjects(projects) {
   const out = [];
   for (const p of projects || []) {
@@ -414,6 +475,14 @@ async function loadForWrite(filePath, opts) {
  * Create (no id) or update (id) a macro. Returns the saved Macro.
  * Throws on invalid input or unknown id.
  */
+/** Merged-macro check: every `{{name}}` in the prompt must be a declared input. */
+function assertPlaceholdersDeclared(macro) {
+  const declared = new Set((macro.inputs || []).map((i) => i.name));
+  for (const name of macroPlaceholders(macro.prompt)) {
+    if (!declared.has(name)) throw new Error(`prompt placeholder {{${name}}} is not declared in inputs`);
+  }
+}
+
 async function saveMacro(input, opts = {}) {
   const parsed = MacroSaveSchema.parse(input);
   const filePath = resolvePath(opts);
@@ -442,6 +511,7 @@ async function saveMacro(input, opts = {}) {
       } else {
         saved.inputs = parsed.inputs;
       }
+      assertPlaceholdersDeclared(saved);
       macros[idx] = saved;
     } else {
       const projects = parsed.projects !== undefined ? normalizeProjects(parsed.projects) : [];
@@ -457,6 +527,7 @@ async function saveMacro(input, opts = {}) {
         updatedAt: now,
       };
       if (parsed.inputs && parsed.inputs.length > 0) saved.inputs = parsed.inputs;
+      assertPlaceholdersDeclared(saved);
       macros.push(saved);
     }
     await writeStore(filePath, macros);
@@ -518,6 +589,10 @@ module.exports = {
   MacroSaveSchema,
   MacroDeleteSchema,
   MacroSetProjectSchema,
+  macroPlaceholders,
+  defaultMacroValues,
+  renderMacroPrompt,
+  macroVisibleIn,
   listMacros,
   saveMacro,
   deleteMacro,

package/src/main/lib/prd/prdCreate.cjs

@@ -29,6 +29,7 @@ const { resolveProjectContext } = require('../projectRootResolve.cjs');
 const { fixChainDepthOf, baseSlugOf } = require('../scheduler/fixChainDepth.cjs');
 const { DEFAULT_PRD_AGENT_TYPE, assertAgentTypeWritable } = require('./prdAgentType.cjs');
 const { resolveDepSlug, findNearMatches } = require('./depSlugResolve.cjs');
+const { resolveEpicPrdWriteDir } = require('./prdLocations.cjs');
 const { isFixPlanSlug } = require('../scheduler/fixPlanSlug.cjs');
 const { isIncomplete, resolveChainTerminals, isValidPlanId, mintPlanId, resolveInheritedPlanId } = require('./prdDisposition.cjs');
 const { sizingWarnings } = require('./prdSizing.cjs');
@@ -443,6 +444,30 @@ async function createPrd(input, remote) {
   }
   extraWarnings.push(...await worktreeReachAdvisory(input, cwd));
 
+  // Duplicate-slug guard (2110/2111 phone-drop-summary-state: duplicate re-issue after archive).
+  // Finished rows leave queue.json, so an author can re-issue a landed PRD under a fresh NN.
+  // Refused before NN allocation so it burns no number. Fix plans are exempt.
+  if (input.sourcePromptId && !isFixPlanSlug(`0-${slug}`)) {
+    let epicDirs = [];
+    try {
+      const prdsDir = resolveEpicPrdWriteDir(cwd, input.sourcePromptId);
+      epicDirs = [prdsDir, path.join(path.dirname(prdsDir), 'prds-archived')];
+    } catch { /* unsafe epic id — no dirs to scan */ }
+    for (const dir of epicDirs) {
+      let names = [];
+      try { names = await fsp.readdir(dir); } catch { /* missing dir counts as empty */ }
+      const dup = names.find((n) => n.endsWith('.md') && n.slice(0, -3).replace(/^\d+-/, '') === slug);
+      if (dup) {
+        return {
+          ok: false,
+          status: 409,
+          error: `A PRD with slug "${slug}" already exists in this Epic as "${dup}". Its work may already have landed. ` +
+            'Use scheduler_update_prd / scheduler_reset_job on it, or pick a distinct slug.',
+        };
+      }
+    }
+  }
+
   const nn = await remote.allocateParallelGroup(input.cwd);
   const filenameSlug = `${nn}-${slug}`;
 

package/src/main/lib/prd/prdWorktreeReach.cjs

@@ -3,8 +3,8 @@
  *
  * Incident: burrow PRD 1516-fb-bilko-first-pumpkin named a gitignored runtime path by RELATIVE
  * path (downloads/fb-tracker.db) and an install-cron.sh that baked a worktree path. Scheduled
- * PRDs run in an isolated git job worktree holding only tracked files plus symlinked dependency
- * dirs (DEFAULT_DEP_DIRS), so that path pointed at a file that did not exist there and the job
+ * PRDs run in an isolated git job worktree holding only tracked files plus symlinked or (pnpm) worktree-local
+ * dependency dirs (DEFAULT_DEP_DIRS), so that path pointed at a file that did not exist there and the job
  * parked needs_human.
  *
  * Two exports: `extractRepoPathCandidates(text)` pulls repo-relative path-looking tokens out of

package/src/main/lib/prd/workTypeLibrary.cjs

@@ -27,6 +27,8 @@ const WORK_TYPES = Object.freeze([
   'discussion',
   'build',
   'project-home-builder',
+  'art',
+  'portfolio',
 ]);
 
 const WorkTypeSchema = z.enum(WORK_TYPES);
@@ -37,17 +39,19 @@ const WorkTypeSchema = z.enum(WORK_TYPES);
 // legacy-drop preprocessing.
 const LEGACY_WORK_TYPES = Object.freeze(['bilko-host-publisher']);
 
-// A 'discussion'-tagged ticket never reaches PRD authoring (a domain
+// 'discussion' and 'portfolio' tickets never reach PRD authoring (a domain
 // invariant unrelated to the Epic/PRD tag unification above), so the PRD
 // frontmatter `tag` field — parsed in prdFrontmatter.cjs/.ts and patched via
-// ipcSchemas.cjs's adminPrdFrontmatterPatch — excludes it even though
+// ipcSchemas.cjs's adminPrdFrontmatterPatch — excludes them even though
 // WorkTypeSchema itself (used at PRD-create time) does not.
-const PRD_WORK_TYPES = Object.freeze(WORK_TYPES.filter((t) => t !== 'discussion'));
+const NON_PRD_WORK_TYPES = Object.freeze(['discussion', 'portfolio']);
+const PRD_WORK_TYPES = Object.freeze(WORK_TYPES.filter((t) => !NON_PRD_WORK_TYPES.includes(t)));
 const PrdWorkTypeSchema = z.enum(PRD_WORK_TYPES);
 
 module.exports = {
   WORK_TYPES,
   WorkTypeSchema,
+  NON_PRD_WORK_TYPES,
   PRD_WORK_TYPES,
   PrdWorkTypeSchema,
   LEGACY_WORK_TYPES,

package/src/main/lib/process/procGroupRss.cjs

@@ -0,0 +1,61 @@
+// @ts-check
+'use strict';
+
+/**
+ * procGroupRss.cjs — summed resident memory (MB) of every process in a
+ * process group, read from /proc (Linux only).
+ *
+ * Why: the scheduler's memory gate double-counted running jobs (2026-10-18).
+ * Each job reserves 2500 MB, but part of that is already consumed and thus
+ * already missing from MemAvailable; subtracting the full reservation again
+ * counts it twice. Scheduler jobs are spawned `detached: true`, so a job's
+ * pid leads its own process group and its tsc/vite/node children share that
+ * pgid — summing the group's RSS tells the gate how much is already used.
+ *
+ * Parsing: /proc/<pid>/stat is `pid (comm) state ppid pgrp ... rss ...` and
+ * comm may contain spaces and parentheses, so split only after the LAST ')'.
+ * In the remainder (0-based): state=0, ppid=1, pgrp=2, rss=21 (pages).
+ */
+
+const fs = require('node:fs');
+
+const PGRP_IDX = 2;
+const RSS_IDX = 21;
+
+/**
+ * @param {number} pgid
+ * @param {{ procRoot?: string, pageSizeKb?: number }} [opts]
+ * @returns {number} integer MB (floor); 0 on any non-applicable/failed case
+ */
+function processGroupRssMb(pgid, opts = {}) {
+  if (!Number.isInteger(pgid) || pgid <= 0) return 0;
+  if (process.platform !== 'linux') return 0;
+  const procRoot = opts.procRoot ?? '/proc';
+  const pageSizeKb = opts.pageSizeKb ?? 4;
+
+  let names;
+  try {
+    names = fs.readdirSync(procRoot);
+  } catch {
+    return 0;
+  }
+
+  let totalKb = 0;
+  for (const name of names) {
+    if (!/^\d+$/.test(name)) continue;
+    try {
+      const stat = fs.readFileSync(`${procRoot}/${name}/stat`, 'utf8');
+      const close = stat.lastIndexOf(')');
+      if (close < 0) continue;
+      const fields = stat.slice(close + 1).trim().split(/\s+/);
+      if (Number(fields[PGRP_IDX]) !== pgid) continue;
+      const rssPages = Number(fields[RSS_IDX]);
+      if (Number.isFinite(rssPages) && rssPages > 0) totalKb += rssPages * pageSizeKb;
+    } catch {
+      // vanished or unreadable entry — skip it
+    }
+  }
+  return Math.floor(totalKb / 1024);
+}
+
+module.exports = { processGroupRssMb };