claude-code-session-manager 0.116.1 → 0.118.0

package/src/main/memoryTool.cjs

@@ -32,6 +32,7 @@ const config = require('./config.cjs');
 
 const { MEMORY_SLUG_RE: SLUG_RE } = require('./lib/memorySlug.cjs');
 const { scoreMemories } = require('./lib/memoryStale.cjs');
+const { makeRefResolver, listTrackedFiles } = require('./lib/memoryRefResolve.cjs');
 const { addIndexLine, removeIndexLines, indexHealth } = require('./lib/memoryIndex.cjs');
 const {
   resolveWorkspaceMemoryDir,
@@ -318,13 +319,24 @@ async function stale({ workspace, cwd, agent }) {
       baseDir = null;
     }
   }
-  const existsPath = baseDir
-    ? (relPath) => {
-        const full = path.resolve(baseDir, relPath);
-        if (full !== baseDir && !full.startsWith(baseDir + path.sep)) return false;
-        return fs.existsSync(full);
+  let existsPath = () => true;
+  if (baseDir) {
+    const resolveRef = makeRefResolver({ cwd: baseDir, trackedFiles: await listTrackedFiles(baseDir) });
+    existsPath = (relPath, roots = []) => {
+      const full = path.resolve(baseDir, relPath);
+      if (full !== baseDir && !full.startsWith(baseDir + path.sep)) return false;
+      const safeRoots = [];
+      for (const root of roots) {
+        try {
+          // Validate the expanded form so `~/x` is checked against the home boundary too.
+          const expanded = root === '~' || root.startsWith('~/') ? path.join(os.homedir(), root.slice(1)) : root;
+          config.validatePath(expanded);
+          safeRoots.push(root);
+        } catch { /* skip an out-of-bounds root */ }
       }
-    : () => true;
+      return resolveRef(relPath, safeRoots);
+    };
+  }
 
   const entries = [];
   for (const name of names) {

package/src/main/promptSessionEvents.cjs

@@ -69,7 +69,9 @@ function mintEventId() {
  * meta arg (not a fifth positional parameter) with `validation`: a
  * scheduler check-in is born `'unvalidated'` — never `'verified'` —
  * regardless of the job's self-reported outcome; the authoring Epic's own
- * validation pass is what may later move it to 'verified'/'refuted'. All
+ * validation pass is what may later move it to 'verified'/'refuted'. `agentType`
+ * (the job's agent) and `digestKey` (the settle digest's stable key) ride the
+ * same meta arg and are copied the same way. All
  * keys are added to the event object only when present in `meta`, never as
  * `undefined`-valued keys, so events appended without them serialize
  * identically to before.
@@ -84,7 +86,7 @@ async function appendResponseEventWithReason(cwd, sourcePromptId, text, meta = {
       const data = result.data;
       const session = data.sessions && data.sessions[sourcePromptId];
       if (!session) return { ok: false, reason: 'no-session' };
-      if (session.status !== 'active') return { ok: false, reason: 'not-active' };
+      if (session.status !== 'active' && !(meta && meta.allowInactive === true)) return { ok: false, reason: 'not-active' };
       const events = (data.events && data.events[sourcePromptId]) || [];
       const tail = events.length > 0 ? events[events.length - 1] : null;
       if (!tail) return { ok: false, reason: 'no-events' };
@@ -99,6 +101,8 @@ async function appendResponseEventWithReason(cwd, sourcePromptId, text, meta = {
       if (meta && meta.prdSlug) event.prdSlug = meta.prdSlug;
       if (meta && meta.outcome) event.outcome = meta.outcome;
       if (meta && meta.validation) event.validation = meta.validation;
+      if (meta && meta.agentType) event.agentType = meta.agentType;
+      if (meta && meta.digestKey) event.digestKey = meta.digestKey;
       data.events[sourcePromptId] = [...events, event];
       await config.writeJson(path, data, { writer: 'scheduler' });
       broadcast(EVENT_APPENDED_CHANNEL, { cwd, promptSessionId: sourcePromptId, event });

package/src/main/runVerify.cjs

@@ -526,17 +526,17 @@ function checkDeps(queueEntry, allJobs, prdBody) {
 // ─── sentinel scanner ─────────────────────────────────────────────────────────
 
 /**
- * Scan for a `SCHEDULER_VERDICT: PASS|FAIL|BLOCKED_BY_FOREIGN_WIP` sentinel
+ * Scan for a `SCHEDULER_VERDICT: PASS|FAIL|BLOCKED_BY_FOREIGN_WIP|NEEDS_HUMAN` sentinel
  * line in the run output.
  *
  * Checks `resultEvent.resultText` first (the agent's final message), then the
  * last tool_result content. Anchored to line-start so prose mentioning the
  * string in mid-sentence does not match.
  *
- * Returns 'pass', 'fail', 'blocked_by_foreign_wip', or null.
+ * Returns 'pass', 'fail', 'blocked_by_foreign_wip', 'needs_human', or null.
  */
 function scanSentinel(resultEvent, events) {
-  const RE = /^SCHEDULER_VERDICT:\s*(PASS|FAIL|BLOCKED_BY_FOREIGN_WIP)\b/m;
+  const RE = /^SCHEDULER_VERDICT:\s*(PASS|FAIL|BLOCKED_BY_FOREIGN_WIP|NEEDS_HUMAN)\b/m;
 
   if (resultEvent) {
     const m = resultEvent.resultText.match(RE);
@@ -577,6 +577,28 @@ function scanSentinelReason(resultEvent, events) {
   return '';
 }
 
+/**
+ * One-line question after `SCHEDULER_VERDICT: NEEDS_HUMAN` (same two-source
+ * scan order as scanSentinel). Trimmed, capped at 300 chars; '' when absent.
+ */
+function scanHumanQuestion(resultEvent, events) {
+  const RE = /^SCHEDULER_VERDICT:\s*NEEDS_HUMAN\b[ \t]*([^\n]*)/m;
+  const clip = (m) => m[1].trim().slice(0, 300);
+  if (resultEvent && resultEvent.resultText) {
+    const m = resultEvent.resultText.match(RE);
+    if (m) return clip(m);
+  }
+  let lastToolResult = null;
+  for (const ev of events) {
+    if (ev.kind === 'tool_result') lastToolResult = ev;
+  }
+  if (lastToolResult && lastToolResult.content) {
+    const m = lastToolResult.content.match(RE);
+    if (m) return clip(m);
+  }
+  return '';
+}
+
 /**
  * Scan for a `FOREIGN_WIP_PATHS: <comma-separated paths>` evidence line —
  * the mandatory companion to a `SCHEDULER_VERDICT: BLOCKED_BY_FOREIGN_WIP`
@@ -1121,6 +1143,19 @@ async function verifyRun({
       );
     }
 
+    // The executor needs a decision/action only the human can take. Parks as
+    // needs_review with the question; every automatic retry rung skips it.
+    if (sentinel === 'needs_human') {
+      const humanQuestion = scanHumanQuestion(resultEvent, events);
+      const kept = [...annotations, ...issues.map((i) => ({ verdict: i.verdict, reason: i.reason }))];
+      return conclude(
+        'needs_human',
+        'executor reported SCHEDULER_VERDICT: NEEDS_HUMAN' + (humanQuestion ? ': ' + humanQuestion : ''),
+        'needs_review',
+        { sentinel, humanQuestion, ...(kept.length ? { annotations: kept } : {}) },
+      );
+    }
+
     // Ground truth outranks heuristics: an exit-0 run that landed a commit
     // ATTRIBUTABLE TO THIS RUN (spawnJob's own guardHeadBefore/headAtExit
     // delta, or the repo-wide committedDuringRun window scan) and never
@@ -1420,6 +1455,7 @@ module.exports = {
   parseLog,
   scanSentinel,
   scanSentinelReason,
+  scanHumanQuestion,
   scanForeignWipPathsClaim,
   isMergeMainSlug,
   extractMergeMainPrNumber,

package/src/main/scheduler/reviewLadder.cjs

@@ -34,9 +34,15 @@ const { DEFAULT_PROJECT_CWD } = require('../lib/scheduler/schedulerBatch.cjs');
  * Kill-switch: SM_RESUME_RECOVERY_DISABLE=1 restores today's behaviour
  * exactly (always returns null), mirroring SM_RCA_DISABLE/SM_DOD_DISABLE.
  */
+/** A row parked on a question only the human can answer — no automatic rung may touch it. */
+function isNeedsHuman(job) {
+  return !!job && job.verifierVerdict === 'needs_human';
+}
+
 function selectResumeRecoveryTarget(job) {
   if (process.env.SM_RESUME_RECOVERY_DISABLE === '1') return null;
   if (!job || job.status !== 'needs_review') return null;
+  if (isNeedsHuman(job)) return null;
   if (job.verifierVerdict !== 'uncommitted_changes') return null;
   if (typeof job.sessionId !== 'string' || job.sessionId.length === 0) return null;
   if (job.resumeRecoveryAttempted === true) return null;
@@ -100,6 +106,7 @@ function isMechanicalRecoveryFutile(job, currentHeadSha) {
 function selectMechanicalRecoveryTarget(job, currentHeadSha = null) {
   if (process.env.SM_MECHANICAL_RECOVERY_DISABLE === '1') return null;
   if (!job || job.status !== 'needs_review') return null;
+  if (isNeedsHuman(job)) return null;
   if (!MECHANICALLY_RESOLVABLE_VERDICTS.has(job.verifierVerdict)) return null;
   if (job.mechanicalRecoveryAttempted === true) return null;
   if (isMechanicalRecoveryFutile(job, currentHeadSha)) return null;
@@ -791,6 +798,7 @@ function selectExhaustedNeedsReviewTargets(jobs, now, thresholdMs) {
   const targets = [];
   for (const j of jobs ?? []) {
     if (j.status !== 'needs_review') continue;
+    if (isNeedsHuman(j)) continue;
     if (!isEligibleForNeedsReviewAutoResolve(j, jobs)) continue;
     if ((j.exhaustedResolveAttempts ?? 0) > NEEDS_REVIEW_RESOLVE_CAP) continue;
     const history = j.statusHistory || [];
@@ -833,6 +841,7 @@ function selectAutoFixTargets(jobs, { fixSlugExists, resolveJobRunId = resolveRu
   const slugsInQueue = new Set(jobs.map((j) => j.slug));
   return jobs.filter((job) => {
     if (job.status !== 'needs_review') return false;
+    if (isNeedsHuman(job)) return false;
     // A job parked here because it was blocked by a sibling's foreign WIP
     // three times in a row (never its own regression) has nothing for a
     // fix-plan investigation to diagnose — there is no code defect to
@@ -926,7 +935,7 @@ function isEligibleForImmediateAutoFix(job, allJobs, fixSlugExists) {
  *
  * Returns the first tier-1 row, else the tier-2 row, else null.
  */
-function selectGateShadowTarget(jobs, headByCwd, { authorityDisabled = false } = {}) {
+function selectGateShadowTarget(jobs, headByCwd, { authorityDisabled = false, baselineDisabled = process.env.SM_BASELINE_GATE_AUTHORITY_DISABLE === '1' } = {}) {
   const eligible = jobs.filter((j) => {
     if (j.status !== 'needs_review') return false;
     const head = headByCwd.get(j.cwd);
@@ -938,16 +947,25 @@ function selectGateShadowTarget(jobs, headByCwd, { authorityDisabled = false } =
     return !j.gateShadow || j.gateShadow.head !== head || j.gateShadow.definitive !== true;
   };
 
-  if (!authorityDisabled) {
+  // Baseline authority: a sentinel_fail park with a landed commit and a known
+  // base commit may complete when its red gate was already red at that base.
+  const baselineEligible = (j) => !baselineDisabled
+    && j.verifierVerdict === 'sentinel_fail'
+    && typeof j.landedCommit === 'string' && j.landedCommit.length > 0
+    && typeof j.guardHeadBefore === 'string' && j.guardHeadBefore.length > 0;
+
+  if (!authorityDisabled || !baselineDisabled) {
     const ranAtMs = (j) => {
       const t = j.gateShadow ? Date.parse(j.gateShadow.ranAt) : NaN;
       return Number.isFinite(t) ? t : -Infinity; // never-run or unparseable sorts oldest
     };
     const tier1 = eligible.filter((j) => isStale(j)
-      && j.verifierVerdict
-      && GATE_AUTHORITY_VERDICTS.includes(j.verifierVerdict)
-      && typeof j.landedCommit === 'string'
-      && j.landedCommit.length > 0);
+      && ((!authorityDisabled
+        && j.verifierVerdict
+        && GATE_AUTHORITY_VERDICTS.includes(j.verifierVerdict)
+        && typeof j.landedCommit === 'string'
+        && j.landedCommit.length > 0)
+        || baselineEligible(j)));
     if (tier1.length) {
       const ranked = tier1
         .map((j, i) => ({ j, i, neverRun: !j.gateShadow, ranAt: ranAtMs(j) }))
@@ -964,6 +982,7 @@ function selectGateShadowTarget(jobs, headByCwd, { authorityDisabled = false } =
 }
 
 module.exports = {
+  isNeedsHuman,
   selectResumeRecoveryTarget,
   MECHANICALLY_RESOLVABLE_VERDICTS,
   isMechanicalRecoveryFutile,

package/src/main/scheduler.cjs

@@ -79,6 +79,8 @@ const { sweepStrandedJobBranches } = require('./lib/git/branchSweep.cjs');
 const { detectRateLimitInLog } = require('./lib/claude/rateLimitDetect.cjs');
 const { stripAppOwnedChurn } = require('./lib/scheduler/jobDirtFilter.cjs');
 const { GATE_AUTHORITY_VERDICTS, decideGateAuthority } = require('./lib/scheduler/gateAuthority.cjs');
+const { decideBaselineAuthority } = require('./lib/scheduler/baselineGate.cjs');
+const { linkDependencyDirs } = require('./lib/git/worktreeDeps.cjs');
 const { resolveBindingRateLimitReset } = require('./lib/claude/rateLimitWindow.cjs');
 const { isResetFresh, bindingWindow, degradedBudget, meterFailureBudget } = require('./lib/claude/usageCircuit.cjs');
 const { computeQueueHealth } = require('./lib/scheduler/queueHealth.cjs');
@@ -97,7 +99,8 @@ const sessionsStore = require('./sessionsStore.cjs');
 const { enqueueExternalPrompt } = require('./chatRunner.cjs');
 const { appendResponseEventIfKnown, appendResponseEventWithReason } = require('./promptSessionEvents.cjs');
 const { buildReviewNotice, selectDueReviewNotices, formatReviewNotice, holdMsFromEnv } = require('./lib/scheduler/reviewNotice.cjs');
-const { maybeEnqueueValidationPrompt } = require('./lib/epic/epicValidationHook.cjs');
+const epicValidationHook = require('./lib/epic/epicValidationHook.cjs');
+const prdCreate = require('./lib/prd/prdCreate.cjs');
 const { parseValidationSentinels } = require('./lib/scheduler/validationSentinels.cjs');
 const { hasDownstreamValidator } = require('./lib/prd/planValidator.cjs');
 const promptSessionTranscript = require('./promptSessionTranscript.cjs');
@@ -347,12 +350,18 @@ ${verdictStepNum}. VERDICT LINE — end your final report with exactly one of th
      SCHEDULER_VERDICT: PASS
      SCHEDULER_VERDICT: FAIL <one-line reason>
      SCHEDULER_VERDICT: BLOCKED_BY_FOREIGN_WIP
+     SCHEDULER_VERDICT: NEEDS_HUMAN <one-line question>
    - Print PASS only when the gate is green AND the commit from step ${commitStepNum} landed.
    - Print FAIL when the gate is red or the commit could not land.
    - Never print PASS on a red gate. Why: a false PASS ships broken work that
      no one notices. A true PASS plus a landed commit lets the scheduler ignore
      harmless noise in your transcript, such as grep hits for "Error", an early
      red test run, or debug tracebacks.
+   - Print NEEDS_HUMAN only when finishing needs a decision or action only the
+     human can take (credentials, an account/dashboard action, a product
+     choice, an install on the host) — never for a red gate or a bug you could
+     fix. Commit any finished work first. Phrase the question so a yes/no or
+     one-line answer unblocks it.
    - Print BLOCKED_BY_FOREIGN_WIP ONLY when your gate failed because of a
      sibling job's unfinished, uncommitted file — never because of your own
      change — AND every failing path is one this prompt already listed as
@@ -2664,6 +2673,7 @@ function resetJobFields(job, errorMsg, opts = {}) {
   job.error = errorMsg ?? null;
   delete job.runtime;
   delete job.verifierVerdict;
+  delete job.humanQuestion;
   delete job.uncommittedPaths;
   delete job.resumeRecoveryAttempted;
   // Same one-attempt-per-episode category as resumeRecoveryAttempted above —
@@ -3009,6 +3019,29 @@ async function resolveFixPlanPath(failedJob) {
   return { fixPath, fixSlug, group, livePrdDir };
 }
 
+/**
+ * defaultScheduleSettle — production wiring for notifyOriginatingTab's
+ * scheduleSettle option: arms the debounced Epic settle runner with live deps.
+ * `remote` is defined later in the module but only read at call time.
+ */
+function defaultScheduleSettle({ cwd, epicId }) {
+  const deps = {
+    loadJobs: async () => (await readQueue()).jobs || [],
+    loadHistory: () => queueHistory.readHistory({ limit: 500 }),
+    createPrd: (input) => prdCreate.createPrd(input, remote),
+    resolveBaseSha: async (c, commit) => {
+      try {
+        return String(await execGitAt(c, ['rev-parse', `${commit}^`])).trim() || null;
+      } catch {
+        return null;
+      }
+    },
+    sendPrompt: enqueueExternalPrompt,
+    appendResponseEvent: appendResponseEventIfKnown,
+  };
+  epicValidationHook.scheduleEpicSettle({ cwd, epicId }, (args) => epicValidationHook.runEpicSettle(args, deps));
+}
+
 /**
  * notifyOriginatingTab(job) → void
  *
@@ -3047,16 +3080,19 @@ async function notifyOriginatingTab(job, {
   appendResponseEvent = appendResponseEventIfKnown,
   appendTranscriptTurn = promptSessionTranscript.appendTurn,
   readResultFromLog = extractResultTextFromLog,
-  enqueueValidation = maybeEnqueueValidationPrompt,
-  // PRD 1408: same queue rows spawnJob/tickQueue already use — read fresh
-  // here (not threaded through the terminal-transition snapshot) since this
-  // fires well after dispatch, when the plan may have gained/dropped a
-  // trailing validator row since this job was spawned.
-  loadJobs = async () => (await readQueue()).jobs || [],
+  scheduleSettle = defaultScheduleSettle,
 } = {}) {
   try {
     const prd = await resolveNotifyPrd(job, parsePrdRaw);
-    const message = `PRD ${job.slug} finished: ${job.status}. Check Scheduler for details.`;
+    let message = `PRD ${job.slug} finished: ${job.status}. Check Scheduler for details.`;
+    if (job.verifierVerdict === 'pass_preexisting_gate_red') {
+      const failures = Array.isArray(job.preexistingGateFailures) ? job.preexistingGateFailures : [];
+      const shown = failures.slice(0, 10).join('; ');
+      const more = failures.length > 10 ? ` (+${failures.length - 10} more)` : '';
+      message = `PRD ${job.slug} completed; the gate was already red before this PRD`
+        + (failures.length ? `. Pre-existing failures: ${shown}${more}` : '')
+        + '. Check Scheduler for details.';
+    }
 
     // The EPIC this check-in belongs to. Deliberately does NOT consider
     // `sourceTabId` — that is a Terminal tab id, not an Epic id, and
@@ -3157,55 +3193,22 @@ async function notifyOriginatingTab(job, {
         prdSlug: job.slug,
         outcome: job.status,
         validation: 'unvalidated',
+        ...(typeof job.agentType === 'string' ? { agentType: job.agentType } : {}),
       }).catch((e) => {
         console.error('[scheduler] notifyOriginatingTab appendResponseEvent error', job?.slug, e);
         return false;
       });
       if (routed) {
-        // PRD 986: a successful check-in append triggers ONE validation
-        // prompt into the authoring Epic's own session, asking it to verify
-        // every acceptance criterion against the real working tree and reply
-        // VERIFIED or REFUTED. Fire-and-forget, same convention as this
-        // function's own call site in tickQueue: a failure to enqueue is
-        // logged inside the hook, never thrown, and never blocks the job's
-        // status transition or the response-event append (which already
-        // happened above). All gating (kill-switch SM_EPIC_VALIDATION_DISABLE,
-        // active-Epic check, once-per-(epicId, prdSlug), loop guard, slot-pool
-        // routing) lives in lib/epic/epicValidationHook.cjs.
-        //
-        // PRD 1407: a validator job's own check-in never enqueues a
-        // validation prompt for itself — it IS the plan's validation pass,
-        // not a work-item awaiting one.
-        //
-        // PRD 1408: nor does an ordinary work-item whose plan already ends in
-        // a trailing validator job depending on it — that validator's own
-        // check-in (above) is the single validation pass for the whole plan,
-        // so a per-PRD prompt here would be a second, redundant ask into the
-        // same (Opus/Fable-tier) authoring session.
-        if (job.agentType !== 'validator') {
-          let skipForDownstreamValidator = false;
-          try {
-            skipForDownstreamValidator = hasDownstreamValidator(job, await loadJobs());
-          } catch (e) {
-            console.error('[scheduler] notifyOriginatingTab loadJobs error', job?.slug, e);
-          }
-          if (!skipForDownstreamValidator) {
-            try {
-              enqueueValidation(
-                {
-                  cwd: job.cwd || null,
-                  epicId,
-                  prdSlug: job.slug,
-                  prdPath: prd?.path || prdPaths.archivedPrdPathForJob(job) || null,
-                  outcome: job.status,
-                  eventValidation: 'unvalidated',
-                },
-                { sendPrompt },
-              );
-            } catch (e) {
-              console.error('[scheduler] notifyOriginatingTab enqueueValidation error', job?.slug, e);
-            }
-          }
+        // The debounced Epic settle runner (lib/epic/epicValidationHook.cjs)
+        // owns all validation messaging now (replaces the per-PRD prompts of
+        // PRDs 986/1407/1408): every successful terminal check-in, a
+        // validator's own included (its finish usually settles the Epic),
+        // just re-arms the per-Epic debounce. A finished PRD never sends a
+        // chat prompt into its authoring Epic by itself.
+        try {
+          scheduleSettle({ cwd: job.cwd || null, epicId });
+        } catch (e) {
+          console.error('[scheduler] notifyOriginatingTab scheduleSettle error', job?.slug, e);
         }
         return;
       }
@@ -3383,6 +3386,7 @@ async function flushDueReviewNotices({
             prdSlug: group.jobs[0].slug,
             outcome: 'needs_review',
             validation: 'unvalidated',
+            allowInactive: true,
           });
           outcome = typeof result === 'boolean' ? { ok: result, reason: result ? undefined : 'refused' } : result;
         } catch (e) {
@@ -6438,17 +6442,10 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null, sib
     let mechanicalRecoveryTarget = null;
     let terminalNotifySnapshot = null;
     const newlyCompletedPrds = [];
-    // PRD 1408: captured inside the mutate() below (the one in-memory read of
-    // `s.jobs` this finalize pass already does) so notifyOriginatingTab's own
-    // hasDownstreamValidator check can reuse it instead of a second, redundant
-    // readQueue() — that call federates queue.json shards across every known
-    // project cwd on the machine, not just this job's own project.
-    let jobsSnapshotForNotify = null;
     // Base HEAD for the mechanical-recovery futility check — read here, never inside mutate() (no I/O).
     const finalizeHeadSha = worktreeIntegrationDetail && worktreeIntegrationDetail.failureKind === 'content_conflict'
       ? await gitTreeGuard.gitHead(guardCwd) : null;
     await mutate((s) => {
-      jobsSnapshotForNotify = s.jobs.slice();
       const i2 = s.jobs.findIndex((x) => x.slug === job.slug);
       // A job already moved off 'running' by someone else (namely
       // remote.cancelJob, PRD 1024 — it SIGTERMs the process then finalizes
@@ -6637,6 +6634,11 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null, sib
           } else if (!['blocked_by_foreign_wip_streak', 'budget_exceeded'].includes(s.jobs[i2].verifierVerdict)) {
             delete s.jobs[i2].verifierVerdict;
           }
+          if (verifyResult?.verdict === 'needs_human') {
+            s.jobs[i2].humanQuestion = verifyResult.humanQuestion || '';
+          } else {
+            delete s.jobs[i2].humanQuestion;
+          }
           stampIntegrationFailure(s.jobs[i2], worktreeIntegrationFailure ? worktreeIntegrationDetail : null);
           transitionJob(s.jobs[i2], effectiveStatus, { reason: finalizeReason, source: 'spawnJob:finalize' });
           s.jobs[i2].finishedAt = new Date().toISOString();
@@ -6860,9 +6862,7 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null, sib
     });
 
     if (terminalNotifySnapshot) {
-      notifyOriginatingTab(terminalNotifySnapshot, {
-        loadJobs: async () => jobsSnapshotForNotify || [],
-      }).catch((e) => {
+      notifyOriginatingTab(terminalNotifySnapshot).catch((e) => {
         console.error('[scheduler] notifyOriginatingTab error', job.slug, e);
       });
     }
@@ -8793,6 +8793,52 @@ async function runGateShadow(job) {
     gateShadow.authority = decision;
   }
 
+  // Baseline authority: a sentinel_fail park whose gate is red at HEAD may
+  // still complete when every HEAD failure already failed at the job's base
+  // commit. The base run is memoized per HEAD on gateShadow.baseline.
+  let baselineDecision = null;
+  if (
+    job.verifierVerdict === 'sentinel_fail'
+    && outcome.status === 'red' && definitive
+    && typeof job.landedCommit === 'string' && job.landedCommit.length > 0
+    && typeof job.guardHeadBefore === 'string' && job.guardHeadBefore.length > 0
+    && process.env.SM_BASELINE_GATE_AUTHORITY_DISABLE !== '1'
+  ) {
+    const startedAtMs = typeof job.startedAt === 'string' ? Date.parse(job.startedAt) : NaN;
+    let evidenceOk = false;
+    if (Number.isFinite(startedAtMs)) {
+      try { evidenceOk = await resolveLandedCommitEvidence(job.cwd, job.landedCommit, job.startedAt); } catch { evidenceOk = false; }
+    }
+    let ancestorOk = false;
+    try {
+      await execGitAt(job.cwd, ['merge-base', '--is-ancestor', job.landedCommit, headBefore], { timeout: 10_000 });
+      ancestorOk = true;
+    } catch { ancestorOk = false; }
+    const memo = job.gateShadow?.baseline;
+    let baseOutcome = memo && memo.head === headBefore && memo.outcome ? memo.outcome : null;
+    if (!baseOutcome) {
+      const scratch = path.join(os.tmpdir(), `sm-baseline-gate-${process.pid}-${Date.now()}`);
+      let added = false;
+      try {
+        await execGitAt(job.cwd, ['worktree', 'add', '--detach', scratch, job.guardHeadBefore], { timeout: 120_000 });
+        added = true;
+        await linkDependencyDirs({ mainCwd: job.cwd, worktreeCwd: scratch });
+        const r = await runGateSequence(gate.sequence, { cwd: scratch });
+        baseOutcome = r.status === 'busy' ? { status: 'unavailable', reason: 'busy', results: [] } : r;
+      } catch (e) {
+        baseOutcome = { status: 'unavailable', reason: `base-gate-error: ${e && e.message ? e.message : e}`, results: [] };
+      } finally {
+        if (added) {
+          try { await execGitAt(job.cwd, ['worktree', 'remove', '--force', scratch], { timeout: 60_000 }); } catch { /* best-effort */ }
+        }
+        try { fs.rmSync(scratch, { recursive: true, force: true }); } catch { /* best-effort */ }
+        try { await execGitAt(job.cwd, ['worktree', 'prune'], { timeout: 30_000 }); } catch { /* best-effort */ }
+      }
+    }
+    baselineDecision = decideBaselineAuthority({ job, headOutcome: outcome, baseOutcome, evidenceOk, ancestorOk, cleanOk, headStable });
+    gateShadow.baseline = { head: headBefore, base: job.guardHeadBefore, outcome: baseOutcome, ...baselineDecision };
+  }
+
   const runId = job.runId || reviewLadder.resolveRunId(job);
   if (runId) {
     const verdictsPath = path.join(schedulerPaths.runsDir(), runId, `${job.slug}.verdicts.json`);
@@ -8827,6 +8873,19 @@ async function runGateShadow(job) {
         continue;
       }
       j.gateShadow = gateShadow;
+      if (baselineDecision?.complete) {
+        const v = j.verifierVerdict;
+        transitionJob(j, 'completed', {
+          reason: `gate red at ${headShort} but identical to base ${String(job.guardHeadBefore).slice(0, 7)}; verdict ${v} overridden`,
+          source: 'gateAuthority:baseline',
+        });
+        j.error = null;
+        j.verifierVerdict = 'pass_preexisting_gate_red';
+        j.preexistingGateFailures = baselineDecision.preexisting;
+        delete j.looksDone;
+        resolved = { slug: j.slug, cwd: j.cwd, verdict: v };
+        continue;
+      }
       if (!decision?.complete) continue;
       const v = j.verifierVerdict;
       transitionJob(j, 'completed', {

package/src/main/templates/PRD_AUTHORING.md

@@ -233,3 +233,5 @@ Before queueing a new PRD, verify each of these:
 - [ ] **§10 Negative assertions:** every "should find nothing" check is inverted to exit 0 on the clean case.
 - [ ] **§11 End green:** the gate runs last; any intentional failure runs early and is captured.
 - [ ] **§12 No stranded probes:** a probe error is corrected or annotated; an expected `timeout` cap branches on exit 124.
+- [ ] **Gate baseline:** every gate command ran green once at HEAD in the main checkout; a red suite is scoped to the PRD's own test files and the PRD notes say why. Why: a gate already red on base parks as `sentinel_fail`.
+- [ ] **No human-only gates:** no gate or criterion needs a human or the passage of time (cron install, live post wait, live payment, dashboard action); those end `SCHEDULER_VERDICT: NEEDS_HUMAN <question>`. Why: no executor can pass them.

package/src/preload/api.d.ts

@@ -259,6 +259,15 @@ export interface McpCatalogResult {
  *  same concept, not a free-form string list. */
 export type AgentPersonaTag = 'feature' | 'bug' | 'discussion' | 'build' | 'project-home-builder';
 
+/** One declared `{{name}}` argument of a macro prompt (macroLibrary.cjs `MacroInputSchema`). */
+export interface MacroInput {
+  name: string;
+  label: string;
+  default?: string;
+  required?: boolean;
+  options?: string[];
+}
+
 /** One user-defined sidebar HOT KEYS macro (macroLibrary.cjs). `projects` = absolute cwds or `'*'` (every project). */
 export interface Macro {
   id: string;
@@ -275,6 +284,7 @@ export interface Macro {
   builtinVersion?: number;
   createdAt: string;
   updatedAt: string;
+  inputs?: MacroInput[];
 }
 
 /** Omit `id` to create; set it to update an existing macro. */
@@ -286,6 +296,8 @@ export interface MacroSaveInput {
   prompt: string;
   projects?: string[];
   surface?: 'sessions' | 'project-home';
+  /** Omitted keeps the stored list on update; `[]` clears it. */
+  inputs?: MacroInput[];
 }
 
 /** One global `~/.claude/agents/<name>.md` persona, per the Agent Library nav page. */
@@ -1347,6 +1359,16 @@ export interface MemoryStaleEntry {
   danglingLinks: string[];
 }
 
+export type MemoryFixProposal = {
+  ok: boolean;
+  action: 'update' | 'delete' | 'fold' | 'keep';
+  summary: string;
+  reason: string;
+  content: string;
+  fold: { target: string; anchor: string; insert: string } | null;
+  error?: string;
+};
+
 export interface MemoryStaleResult {
   entries: MemoryStaleEntry[];
   workspace: string;
@@ -2131,9 +2153,9 @@ export interface SessionManagerAPI {
     /** Gated `claude -p` question over the memory folder. */
     ask: (input: { question: string; target?: MemoryTarget; contextName?: string }) =>
       Promise<{ ok: boolean; answer: string; citations: string[]; error?: string }>;
-    /** Gated `claude -p` proposed rewrite fixing a memory's dead refs; requires `target.cwd`. */
+    /** Gated `claude -p` triage of a memory against the md network: update, delete, fold into a CLAUDE.md, or keep; requires `target.cwd`. */
     proposeFix: (input: { name: string; target?: MemoryTarget }) =>
-      Promise<{ ok: boolean; content: string; summary: string; error?: string }>;
+      Promise<MemoryFixProposal>;
   };
   projectBrief: {
     /** Read brief.json (or null if none yet) plus cheaply-computed source/drift metadata. Never fires an LLM call. */