claude-code-session-manager 0.35.7 → 0.35.9

package/dist/index.html

@@ -7,7 +7,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-DgFpE4dn.js"></script>
+    <script type="module" crossorigin src="./assets/index-B4PkQh71.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
     <link rel="stylesheet" crossorigin href="./assets/index-C7NyYuXu.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.35.7",
+  "version": "0.35.9",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

package/plugins/session-manager-dev/skills/develop/standards.md

@@ -58,7 +58,9 @@ Data-driven from 400+ scheduler runs: long hangs (not bad code) are the dominant
 - **Verify before done.** Run the acceptance test command once before declaring success. If it's red, fix it or `exit 1` with the failure — never end the run on a failing test (that trips the verifier's `transcript_errors` downgrade).
 - **Fail loud, fail fast.** On any step failure, print one diagnostic line and `exit 1`; don't swallow with `|| true` or spin in a silent retry. A `rateLimited` exit-1 is the scheduler's benign auto-pause (auto-resumes next window) — not a failure to engineer around.
 - **Stay in the AC.** Do not add work past the acceptance checklist ("while we're here" generators/fixtures are the post-AC-overrun incident). Body must be clean UTF-8 — no NUL/control bytes.
-- **You ARE the executor — never re-queue or self-schedule.** A headless PRD run must perform its own acceptance criteria directly. Do NOT invoke `/develop`, `/process-feedback`, or any queue-authoring skill from inside a run — those are interactive main-loop skills that author a *new* PRD and return, so the run exits 0 having done nothing (no commit, no sentinel → `needs_review` with `no_verdict_sentinel`). Do NOT call `ScheduleWakeup`/set a tracking loop either — the process exits when the run ends and nothing re-invokes it. If the PRD's work looks large, decompose and execute it inline within this run; never delegate it back to the queue. (Incident: PRD 460 invoked `/develop`, spawned a duplicate PRD 461, and exited 0 with no work.)
+- **You ARE the executor — never re-queue or self-schedule.** A headless PRD run must perform its own acceptance criteria directly. Do NOT invoke `/develop`, `/process-feedback`, or any queue-authoring skill from inside a run — those are interactive main-loop skills that author a *new* PRD and return, so the run exits 0 having done nothing (no commit, no sentinel → `needs_review` with `no_verdict_sentinel`). Do NOT call `ScheduleWakeup`/set a tracking loop either — the process exits when the run ends and nothing re-invokes it. This applies just as much to spawning your own review agents and waiting on them: do NOT invoke `/code-review`, `/security-review`, `requesting-code-review`, or any other skill/subagent as a background/async step and then end your turn with something like "I'll wait for the review agents to complete" — a headless run has no next turn, so that line is the run's last output, no verdict sentinel prints, and the job parks in `needs_review` even though the actual work already landed. If a PRD's acceptance criteria call for a second review pass, run it **synchronously, inline, before the finish protocol** — call the reviewer and read its result in the same turn, don't fire-and-wait. If the PRD's work looks large, decompose and execute it inline within this run; never delegate it back to the queue. (Incidents: PRD 460 invoked `/develop`, spawned a duplicate PRD 461, and exited 0 with no work. PRD 479 landed its commit correctly but then backgrounded `/code-review --fix` + `/security-review` and called `ScheduleWakeup` to "wait" for them — same class of failure, different entry point.)
+- **A shared-repo `cwd` can be occupied by a concurrent job — check before you touch shared state.** When a PRD's `cwd` is a repo other headless runs may also target (a shared team repo like sigma, not a private single-purpose project), a `git checkout`/`gh pr checkout` can land you in another job's live worktree with its own uncommitted WIP. Before running `git stash`, `git reset`, or any command that discards or hides working-tree state, check `git stash list` and `git status` first, and if you must set aside pre-existing uncommitted changes that aren't yours, **stash with a descriptive message** (`git stash push -m "pre-existing WIP found by PRD <NN>, not mine"`) and **restore it before your run ends** (or, if you can't safely restore because your own commit depends on that worktree state, leave it stashed with the message and say so explicitly in your finish output — never let the run end silently dropping someone else's stash). Never `git stash drop`/`git clean -fd` on state you didn't create. (Incident: PRD 477 stashed a concurrent job's rAF-throttle-revert WIP to get its own checkout, finished, and exited without restoring it — orphaning the other job's uncommitted work in `stash@{0}` with no record of whose it was.)
+- **`gh pr edit --body` can fail on repos with legacy GitHub Projects (classic) boards** — the underlying GraphQL query fetches `repository.pullRequest.projectCards`, a field GitHub is sunsetting, and errors with `GraphQL: Projects (classic) is being deprecated ... (repository.pullRequest.projectCards)` even though the edit itself would otherwise succeed. This is a known `gh` CLI quirk, not a defect in your work. Prefer `gh api -X PATCH repos/<owner>/<repo>/pulls/<n> -f body="$(cat body.md)"` for updating a PR description headlessly — it doesn't touch the deprecated field. If you do use `gh pr edit` and it fails this way, don't leave the bare GraphQL error as the last thing in that step (it reads as an unrecovered error in the final-20%-of-transcript verifier heuristic): immediately retry with the `gh api` form and print one line noting the known-bug fallback, so the recovery is adjacent to the error.
 - **Negative-assertion checks must exit 0 when clean.** A check that verifies the *absence* of something (a `grep` that should find nothing, "no leftover X", `diff` expecting no change) must return exit 0 on the clean case. A bare `grep` exits **1 on no-match** — so the *success* path surfaces as `is_error=true` and the verifier downgrades a perfect run to `needs_review`. Always invert: `if <detector>; then echo "HALT: <what was found>"; exit 1; fi; echo clean`. Never let the no-match/empty path carry the non-zero exit.
 - **Recover or annotate every error — don't strand a Traceback in the transcript.** The verifier downgrades an otherwise-perfect run to `needs_review` when a `Traceback`/`Error` appears with *no visible recovery within ~10 lines* (the `transcript_errors` heuristic — the single most common false-positive on green deliverables). Two executor habits cause it: (1) **throwaway probes that error** — an inline `python -c` with a quoting/f-string slip, a wrong kwarg, a bad path. When a probe errors, immediately re-run the corrected version *or* print one line `# expected/handled: <why>` right after, so recovery is adjacent. Don't move on leaving a bare error as the last thing in that step. Prefer a small temp `.py` file over a fragile multi-quote `python -c` one-liner (inline f-string errors are the top source of stranded tracebacks). (2) See the timeout rule below.
 - **An *expected* bounded-timeout (exit 124) must be annotated, not bare.** `timeout`-capping a genuinely long task you expect to hit the cap (a full-universe ingest, a long scan) is correct — but a bare `Exit code 124` reads as a failure to the verifier. Wrap it so the cap is a success-with-note: `timeout 120 <cmd> || { rc=$?; [ $rc -eq 124 ] && echo "hit time cap — idempotent/partial, rows persist incrementally; OK" || { echo "HALT: <cmd> failed rc=$rc"; exit 1; }; }`. (Distinguish 124 = expected cap from a real non-zero.) For work that legitimately needs longer than a safe cap, run it in the background and poll a bounded number of times rather than capping the foreground command.

package/src/main/__tests__/dod-drain-hook.test.cjs

@@ -19,6 +19,7 @@ const os = require('node:os');
 const fs = require('node:fs');
 const path = require('node:path');
 const { runDefinitionOfDoneOnDrain } = require('../lib/dodDrainHook.cjs');
+const { readWatermark } = require('../lib/definitionOfDone.cjs');
 
 // ─── helpers ──────────────────────────────────────────────────────────────────
 
@@ -172,6 +173,110 @@ test('paused state → no report written', async () => {
   }
 });
 
+test('first-ever drain (no watermark file) processes all completed jobs', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const runsDir = path.join(tmpDir, 'runs');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+
+  const jobA = writePrd(prdsDir, '106-old', cwd);
+  jobA.finishedAt = '2020-01-01T00:00:00.000Z';
+  const jobB = writePrd(prdsDir, '107-new', cwd);
+  jobB.finishedAt = '2026-07-11T00:00:00.000Z';
+  const state = { paused: null, jobs: [jobA, jobB] };
+  const cancelToken = { cancelled: false };
+  const savedDisable = process.env.SM_DOD_DISABLE;
+  delete process.env.SM_DOD_DISABLE;
+
+  try {
+    assert.strictEqual(readWatermark(runsDir), null, 'no watermark should exist yet');
+    await runDefinitionOfDoneOnDrain(state, { cancelToken, prdsDir, runsDir });
+    assert.strictEqual(countReports(runsDir), 1);
+
+    const reportsRoot = fs.readdirSync(runsDir, { withFileTypes: true }).filter(e => e.isDirectory());
+    const reportFile = reportsRoot
+      .map(e => path.join(runsDir, e.name))
+      .flatMap(dir => fs.readdirSync(dir).filter(f => f.startsWith('definition-of-done-')).map(f => path.join(dir, f)))[0];
+    const contents = fs.readFileSync(reportFile, 'utf8');
+    assert.match(contents, /106-old/, 'first-ever drain must include old job too');
+    assert.match(contents, /107-new/);
+  } finally {
+    if (savedDisable !== undefined) process.env.SM_DOD_DISABLE = savedDisable;
+    rmdir(tmpDir);
+  }
+});
+
+test('subsequent drain with a persisted watermark only reverifies newer jobs', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const runsDir = path.join(tmpDir, 'runs');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+  fs.mkdirSync(runsDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(runsDir, '.dod-watermark.json'),
+    JSON.stringify({ lastFinishedAt: '2026-01-01T00:00:00.000Z' })
+  );
+
+  const jobOld = writePrd(prdsDir, '108-old', cwd);
+  jobOld.finishedAt = '2025-01-01T00:00:00.000Z';
+  const jobNew = writePrd(prdsDir, '109-new', cwd);
+  jobNew.finishedAt = '2026-07-11T00:00:00.000Z';
+  const state = { paused: null, jobs: [jobOld, jobNew] };
+  const cancelToken = { cancelled: false };
+  const savedDisable = process.env.SM_DOD_DISABLE;
+  delete process.env.SM_DOD_DISABLE;
+
+  try {
+    await runDefinitionOfDoneOnDrain(state, { cancelToken, prdsDir, runsDir });
+    assert.strictEqual(countReports(runsDir), 1);
+
+    const reportsRoot = fs.readdirSync(runsDir, { withFileTypes: true }).filter(e => e.isDirectory());
+    const reportFile = reportsRoot
+      .map(e => path.join(runsDir, e.name))
+      .flatMap(dir => fs.readdirSync(dir).filter(f => f.startsWith('definition-of-done-')).map(f => path.join(dir, f)))[0];
+    const contents = fs.readFileSync(reportFile, 'utf8');
+    assert.doesNotMatch(contents, /108-old/, 'jobs finished before the watermark must be excluded');
+    assert.match(contents, /109-new/, 'jobs finished after the watermark must be included');
+  } finally {
+    if (savedDisable !== undefined) process.env.SM_DOD_DISABLE = savedDisable;
+    rmdir(tmpDir);
+  }
+});
+
+test('watermark advances after a report so a repeat drain over the same jobs is a no-op', async () => {
+  const tmpDir = makeTmpDir();
+  const prdsDir = path.join(tmpDir, 'prds');
+  const runsDir = path.join(tmpDir, 'runs');
+  const cwd = path.join(tmpDir, 'project');
+  fs.mkdirSync(prdsDir);
+  fs.mkdirSync(cwd);
+
+  const job = writePrd(prdsDir, '110-test', cwd);
+  job.finishedAt = '2026-07-11T00:00:00.000Z';
+  const state = { paused: null, jobs: [job] };
+  const cancelToken = { cancelled: false };
+  const savedDisable = process.env.SM_DOD_DISABLE;
+  delete process.env.SM_DOD_DISABLE;
+
+  try {
+    await runDefinitionOfDoneOnDrain(state, { cancelToken, prdsDir, runsDir });
+    assert.strictEqual(countReports(runsDir), 1, 'first drain writes one report');
+    assert.strictEqual(readWatermark(runsDir), job.finishedAt, 'watermark must advance to the covered job\'s finishedAt');
+
+    // Second drain with a fresh job list containing the same already-covered job.
+    const state2 = { paused: null, jobs: [{ ...job }] };
+    await runDefinitionOfDoneOnDrain(state2, { cancelToken, prdsDir, runsDir });
+    assert.strictEqual(countReports(runsDir), 1, 'repeat drain over the same (now-old) job must be a no-op');
+  } finally {
+    if (savedDisable !== undefined) process.env.SM_DOD_DISABLE = savedDisable;
+    rmdir(tmpDir);
+  }
+});
+
 test('cancelToken.cancelled=true → no report written', async () => {
   const tmpDir = makeTmpDir();
   const prdsDir = path.join(tmpDir, 'prds');

package/src/main/__tests__/runVerify.test.cjs

@@ -297,6 +297,7 @@ test('Truly clean run (no error markers) → clean/null', async () => {
       prdPath,
       queueEntry: { slug, status: 'running' },
       allJobs: [],
+      committedDuringRun: true,
     });
 
     assert.equal(verdict.verdict, 'clean', `expected clean, got ${verdict.verdict}: ${verdict.reason}`);
@@ -379,6 +380,7 @@ test('FAIL recovered within 30 events → clean', async () => {
       prdPath,
       queueEntry: { slug, status: 'running' },
       allJobs: [],
+      committedDuringRun: true,
     });
 
     assert.equal(verdict.verdict, 'clean', `self-recovery should yield clean, got ${verdict.verdict}: ${verdict.reason}`);
@@ -430,7 +432,7 @@ test('feedback 01: reviewer prose mentioning ImportError mid-sentence → clean'
     ].join('\n');
     writeLog(tmp, slug, bashRunEvents(prose));
     const prdPath = writePrd(tmp, slug, '# Hardening');
-    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [] });
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
     assert.equal(verdict.verdict, 'clean', `prose mention must not flag, got ${verdict.verdict}: ${verdict.reason}`);
   } finally { rmdir(tmp); }
 });
@@ -477,7 +479,7 @@ test('addendum: Traceback→ModuleNotFoundError in a SUCCEEDED run → clean (an
     ].join('\n');
     writeLog(tmp, slug, bashRunEvents(probe)); // resultSubtype defaults to success
     const prdPath = writePrd(tmp, slug, '# Shared lib');
-    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [] });
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
     assert.equal(verdict.verdict, 'clean', `recovered env probe must not downgrade, got ${verdict.verdict}: ${verdict.reason}`);
     assert.equal(verdict.downgradeTo, null);
     assert.ok(Array.isArray(verdict.annotations) && verdict.annotations.length === 1, 'should record one annotation');
@@ -491,7 +493,7 @@ test('addendum: bare Import/ModuleNotFound probe (no traceback) in SUCCEEDED run
     const slug = '26-self-parser-tests';
     writeLog(tmp, slug, bashRunEvents("ModuleNotFoundError: No module named 'conftest'"));
     const prdPath = writePrd(tmp, slug, '# Parser tests');
-    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [] });
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
     assert.equal(verdict.verdict, 'clean', `got ${verdict.verdict}: ${verdict.reason}`);
     assert.ok(Array.isArray(verdict.annotations) && verdict.annotations.length === 1);
   } finally { rmdir(tmp); }
@@ -527,7 +529,7 @@ test('feedback 01: error-shaped text inside a Task (subagent) result → clean',
     ].join('\n');
     writeLog(tmp, slug, bashRunEvents(reviewFinding, { toolName: 'Task' }));
     const prdPath = writePrd(tmp, slug, '# Review-heavy PRD');
-    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [] });
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
     assert.equal(verdict.verdict, 'clean', `Task results must be exempt from pattern scan, got ${verdict.verdict}: ${verdict.reason}`);
   } finally { rmdir(tmp); }
 });
@@ -543,7 +545,7 @@ test('feedback 01: quoted "Traceback..." line (leading quote) → clean', async
     ].join('\n');
     writeLog(tmp, slug, bashRunEvents(prose));
     const prdPath = writePrd(tmp, slug, '# Docs PRD');
-    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [] });
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
     assert.equal(verdict.verdict, 'clean', `quoted traceback prose must not flag, got ${verdict.verdict}: ${verdict.reason}`);
   } finally { rmdir(tmp); }
 });
@@ -572,7 +574,7 @@ test('harness tool error (<tool_use_error>) in final 20% → clean', async () =>
 
     writeLog(tmp, slug, events);
     const prdPath = writePrd(tmp, slug, '# Correctness batch');
-    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [] });
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
     assert.equal(verdict.verdict, 'clean', `harness tool error must not flag, got ${verdict.verdict}: ${verdict.reason}`);
   } finally { rmdir(tmp); }
 });
@@ -859,7 +861,7 @@ test('no_verdict_sentinel guard: same run but committedDuringRun:true → stays
   }
 });
 
-test('no_verdict_sentinel guard: same run but with SCHEDULER_VERDICT: PASS sentinel → stays clean', async () => {
+test('no_verdict_sentinel guard: same run but with SCHEDULER_VERDICT: PASS sentinel + a commit → stays clean', async () => {
   const tmp = makeTmpDir();
   try {
     const slug = '406-browser-capture-panel-ui-sentinel';
@@ -870,15 +872,37 @@ test('no_verdict_sentinel guard: same run but with SCHEDULER_VERDICT: PASS senti
       prdPath,
       queueEntry: { slug, status: 'running' },
       allJobs: [],
-      committedDuringRun: false,
+      committedDuringRun: true,
     });
-    assert.equal(verdict.verdict, 'clean', `PASS sentinel should stay clean, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.verdict, 'clean', `PASS sentinel + commit should stay clean, got ${verdict.verdict}: ${verdict.reason}`);
     assert.equal(verdict.downgradeTo, null);
   } finally {
     rmdir(tmp);
   }
 });
 
+// ─── pass_no_commit: PASS sentinel with no commit is not "clean" ───────────
+
+test('pass_no_commit: SCHEDULER_VERDICT: PASS but no commit landed → needs_review', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '511-recorder-mouse-drag-panel-export';
+    writeLog(tmp, slug, noOpRunEvents('All acceptance criteria verified.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, '# Recorder mouse drag panel export');
+    const verdict = await verifyRun({
+      runDir: tmp,
+      prdPath,
+      queueEntry: { slug, status: 'running' },
+      allJobs: [],
+      committedDuringRun: false,
+    });
+    assert.equal(verdict.verdict, 'pass_no_commit', `expected pass_no_commit, got ${verdict.verdict}: ${verdict.reason}`);
+    assert.equal(verdict.downgradeTo, 'needs_review');
+  } finally {
+    rmdir(tmp);
+  }
+});
+
 // (e) halt + sentinel PASS → still halt (override must not apply to halt)
 test('halt result + sentinel PASS + committedDuringRun:true → still halt', async () => {
   const tmp = makeTmpDir();

package/src/main/__tests__/scheduler-autofix-select.test.cjs

@@ -8,7 +8,7 @@
 
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
-const { selectAutoFixTargets, isUnresolvableNeedsReview } = require('../scheduler.cjs');
+const { selectAutoFixTargets, isUnresolvableNeedsReview, isRescanCandidate } = require('../scheduler.cjs');
 
 const noSiblingOnDisk = () => false;
 const noRunDir = () => null;
@@ -140,4 +140,14 @@ test('defaults parallelGroup to 99 when absent', () => {
   assert.strictEqual(seen[0], '99-fix-my-feature');
 });
 
+test('isRescanCandidate: needs_review + runId + no_verdict_sentinel → true (RESCANNABLE_VERDICTS includes it)', () => {
+  const job = makeJob({ verifierVerdict: 'no_verdict_sentinel' });
+  assert.strictEqual(isRescanCandidate(job), true);
+});
+
+test('isRescanCandidate: needs_review + runId + uncommitted_changes → false (git commit-guard verdict stays excluded)', () => {
+  const job = makeJob({ verifierVerdict: 'uncommitted_changes' });
+  assert.strictEqual(isRescanCandidate(job), false);
+});
+
 console.log('scheduler-autofix-select tests: PASS');

package/src/main/__tests__/scheduler-committed-in-window.test.cjs

@@ -0,0 +1,62 @@
+/**
+ * scheduler-committed-in-window.test.cjs — unit tests for committedInWindow.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-committed-in-window.test.cjs
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { committedInWindow } = require('../scheduler.cjs');
+
+function git(cwd, args) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8' }).trim();
+}
+
+function makeRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-'));
+  git(dir, ['init', '-q']);
+  git(dir, ['config', 'user.email', 'test@example.com']);
+  git(dir, ['config', 'user.name', 'Test']);
+  fs.writeFileSync(path.join(dir, 'base.txt'), 'base\n');
+  git(dir, ['add', '.']);
+  git(dir, ['commit', '-q', '-m', 'base']);
+  return dir;
+}
+
+test('committedInWindow returns true for a commit landed on a non-checked-out branch', async () => {
+  const dir = makeRepo();
+  try {
+    git(dir, ['checkout', '-q', '-b', 'work']);
+
+    const startedAt = new Date().toISOString();
+    fs.writeFileSync(path.join(dir, 'feature.txt'), 'feature\n');
+    git(dir, ['add', '.']);
+    git(dir, ['commit', '-q', '-m', 'feature commit']);
+    const finishedAt = new Date(Date.now() + 1000).toISOString();
+
+    // Simulate the run leaving a different branch checked out at exit.
+    git(dir, ['checkout', '-q', '-b', 'other-branch-at-exit']);
+
+    const result = await committedInWindow(dir, startedAt, finishedAt);
+    expect(result).toBe(true);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('committedInWindow returns false when the window covers no commit', async () => {
+  const dir = makeRepo();
+  try {
+    const farFutureStart = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString();
+    const farFutureEnd = new Date(Date.now() + 366 * 24 * 60 * 60 * 1000).toISOString();
+
+    const result = await committedInWindow(dir, farFutureStart, farFutureEnd);
+    expect(result).toBe(false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/main/browserView.cjs

@@ -344,7 +344,7 @@ function handleRecordEvent(event, payload) {
   const viewId = contentsIdToViewId.get(event.sender.id);
   if (!viewId || !recordingViewIds.has(viewId)) return;
   const verb = payload && payload.verb;
-  if (verb !== 'click' && verb !== 'type') return;
+  if (verb !== 'click' && verb !== 'type' && verb !== 'drag') return;
   const target = typeof payload.target === 'string' ? payload.target.slice(0, 300) : '';
   const step = { verb, target };
   if (verb === 'type') {
@@ -353,6 +353,19 @@ function handleRecordEvent(event, payload) {
       step.variableSuggestion = payload.variableSuggestion.slice(0, 64);
     }
   }
+  if (verb === 'click') {
+    const x = Number(payload.x);
+    const y = Number(payload.y);
+    if (Number.isFinite(x)) step.x = x;
+    if (Number.isFinite(y)) step.y = y;
+  }
+  if (verb === 'drag') {
+    if (typeof payload.endTarget === 'string') step.endTarget = payload.endTarget.slice(0, 300);
+    for (const key of ['x', 'y', 'endX', 'endY']) {
+      const n = Number(payload[key]);
+      if (Number.isFinite(n)) step[key] = n;
+    }
+  }
   emitRecordStep(viewId, step);
 }
 
@@ -371,7 +384,16 @@ function withTimeout(promise, ms, label) {
   return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
 
+async function replayPositionedClick(wc, x, y) {
+  wc.sendInputEvent({ type: 'mouseDown', x, y, button: 'left', clickCount: 1 });
+  wc.sendInputEvent({ type: 'mouseUp', x, y, button: 'left', clickCount: 1 });
+}
+
 async function replayClickOrType(wc, step, values) {
+  if (step.verb === 'click' && Number.isFinite(step.x) && Number.isFinite(step.y)) {
+    await replayPositionedClick(wc, step.x, step.y);
+    return;
+  }
   const script =
     step.verb === 'type'
       ? `(() => {
@@ -429,6 +451,25 @@ async function replayWaitFor(wc, step) {
   }
 }
 
+const REPLAY_DRAG_STEPS = 3;
+
+async function replayDrag(wc, step) {
+  const { x, y, endX, endY } = step;
+  if (![x, y, endX, endY].every((n) => Number.isFinite(n))) {
+    throw new Error('drag step missing coordinates');
+  }
+  wc.sendInputEvent({ type: 'mouseDown', x, y, button: 'left', clickCount: 1 });
+  for (let i = 1; i <= REPLAY_DRAG_STEPS; i += 1) {
+    const t = i / REPLAY_DRAG_STEPS;
+    wc.sendInputEvent({
+      type: 'mouseMove',
+      x: Math.round(x + (endX - x) * t),
+      y: Math.round(y + (endY - y) * t),
+    });
+  }
+  wc.sendInputEvent({ type: 'mouseUp', x: endX, y: endY, button: 'left', clickCount: 1 });
+}
+
 async function replayStep(view, step, values) {
   const wc = view.webContents;
   if (step.verb === 'navigate') {
@@ -445,6 +486,10 @@ async function replayStep(view, step, values) {
     await replayWaitFor(wc, step);
     return;
   }
+  if (step.verb === 'drag') {
+    await withTimeout(replayDrag(wc, step), REPLAY_STEP_TIMEOUT_MS, 'drag');
+    return;
+  }
   throw new Error(`unsupported step verb: ${step.verb}`);
 }
 

package/src/main/index.cjs

@@ -434,6 +434,25 @@ ipcMain.handle('app:pick-directory', async () => {
 
 ipcMain.on('app:reboot-app', () => rebootApp());
 
+// Recorder export "Save to file…" (PRD 412) — native Save As dialog, written
+// directly since the path is user-chosen, not renderer input.
+ipcMain.handle('browser:save-recording', validated(schemas.browserSaveRecording, async ({ defaultName, text }) => {
+  try {
+    const result = await dialog.showSaveDialog(mainWindow, {
+      defaultPath: defaultName,
+      filters: [
+        { name: 'Markdown', extensions: ['md'] },
+        { name: 'All Files', extensions: ['*'] },
+      ],
+    });
+    if (result.canceled || !result.filePath) return { ok: false, canceled: true };
+    await fsp.writeFile(result.filePath, text, 'utf8');
+    return { ok: true, path: result.filePath };
+  } catch (e) {
+    return { ok: false, error: e && e.message ? e.message : String(e) };
+  }
+}));
+
 // Image paste — Ctrl+V in the Terminal pane. Reads the OS clipboard via
 // Electron's native API (renderer's navigator.clipboard.read() doesn't expose
 // raw image MIME types under contextIsolation), saves the bitmap to a temp
@@ -469,6 +488,16 @@ ipcMain.handle('clipboard:paste-text', async () => {
   }
 });
 
+// Recorder export "Copy to clipboard" (PRD 412) — write side.
+ipcMain.handle('clipboard:write-text', validated(schemas.clipboardWriteText, ({ text }) => {
+  try {
+    clipboard.writeText(text);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e && e.message ? e.message : String(e) };
+  }
+}));
+
 // PRD 407 Capture panel — write side of paste-image's read. Writes a
 // screenshot capture to the OS clipboard as an image.
 ipcMain.handle('browser:copy-image', validated(schemas.browserCopyImage, ({ dataUrl }) => {

package/src/main/ipcSchemas.cjs

@@ -96,6 +96,19 @@ const browserCopyImage = z.object({
   dataUrl: z.string().min(1).max(50_000_000),
 });
 
+// Recorder export (PRD 412): write arbitrary recorded-flow text to the OS
+// clipboard, separate from the image-only browserCopyImage above.
+const clipboardWriteText = z.object({
+  text: z.string().max(1_000_000),
+});
+
+// Recorder export (PRD 412): native "Save As" dialog write, bypassing the
+// config.cjs write-boundary since the path is user-chosen via OS dialog.
+const browserSaveRecording = z.object({
+  defaultName: z.string().min(1).max(255),
+  text: z.string().max(1_000_000),
+});
+
 // PRD 407: binary-safe atomic write (browser:save-binary) for screenshot
 // captures — config:write-text is utf8-only.
 const browserSaveBinary = z.object({
@@ -621,6 +634,8 @@ module.exports = {
     browserCaptureSelection,
     browserCopyImage,
     browserSaveBinary,
+    clipboardWriteText,
+    browserSaveRecording,
     browserReplay,
     browserSetZoom,
     browserFind,

package/src/main/lib/definitionOfDone.cjs

@@ -533,6 +533,42 @@ function writeReport(key, { acResults = [], riskFlags = [], runsDir } = {}) {
   return reportPath;
 }
 
+const WATERMARK_FILENAME = '.dod-watermark.json';
+
+/**
+ * Read the persisted "last finished" watermark used to bound which completed
+ * jobs get reverified on each drain. Never throws — a missing or unparseable
+ * sidecar means "beginning of time" (process everything), matching the
+ * pre-watermark unbounded behavior on first-ever drain.
+ *
+ * @param {string} [runsDir] Override for testing; defaults to RUNS_DIR
+ * @returns {string|null}  ISO8601 timestamp, or null if unset/unreadable.
+ */
+function readWatermark(runsDir = RUNS_DIR) {
+  try {
+    const raw = fs.readFileSync(path.join(runsDir, WATERMARK_FILENAME), 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed.lastFinishedAt === 'string' ? parsed.lastFinishedAt : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist the "last finished" watermark so the next drain only reverifies
+ * jobs that completed after it.
+ *
+ * @param {string} lastFinishedAt  ISO8601 timestamp.
+ * @param {string} [runsDir]       Override for testing; defaults to RUNS_DIR
+ */
+function writeWatermark(lastFinishedAt, runsDir = RUNS_DIR) {
+  fs.mkdirSync(runsDir, { recursive: true });
+  _writeFileAtomic(
+    path.join(runsDir, WATERMARK_FILENAME),
+    JSON.stringify({ lastFinishedAt }, null, 2)
+  );
+}
+
 module.exports = {
   batchKey,
   reportPathFor,
@@ -542,4 +578,6 @@ module.exports = {
   reverifyBatch,
   flagRiskySurfaces,
   writeReport,
+  readWatermark,
+  writeWatermark,
 };

package/src/main/lib/dodDrainHook.cjs

@@ -21,6 +21,8 @@ const {
   reverifyBatch,
   flagRiskySurfaces,
   writeReport,
+  readWatermark,
+  writeWatermark,
 } = require('./definitionOfDone.cjs');
 
 // Track keys whose DoD pass is currently in-flight.
@@ -58,7 +60,19 @@ async function runDefinitionOfDoneOnDrain(state, opts = {}) {
   if (state.paused) return;
   if (cancelToken.cancelled) return;
 
-  const completedJobs = (state.jobs || []).filter(j => j.status === 'completed');
+  const allCompleted = (state.jobs || []).filter(j => j.status === 'completed');
+  if (allCompleted.length === 0) return;
+
+  // Watermark: only reverify jobs that finished after the last DoD report.
+  // Jobs missing finishedAt are treated as older than any real watermark
+  // (excluded once a watermark exists; included on the first-ever drain when
+  // watermark is null, preserving back-compat with the unbounded behavior).
+  const wmIso = readWatermark(runsDir);            // null on first-ever drain
+  const wm = wmIso ? new Date(wmIso).getTime() : 0; // 0 = beginning of time
+  const completedJobs = allCompleted.filter(j => {
+    const t = j.finishedAt ? new Date(j.finishedAt).getTime() : NaN;
+    return wm === 0 ? true : (Number.isFinite(t) && t > wm);
+  });
   if (completedJobs.length === 0) return;
 
   const key = batchKey(completedJobs);
@@ -73,6 +87,14 @@ async function runDefinitionOfDoneOnDrain(state, opts = {}) {
     if (cancelToken.cancelled) return;
     const riskFlags = flagRiskySurfaces(completedJobs, { prdsDir });
     writeReport(key, { acResults, riskFlags, runsDir });
+
+    // Advance watermark to the newest finishedAt we just covered, so the next
+    // drain excludes this batch. Guard against jobs with no/invalid finishedAt.
+    const maxFinished = completedJobs
+      .map(j => (j.finishedAt ? new Date(j.finishedAt).getTime() : NaN))
+      .filter(Number.isFinite)
+      .reduce((a, b) => Math.max(a, b), wm);
+    if (maxFinished > wm) writeWatermark(new Date(maxFinished).toISOString(), runsDir);
   } finally {
     _inFlight.delete(key);
   }

package/src/main/runVerify.cjs

@@ -628,6 +628,22 @@ async function verifyRun({ runDir, prdPath, queueEntry, allJobs = [], committedD
       });
     }
 
+    // A truthful-looking PASS sentinel with no commit is still not "clean":
+    // the finish protocol requires the commit to land before printing PASS
+    // (see the module's finish-protocol docs), so a PASS with no commit means
+    // the run's own claim of success is unsubstantiated — route it to
+    // needs_review so the auto-fix pipeline can investigate rather than
+    // silently accepting a bare sentinel as proof of work done. Mutually
+    // exclusive with the no_verdict_sentinel case above (sentinel === null
+    // vs sentinel === 'pass'), kept as a separate sibling check for clarity.
+    if (sentinel === 'pass' && !committedDuringRun) {
+      issues.push({
+        verdict: 'pass_no_commit',
+        reason: 'SCHEDULER_VERDICT: PASS but no commit landed during the run window — the run claims success but produced no code change',
+        priority: 1,
+      });
+    }
+
     if (issues.length === 0) {
       const reason = annotations.length
         ? `no blocking issues (${annotations.length} annotation(s): ${annotations.map((a) => a.reason).join('; ')})`