claude-code-session-manager 0.80.0 → 0.81.0

package/src/main/lib/__tests__/fixtures/204-mercury-steam-horse.log.txt

@@ -0,0 +1,13 @@
+[scheduler] starting 204-mercury-steam-horse at 2026-09-05T16:32:31.039Z
+[scheduler] cwd=/home/bilko/Projects/starry-night-ships (running isolated in worktree /tmp/session-manager-job-worktrees/443997d5bbc5f8ab/204-mercury-steam-horse)
+
+[scheduler] agentType=dev-lead persona=/home/bilko/.claude/agents/dev-lead.md model=fable
+[scheduler] spawned pid=3537290 sessionId=5cb9d69b-e2e7-49f9-806c-2307f1c94b2b (process group)
+
+{"type":"rate_limit_event","rate_limit_info":{"status":"allowed_warning","resetsAt":1789059600,"rateLimitType":"seven_day","utilization":0.59,"isUsingOverage":false,"unifiedWindows":{"five_hour":{"utilization":0,"resetsAt":1788643800},"seven_day":{"utilization":0.59,"resetsAt":1789059600}}},"uuid":"f7ef520a-9c3f-470e-89de-4ba9af7d5968","session_id":"5cb9d69b-e2e7-49f9-806c-2307f1c94b2b"}
+{"type":"system","subtype":"init","cwd":"/tmp/session-manager-job-worktrees/443997d5bbc5f8ab/204-mercury-steam-horse","session_id":"5cb9d69b-e2e7-49f9-806c-2307f1c94b2b","tools":["Task","Bash","CronCreate","CronDelete","CronList","DesignSync","Edit","EnterWorktree","ExitWorktree","ListAgents","ListMcpResourcesTool","Monitor","NotebookEdit","PushNotification","Read","ReadMcpResourceDirTool","ReadMcpResourceTool","RemoteTrigger","ReportFindings","ScheduleWakeup","SendMessage","Skill","TaskOutput","TaskStop","ToolSearch","WebFetch","WebSearch","Workflow","Write","mcp__bilko-host__get_host_contract","mcp__bilko-host__list_projects","mcp__bilko-host__publish_static_project","mcp__bilko-host__register_static_project","mcp__bilko-host__status","mcp__bilko-host__unregister_project","mcp__bilko-host__usage_report","mcp__claude_ai_Gmail__apply_sensitive_message_label","mcp__claude_ai_Gmail__apply_sensitive_thread_label","mcp__claude_ai_Gmail__create_draft","mcp__claude_ai_Gmail__create_label","mcp__claude_ai_Gmail__delete_label","mcp__claude_ai_Gmail__forward","mcp__claude_ai_Gmail__get_draft","mcp__claude_ai_Gmail__get_message","mcp__claude_ai_Gmail__get_thread","mcp__claude_ai_Gmail__label_message","mcp__claude_ai_Gmail__label_thread","mcp__claude_ai_Gmail__list_drafts","mcp__claude_ai_Gmail__list_labels","mcp__claude_ai_Gmail__mark_message_spam","mcp__claude_ai_Gmail__mark_thread_spam","mcp__claude_ai_Gmail__reply","mcp__claude_ai_Gmail__search_threads","mcp__claude_ai_Gmail__send_message","mcp__claude_ai_Gmail__trash_message","mcp__claude_ai_Gmail__trash_thread","mcp__claude_ai_Gmail__unlabel_message","mcp__claude_ai_Gmail__unlabel_thread","mcp__claude_ai_Gmail__unmark_message_spam","mcp__claude_ai_Gmail__unmark_thread_spam","mcp__claude_ai_Gmail__untrash_message","mcp__claude_ai_Gmail__untrash_thread","mcp__claude_ai_Gmail__update_draft","mcp__claude_ai_Gmail__update_label","mcp__claude_ai_Gmail__update_message_labels","mcp__fetch__fetch","mcp__godot__add_node","mcp__godot__create_scene","mcp__godot__export_mesh_library","mcp__godot__get_debug_output","mcp__godot__get_godot_version","mcp__godot__get_project_info","mcp__godot__get_uid","mcp__godot__launch_editor","mcp__godot__list_projects","mcp__godot__load_sprite","mcp__godot__run_project","mcp__godot__save_scene","mcp__godot__stop_project","mcp__godot__update_project_uids","mcp__google-workspace__batch_modify_gmail_message_labels","mcp__google-workspace__batch_update_doc","mcp__google-workspace__check_drive_file_public_access","mcp__google-workspace__copy_drive_file","mcp__google-workspace__create_calendar","mcp__google-workspace__create_doc","mcp__google-workspace__create_drive_file","mcp__google-workspace__create_drive_folder","mcp__google-workspace__create_reaction","mcp__google-workspace__create_table_with_data","mcp__google-workspace__debug_docs_runtime_info","mcp__google-workspace__debug_table_structure","mcp__google-workspace__download_chat_attachment","mcp__google-workspace__draft_gmail_message","mcp__google-workspace__export_doc_to_pdf","mcp__google-workspace__find_and_replace_doc","mcp__google-workspace__get_doc_as_markdown","mcp__google-workspace__get_doc_content","mcp__google-workspace__get_drive_file_content","mcp__google-workspace__get_drive_file_download_url","mcp__google-workspace__get_drive_file_permissions","mcp__google-workspace__get_drive_shareable_link","mcp__google-workspace__get_events","mcp__google-workspace__get_gmail_attachment_content","mcp__google-workspace__get_gmail_message_content","mcp__google-workspace__get_gmail_messages_content_batch","mcp__google-workspace__get_gmail_thread_content","mcp__google-workspace__get_gmail_threads_content_batch","mcp__google-workspace__get_messages","mcp__google-workspace__import_to_google_doc","mcp__google-workspace__import_to_google_sheets","mcp__google-workspace__import_to_google_slides","mcp__google-workspace__insert_doc_elements","mcp__google-workspace__insert_doc_image","mcp__google-workspace__inspect_doc_structure","mcp__google-workspace__list_calendars","mcp__google-workspace__list_docs_in_folder","mcp__google-workspace__list_document_comments","mcp__google-workspace__list_drive_items","mcp__google-workspace__list_gmail_filters","mcp__google-workspace__list_gmail_labels","mcp__google-workspace__list_spaces","mcp__google-workspace__manage_doc_tab","mcp__google-workspace__manage_document_comment","mcp__google-workspace__manage_drive_access","mcp__google-workspace__manage_event","mcp__google-workspace__manage_focus_time","mcp__google-workspace__manage_gmail_filter","mcp__google-workspace__manage_gmail_label","mcp__google-workspace__manage_out_of_office","mcp__google-workspace__modify_doc_text","mcp__google-workspace__modify_gmail_message_labels","mcp__google-workspace__query_freebusy","mcp__google-workspace__search_docs","mcp__google-workspace__search_drive_files","mcp__google-workspace__search_gmail_messages","mcp__google-workspace__search_messages","mcp__google-workspace__send_gmail_message","mcp__google-workspace__send_message","mcp__google-workspace__set_drive_file_permissions","mcp__google-workspace__start_google_auth","mcp__google-workspace__update_doc_headers_footers","mcp__google-workspace__update_drive_file","mcp__google-workspace__update_paragraph_style","mcp__playwright__browser_click","mcp__playwright__browser_close","mcp__playwright__browser_console_messages","mcp__playwright__browser_drag","mcp__playwright__browser_drop","mcp__playwright__browser_evaluate","mcp__playwright__browser_file_upload","mcp__playwright__browser_fill_form","mcp__playwright__browser_handle_dialog","mcp__playwright__browser_hover","mcp__playwright__browser_navigate","mcp__playwright__browser_navigate_back","mcp__playwright__browser_network_request","mcp__playwright__browser_network_requests","mcp__playwright__browser_press_key","mcp__playwright__browser_resize","mcp__playwright__browser_run_code_unsafe","mcp__playwright__browser_select_option","mcp__playwright__browser_snapshot","mcp__playwright__browser_tabs","mcp__playwright__browser_take_screenshot","mcp__playwright__browser_type","mcp__playwright__browser_wait_for","mcp__session-manager-scheduler__chat_send_prompt","mcp__session-manager-scheduler__feedback_list_projects","mcp__session-manager-scheduler__feedback_open_session","mcp__session-manager-scheduler__project_home_get_contract","mcp__session-manager-scheduler__project_home_render","mcp__session-manager-scheduler__project_home_status","mcp__session-manager-scheduler__project_home_validate_summary","mcp__session-manager-scheduler__scheduler_archive_prd","mcp__session-manager-scheduler__scheduler_cancel_job","mcp__session-manager-scheduler__scheduler_create_prd","mcp__session-manager-scheduler__scheduler_get_prd","mcp__session-manager-scheduler__scheduler_list_jobs","mcp__session-manager-scheduler__scheduler_list_prds","mcp__session-manager-scheduler__scheduler_reset_job","mcp__session-manager-scheduler__scheduler_retag_prd","mcp__session-manager-scheduler__scheduler_update_prd","mcp__session-manager-scheduler__session_manager_help"],"mcp_servers":[{"name":"plugin:stripe:stripe","status":"needs-auth"},{"name":"fetch","status":"connected"},{"name":"sqlite","status":"failed"},{"name":"playwright","status":"connected"},{"name":"google-workspace","status":"connected"},{"name":"n8n","status":"failed"},{"name":"session-manager-scheduler","status":"connected"},{"name":"bilko-host","status":"connected"},{"name":"godot","status":"connected"},{"name":"claude.ai Google Calendar","status":"needs-auth"},{"name":"claude.ai Google Drive","status":"needs-auth"},{"name":"claude.ai Gmail","status":"connected"}],"model":"claude-fable-5-1","permissionMode":"bypassPermissions","slash_commands":["refresh-claude-md","deep-research","stripe:explain-error","stripe:test-cards","session-manager-dev:blog-for-project-feature","session-manager-dev:builder","session-manager-dev:develop","session-manager-dev:discover-features","session-manager-dev:explain-to-me","session-manager-dev:find-opportunity","session-manager-dev:issue-address","session-manager-dev:local-project-health","session-manager-dev:memory-sanitation","session-manager-dev:ops-sweep","session-manager-dev:pr-review-sweep","session-manager-dev:pr-signal","session-manager-dev:project-status","session-manager-dev:requesting-code-review","session-manager-dev:send-feedback","stripe:connect-recommend","stripe:connect-required-verification-information","stripe:stripe-apps","stripe:stripe-best-practices","stripe:stripe-directory","stripe:stripe-docs","stripe:stripe-projects","stripe:upgrade-stripe","design-sync","dataviz","update-config","verify","debug","code-review","simplify","batch","fewer-permission-prompts","doctor","loop","schedule","claude-api","workflow-authoring","run","run-skill-generator","advisor","agents","auto-mode-setup","autocompact","clear","color","compact","config","context","effort","fast","heapdump","init","mcp","import","model","__remote-workflow","workflow-launch-exec","reload-plugins","reload-skills","rename","ultrareview","security-review","usage-credits","extra-usage","usage","insights","recap","skill-doctor","goal","design","design-consent","design-revoke","list-agents","team-onboarding","mcp__fetch__fetch"],"terminal_slash_commands":["doctor","color","reload-plugins"],"apiKeySource":"none","claude_code_version":"2.1.261","output_style":"default","agents":["architect","bilko-host-publisher","builder","claude","dev-lead","Explore","general-purpose","Plan","project-home-builder","statusline-setup","stripe:Company Researcher"],"skills":["deep-research","session-manager-dev:blog-for-project-feature","session-manager-dev:builder","session-manager-dev:develop","session-manager-dev:discover-features","session-manager-dev:explain-to-me","session-manager-dev:find-opportunity","session-manager-dev:issue-address","session-manager-dev:local-project-health","session-manager-dev:memory-sanitation","session-manager-dev:ops-sweep","session-manager-dev:pr-review-sweep","session-manager-dev:pr-signal","session-manager-dev:project-status","session-manager-dev:requesting-code-review","session-manager-dev:send-feedback","stripe:connect-recommend","stripe:connect-required-verification-information","stripe:stripe-apps","stripe:stripe-best-practices","stripe:stripe-directory","stripe:stripe-docs","stripe:stripe-projects","stripe:upgrade-stripe","design-sync","dataviz","update-config","verify","debug","code-review","simplify","batch","fewer-permission-prompts","doctor","loop","schedule","claude-api","workflow-authoring","run","run-skill-generator"],"plugins":[{"name":"session-manager-dev","path":"/home/bilko/Projects/session-manager/plugins/session-manager-dev","source":"session-manager-dev@session-manager","version":"0.1.0"},{"name":"stripe","path":"/home/bilko/.claude/plugins/cache/claude-plugins-official/stripe/0.6.4","source":"stripe@claude-plugins-official","version":"0.6.4"}],"capabilities":["interrupt_receipt_v1","interrupt_cancel_queued_v1","msg_lifecycle_v1"],"analytics_disabled":false,"product_feedback_disabled":false,"uuid":"7f8e3566-fc40-427c-a9ad-0c0719d7f3b2","memory_paths":{"auto":"/home/bilko/.claude/projects/-home-bilko-Projects-starry-night-ships/memory/"},"messaging_socket_path":"/run/user/1000/cc-socks/3537290.sock","fast_mode_state":"off","fast_mode_disabled_reason":"sdk_opt_in_required"}
+{"type":"rate_limit_event","rate_limit_info":{"status":"rejected","resetsAt":1789059600,"rateLimitType":"seven_day_overage_included","overageStatus":"rejected","overageDisabledReason":"org_level_disabled","isUsingOverage":false,"unifiedWindows":{"five_hour":{"utilization":0,"resetsAt":1788643800},"seven_day":{"utilization":0.59,"resetsAt":1789059600},"seven_day_overage_included":{"utilization":1,"resetsAt":1789059600}}},"uuid":"faa8b505-db69-4afe-9436-9c812b76569a","session_id":"5cb9d69b-e2e7-49f9-806c-2307f1c94b2b"}
+{"type":"assistant","message":{"diagnostics":null,"id":"dcbde611-72e9-4f07-bc35-c8ec9911f789","container":null,"model":"<synthetic>","role":"assistant","stop_details":null,"stop_reason":"stop_sequence","stop_sequence":"","type":"message","usage":{"output_tokens_details":null,"input_tokens":0,"output_tokens":0,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"server_tool_use":{"web_search_requests":0,"web_fetch_requests":0},"service_tier":null,"cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"inference_geo":null,"iterations":null,"speed":null},"content":[{"type":"text","text":"You've reached your Fable limit. Switch to another model, or manage usage credits at claude.ai/settings/usage?from=cc_cli_limit_message, to continue."}],"context_management":null},"parent_tool_use_id":null,"session_id":"5cb9d69b-e2e7-49f9-806c-2307f1c94b2b","uuid":"a651974e-39c4-440f-a34e-eeec87e65fa4","timestamp":"2026-09-05T16:32:35.275Z","error":"rate_limit","request_id":"req_011CekcYKs4mrLVHXVc5xC2X","is_api_error_message":true}
+{"duration_api_ms":1120,"stop_reason":"stop_sequence","session_id":"5cb9d69b-e2e7-49f9-806c-2307f1c94b2b","total_cost_usd":0.005226,"usage":{"output_tokens_details":{"thinking_tokens":0},"input_tokens":0,"cache_creation_input_tokens":0,"cache_read_input_tokens":0,"output_tokens":0,"server_tool_use":{"web_search_requests":0,"web_fetch_requests":0},"service_tier":"standard","cache_creation":{"ephemeral_1h_input_tokens":0,"ephemeral_5m_input_tokens":0},"inference_geo":"","iterations":[],"speed":"standard"},"modelUsage":{"claude-haiku-4-5-20251001":{"inputTokens":5161,"outputTokens":13,"cacheReadInputTokens":0,"cacheCreationInputTokens":0,"webSearchRequests":0,"costUSD":0.005226,"contextWindow":200000,"maxOutputTokens":32000,"thinkingTokens":0,"canonicalModel":"claude-haiku-4-5","provider":"firstParty","costBasis":"list"}},"permission_denials":[],"terminal_reason":"api_error","fast_mode_state":"off","fast_mode_disabled_reason":"sdk_opt_in_required","subagent_stats":{"spawned":0,"requested":{"background":0,"foreground":0,"unset":0},"started_in_background":0,"max_depth":0,"spawned_by_subagents":0,"completed":0,"failed":0,"killed":{"parent":0,"user":0,"system":0},"refused":{"depth_limit":0,"concurrency_limit":0,"budget":0},"by_type":{}},"is_error":true,"num_turns":1,"subtype":"success","api_error_status":429,"result":"You've reached your Fable limit. Switch to another model, or manage usage credits at claude.ai/settings/usage?from=cc_cli_limit_message, to continue.","type":"result","duration_ms":1036,"uuid":"b729d2fe-95bd-41a0-9558-eb7149222eb3","queued_turn_count":0}
+
+[scheduler] exit code=1 (raw code=1 signal=null) duration=5s

package/src/main/lib/__tests__/landedSinceRun.test.cjs

@@ -13,7 +13,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { landedSinceRun } = require('../landedSinceRun.cjs');
+const { landedSinceRun, landedOnMainSince } = require('../landedSinceRun.cjs');
 
 function mkRepo() {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-since-run-'));
@@ -23,6 +23,16 @@ function mkRepo() {
   return dir;
 }
 
+// -b main pins the branch name regardless of the host's init.defaultBranch
+// config — landedOnMainSince's tests need a deterministic 'main' ref.
+function mkRepoOnMain() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-on-main-'));
+  execFileSync('git', ['-C', dir, 'init', '-q', '-b', 'main']);
+  execFileSync('git', ['-C', dir, 'config', 'user.email', 'test@test.com']);
+  execFileSync('git', ['-C', dir, 'config', 'user.name', 'Test']);
+  return dir;
+}
+
 function commitFile(dir, relPath, content, message) {
   const abs = path.join(dir, relPath);
   fs.mkdirSync(path.dirname(abs), { recursive: true });
@@ -71,3 +81,53 @@ test('has a bounded default timeout', () => {
   const { LANDED_SINCE_RUN_TIMEOUT_MS } = require('../landedSinceRun.cjs');
   assert.ok(LANDED_SINCE_RUN_TIMEOUT_MS > 0 && LANDED_SINCE_RUN_TIMEOUT_MS <= 60_000);
 });
+
+// landedOnMainSince — PRD 1136's already-satisfied-on-main evidence query:
+// scoped to `main` (not --all) and to the PRD's declared paths.
+
+test('landedOnMainSince: finds a commit on main after sinceIso touching a declared path', async () => {
+  const dir = mkRepoOnMain();
+  commitFile(dir, 'README.md', 'hello', 'initial');
+  const since = new Date().toISOString();
+  await new Promise((r) => setTimeout(r, 1100));
+  commitFile(dir, 'src/foo.js', 'hello', 'fix foo');
+  const shas = await landedOnMainSince(dir, since, ['src/foo.js']);
+  assert.strictEqual(shas.length, 1);
+});
+
+test('landedOnMainSince: ignores a commit that does not touch any declared path', async () => {
+  const dir = mkRepoOnMain();
+  commitFile(dir, 'README.md', 'hello', 'initial');
+  const since = new Date().toISOString();
+  await new Promise((r) => setTimeout(r, 1100));
+  commitFile(dir, 'src/unrelated.js', 'hello', 'touch unrelated');
+  const shas = await landedOnMainSince(dir, since, ['src/foo.js']);
+  assert.deepStrictEqual(shas, []);
+});
+
+test('landedOnMainSince: a commit older than sinceIso is not evidence', async () => {
+  const dir = mkRepoOnMain();
+  commitFile(dir, 'src/foo.js', 'hello', 'fix foo');
+  await new Promise((r) => setTimeout(r, 1100));
+  const since = new Date().toISOString();
+  const shas = await landedOnMainSince(dir, since, ['src/foo.js']);
+  assert.deepStrictEqual(shas, []);
+});
+
+test('landedOnMainSince: empty paths never fabricates evidence — resolves []', async () => {
+  const dir = mkRepoOnMain();
+  commitFile(dir, 'src/foo.js', 'hello', 'fix foo');
+  const shas = await landedOnMainSince(dir, new Date(0).toISOString(), []);
+  assert.deepStrictEqual(shas, []);
+});
+
+test('landedOnMainSince: no cwd resolves [] without throwing', async () => {
+  const shas = await landedOnMainSince(null, new Date().toISOString(), ['src/foo.js']);
+  assert.deepStrictEqual(shas, []);
+});
+
+test('landedOnMainSince: git-unavailable (non-repo cwd) resolves [] without throwing', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'landed-on-main-norepo-'));
+  const shas = await landedOnMainSince(dir, new Date().toISOString(), ['src/foo.js']);
+  assert.deepStrictEqual(shas, []);
+});

package/src/main/lib/__tests__/rateLimitWindow.test.cjs

@@ -0,0 +1,88 @@
+/**
+ * rateLimitWindow.test.cjs — resolveBindingRateLimitReset: reads the log's
+ * OWN rate_limit_event windows and returns the reset of whichever window
+ * actually bound (utilization >= 1.0), not the billing endpoint's five_hour
+ * assumption (PRD 1118).
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/rateLimitWindow.test.cjs
+ */
+
+'use strict';
+
+import { test } from 'vitest';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { resolveBindingRateLimitReset } = require('../rateLimitWindow.cjs');
+
+// Repo-tracked, byte-for-byte copy of the real incident log (2026-09-05
+// starry-night-ships 429) so this test is hermetic — CI, a fresh clone, or
+// this machine's own run-log retention sweep (runLogRetention.test.cjs)
+// pruning the live copy must not turn this red for reasons unrelated to the
+// code under test.
+const TRACKED_FIXTURE = path.join(__dirname, 'fixtures', '204-mercury-steam-horse.log.txt');
+const REAL_FIXTURE_LIVE_PATH = '/home/bilko/.claude/session-manager/scheduled-plans/runs/2026-09-05T16-32-18-381Z/204-mercury-steam-horse.log';
+
+test('tracked fixture (verbatim copy of the real incident log): seven_day_overage_included (utilization 1.0) binds, not five_hour', () => {
+  const reset = resolveBindingRateLimitReset(TRACKED_FIXTURE);
+  assert.strictEqual(reset, 1789059600);
+  assert.notStrictEqual(reset, 1788643800);
+});
+
+test('tracked fixture is byte-identical to the live incident log, when present on this machine', () => {
+  if (!fs.existsSync(REAL_FIXTURE_LIVE_PATH)) return; // machine-local artifact, not guaranteed to exist
+  assert.strictEqual(
+    fs.readFileSync(TRACKED_FIXTURE, 'utf8'),
+    fs.readFileSync(REAL_FIXTURE_LIVE_PATH, 'utf8'),
+  );
+});
+
+function writeTmpLog(lines) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rate-limit-window-test-'));
+  const file = path.join(dir, 'job.log');
+  fs.writeFileSync(file, lines.map((l) => (typeof l === 'string' ? l : JSON.stringify(l))).join('\n') + '\n');
+  return file;
+}
+
+test('no rate_limit_event in log → null', () => {
+  const logPath = writeTmpLog(['[scheduler] starting job', '{"type":"system","subtype":"init"}']);
+  assert.strictEqual(resolveBindingRateLimitReset(logPath), null);
+});
+
+test('rate_limit_event present but no window at/above 1.0 utilization → null', () => {
+  const logPath = writeTmpLog([
+    { type: 'rate_limit_event', rate_limit_info: { unifiedWindows: {
+      five_hour: { utilization: 0, resetsAt: 1788643800 },
+      seven_day: { utilization: 0.59, resetsAt: 1789059600 },
+    } } },
+  ]);
+  assert.strictEqual(resolveBindingRateLimitReset(logPath), null);
+});
+
+test('multiple windows bind in the last event → the LATEST reset wins', () => {
+  const logPath = writeTmpLog([
+    { type: 'rate_limit_event', rate_limit_info: { unifiedWindows: {
+      five_hour: { utilization: 1.0, resetsAt: 1000 },
+      seven_day: { utilization: 1.0, resetsAt: 2000 },
+    } } },
+  ]);
+  assert.strictEqual(resolveBindingRateLimitReset(logPath), 2000);
+});
+
+test('uses the LAST rate_limit_event in the log, not the first', () => {
+  const logPath = writeTmpLog([
+    { type: 'rate_limit_event', rate_limit_info: { unifiedWindows: {
+      seven_day: { utilization: 0.3, resetsAt: 111 },
+    } } },
+    { type: 'other' },
+    { type: 'rate_limit_event', rate_limit_info: { unifiedWindows: {
+      seven_day_overage_included: { utilization: 1.0, resetsAt: 999 },
+    } } },
+  ]);
+  assert.strictEqual(resolveBindingRateLimitReset(logPath), 999);
+});
+
+test('missing file → null (best-effort, matches readTail contract)', () => {
+  assert.strictEqual(resolveBindingRateLimitReset('/nonexistent/path/job.log'), null);
+});

package/src/main/lib/__tests__/reaperHelpers.test.cjs

@@ -19,7 +19,12 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { selectReapableJobs, mapOutcomeToGateOutcome, classifyRunOutcome } = require('../reaperHelpers.cjs');
+const { spawn } = require('node:child_process');
+const {
+  selectReapableJobs, mapOutcomeToGateOutcome, classifyRunOutcome,
+  findLiveProcessForJob, logHasOutput, resolvePidlessGateOutcome,
+  isAlreadySatisfiedOnMain,
+} = require('../reaperHelpers.cjs');
 const { detectRateLimitInLog } = require('../rateLimitDetect.cjs');
 
 const NOW = Date.parse('2026-09-01T12:00:00.000Z');
@@ -101,6 +106,33 @@ test('non-running rows are never considered, pidless or not', () => {
   assert.deepStrictEqual(warnings, []);
 });
 
+test('pidless + past grace + findLiveProcess finds a pid → recovered, never reaped', () => {
+  const jobs = [{ slug: 'zombie-alive', status: 'running', startedAt: agoMin(464) }];
+  const findLiveProcess = () => 2174739;
+  const { reapable, recovered, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE, findLiveProcess });
+  assert.deepStrictEqual(reapable, []);
+  assert.deepStrictEqual(warnings, []);
+  assert.strictEqual(recovered.length, 1);
+  assert.strictEqual(recovered[0].slug, 'zombie-alive');
+  assert.strictEqual(recovered[0].pid, 2174739);
+});
+
+test('pidless + past grace + findLiveProcess finds nothing → reaped exactly as today', () => {
+  const jobs = [{ slug: 'zombie-dead', status: 'running', startedAt: agoMin(464) }];
+  const findLiveProcess = () => null;
+  const { reapable, recovered } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE, findLiveProcess });
+  assert.deepStrictEqual(recovered, []);
+  assert.strictEqual(reapable.length, 1);
+  assert.strictEqual(reapable[0].pidless, true);
+});
+
+test('pidless + past grace + no findLiveProcess supplied → reaped exactly as before this PRD', () => {
+  const jobs = [{ slug: 'zombie', status: 'running', startedAt: agoMin(464) }];
+  const { reapable, recovered } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
+  assert.strictEqual(reapable.length, 1);
+  assert.deepStrictEqual(recovered, []);
+});
+
 test('mixed batch: each row classified independently', () => {
   const jobs = [
     { slug: 'zombie', status: 'running', startedAt: agoMin(464) },
@@ -220,3 +252,90 @@ test('classifyRunOutcome: a clean success log still classifies as success', () =
   const p = writeTmpLog('{"type":"result","subtype":"success","is_error":false,"result":"done"}\n');
   assert.strictEqual(classifyRunOutcome(p), 'success');
 });
+
+// findLiveProcessForJob — the /proc positive liveness scan behind the
+// 2026-09-06 stranded-branch incident (234-uranus-eight-tails-ox: marked
+// failed/never_ran while its process was alive and still writing to its
+// worktree). Linux-only, and a safe no-op everywhere else per its own header.
+
+test('findLiveProcessForJob: finds a live process via /proc/<pid>/cwd match', async () => {
+  if (process.platform !== 'linux' || !fs.existsSync('/proc')) return;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reaper-liveness-'));
+  const child = spawn('sleep', ['5'], { cwd: dir, stdio: 'ignore' });
+  try {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    const pid = findLiveProcessForJob({ slug: 'irrelevant-slug' }, { worktreeDir: dir });
+    assert.strictEqual(pid, child.pid);
+  } finally {
+    child.kill('SIGKILL');
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('findLiveProcessForJob: no live process anywhere → null', () => {
+  if (process.platform !== 'linux' || !fs.existsSync('/proc')) return;
+  const pid = findLiveProcessForJob(
+    { slug: 'definitely-not-a-real-running-slug-xyz123' },
+    { worktreeDir: '/nonexistent/worktree/dir/xyz123' },
+  );
+  assert.strictEqual(pid, null);
+});
+
+// logHasOutput — the literal "did the run dir produce any log output" check
+// that gates whether a pidless reap may assert gateOutcome: 'never_ran'.
+
+test('logHasOutput: missing file → false', () => {
+  assert.strictEqual(logHasOutput('/nonexistent/path/does-not-exist.log'), false);
+});
+
+test('logHasOutput: empty file → false', () => {
+  const p = writeTmpLog('');
+  assert.strictEqual(logHasOutput(p), false);
+});
+
+test('logHasOutput: file with content → true', () => {
+  const p = writeTmpLog('some real log output\n');
+  assert.strictEqual(logHasOutput(p), true);
+});
+
+test('logHasOutput: null path → false', () => {
+  assert.strictEqual(logHasOutput(null), false);
+});
+
+// resolvePidlessGateOutcome — never_ran is asserted ONLY when the run dir has
+// no log output; a run dir WITH output must not claim never_ran even if no
+// clean result event was found in it.
+
+test('resolvePidlessGateOutcome: no output → never_ran, regardless of raw outcome (terminalizes as today)', () => {
+  assert.strictEqual(resolvePidlessGateOutcome('no_result', false), 'never_ran');
+  assert.strictEqual(resolvePidlessGateOutcome('success', false), 'never_ran');
+});
+
+test('resolvePidlessGateOutcome: output present + no_result → failed, never never_ran', () => {
+  assert.strictEqual(resolvePidlessGateOutcome('no_result', true), 'failed');
+});
+
+test('resolvePidlessGateOutcome: output present + success → passed', () => {
+  assert.strictEqual(resolvePidlessGateOutcome('success', true), 'passed');
+});
+
+test('resolvePidlessGateOutcome: output present + failed → failed', () => {
+  assert.strictEqual(resolvePidlessGateOutcome('failed', true), 'failed');
+});
+
+// isAlreadySatisfiedOnMain — PRD 1136. Pure decision layer: given the
+// already-git-queried list of satisfying commits, decide whether the
+// commit-guard's 'silent_no_op' verdict should be overridden to 'completed'.
+
+test('isAlreadySatisfiedOnMain: a satisfying commit → completed-shaped verdict naming the sha', () => {
+  const verdict = isAlreadySatisfiedOnMain(['5de4134abc123', 'a96de98def456']);
+  assert.strictEqual(verdict.sha, '5de4134abc123');
+  assert.strictEqual(verdict.verdict, 'already_satisfied_on_main');
+  assert.match(verdict.reason, /5de4134abc123/);
+});
+
+test('isAlreadySatisfiedOnMain: no satisfying commits → null — the gate must not be weakened into always-passing', () => {
+  assert.strictEqual(isAlreadySatisfiedOnMain([]), null);
+  assert.strictEqual(isAlreadySatisfiedOnMain(null), null);
+  assert.strictEqual(isAlreadySatisfiedOnMain(undefined), null);
+});

package/src/main/lib/branchSweep.cjs

@@ -0,0 +1,127 @@
+/**
+ * branchSweep.cjs — periodic recovery for `sm-job/<slug>` branches whose
+ * owning job row was terminalized (or lost entirely) without the branch ever
+ * being merged back into its project's HEAD (PRD 1135).
+ *
+ * The reaper's own liveness check (reaperHelpers.cjs findLiveProcessForJob)
+ * stops NEW stranding at the source; this module recovers anything already
+ * stranded before that fix landed, or by a crash the liveness check can't
+ * cover (app killed between a job's commit and its own integrateJobBranch
+ * call). Two halves of one invariant — see the PRD body.
+ *
+ * Deliberately never deletes a branch (`git branch -D` or otherwise) —
+ * reclaiming disk is out of scope; this module only ever merges forward.
+ *
+ * Kept free of scheduler.cjs / electron / queueStore coupling (same reason
+ * reaperHelpers.cjs is separate — importable and unit-testable without
+ * requiring electron) — callers own persisting a `conflict` result onto a
+ * job row.
+ */
+'use strict';
+
+const { execFile } = require('node:child_process');
+const gitWorktree = require('./gitWorktree.cjs');
+
+function execGit(cwd, args, timeout = 20_000) {
+  return new Promise((resolve, reject) => {
+    execFile('git', ['-C', cwd, ...args], { timeout, windowsHide: true, encoding: 'utf8' }, (err, stdout, stderr) => {
+      if (err) {
+        err.stderrText = stderr;
+        reject(err);
+        return;
+      }
+      resolve(stdout || '');
+    });
+  });
+}
+
+/** List every local branch under `refs/heads/sm-job/*`. Never throws. */
+async function listSmJobBranches(cwd) {
+  try {
+    const out = await execGit(cwd, ['for-each-ref', '--format=%(refname:short)', 'refs/heads/sm-job/*']);
+    return out.split('\n').map((l) => l.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/** Branch names currently checked out in any linked worktree (incl. main). Never throws. */
+async function listCheckedOutBranches(cwd) {
+  try {
+    const out = await execGit(cwd, ['worktree', 'list', '--porcelain']);
+    return gitWorktree.parseWorktreeListPorcelain(out)
+      .map((e) => e.branch)
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+const TERMINAL_JOB_STATUSES = new Set(['completed', 'failed', 'skipped']);
+
+/**
+ * sweepStrandedJobBranches({ cwd, jobs, attemptedBranches }) → { results }
+ *
+ * `jobs` is the full in-memory queue snapshot (any project's rows may be
+ * present; matched by slug only, since a slug is globally unique). `attemptedBranches`
+ * is a caller-owned `Set` of `"<cwd>::<branch>"` keys — persisted across calls
+ * (in-memory is enough: the goal is "not retried every cycle forever" while
+ * the process is up, not durability across a restart) so a branch that
+ * conflicts once is never retried again in the same process lifetime.
+ *
+ * Each result is `{ branch, slug, action }` where action is one of:
+ *   'skip-checked-out'   — branch is checked out in a live worktree, left alone
+ *   'no-op-merged'       — branch has no commits beyond HEAD, nothing to do
+ *   'skip-active-row'    — job row exists and is NOT terminal, left alone
+ *   'skip-already-attempted' — a prior sweep already tried and failed this branch
+ *   'integrated'         — merged into HEAD this pass (`integration` attached)
+ *   'conflict'           — one bounded integrateBranch attempt failed (`integration` attached)
+ *
+ * SM_BRANCH_SWEEP_DISABLE=1 restores today's behaviour exactly (no-op),
+ * mirroring SM_RESUME_RECOVERY_DISABLE.
+ */
+async function sweepStrandedJobBranches({ cwd, jobs, attemptedBranches }) {
+  if (process.env.SM_BRANCH_SWEEP_DISABLE === '1') return { results: [] };
+  if (!cwd || !(await gitWorktree.isGitRepo(cwd))) return { results: [] };
+
+  const attempted = attemptedBranches instanceof Set ? attemptedBranches : new Set();
+  const branches = await listSmJobBranches(cwd);
+  if (!branches.length) return { results: [] };
+  const checkedOut = new Set(await listCheckedOutBranches(cwd));
+  const jobsBySlug = new Map((Array.isArray(jobs) ? jobs : []).map((j) => [j.slug, j]));
+
+  const results = [];
+  for (const branch of branches) {
+    const slug = gitWorktree.keyFromBranch('job', branch);
+    if (checkedOut.has(branch)) {
+      results.push({ branch, slug, action: 'skip-checked-out' });
+      continue;
+    }
+    const merged = await gitWorktree.isBranchMergedIntoHead(cwd, branch);
+    if (merged) {
+      results.push({ branch, slug, action: 'no-op-merged' });
+      continue;
+    }
+    const row = slug ? jobsBySlug.get(slug) : null;
+    const terminalOrMissing = !row || TERMINAL_JOB_STATUSES.has(row.status);
+    if (!terminalOrMissing) {
+      results.push({ branch, slug, action: 'skip-active-row' });
+      continue;
+    }
+    const attemptKey = `${cwd}::${branch}`;
+    if (attempted.has(attemptKey)) {
+      results.push({ branch, slug, action: 'skip-already-attempted' });
+      continue;
+    }
+    attempted.add(attemptKey);
+    const integration = await gitWorktree.integrateJobBranch({ cwd, branch, slug: slug || branch });
+    results.push({ branch, slug, action: integration.ok ? 'integrated' : 'conflict', integration });
+  }
+  return { results };
+}
+
+module.exports = {
+  listSmJobBranches,
+  listCheckedOutBranches,
+  sweepStrandedJobBranches,
+};

package/src/main/lib/gitWorktree.cjs

@@ -859,6 +859,25 @@ async function salvageDirtyDelta({ cwd, paths, outFile }) {
   }
 }
 
+/**
+ * True when every commit on `branch` is already an ancestor of (or equal to)
+ * `cwd`'s current HEAD — i.e. the branch holds no work that isn't already
+ * landed. Used by the stranded-branch sweep (branchSweep.cjs) to tell a
+ * genuinely stranded `sm-job/*` branch from one that's already a no-op.
+ * Never throws; a branch that doesn't exist, or any other git failure, is
+ * conservatively reported as NOT merged so a caller never treats an
+ * unreadable branch as safe to skip.
+ */
+async function isBranchMergedIntoHead(cwd, branch) {
+  try {
+    const branchHead = (await execGit(['rev-parse', '--verify', branch], { cwd, timeout: 10_000 })).trim();
+    const mergeBase = (await execGit(['merge-base', 'HEAD', branch], { cwd, timeout: 10_000 })).trim();
+    return mergeBase !== '' && mergeBase === branchHead;
+  } catch {
+    return false;
+  }
+}
+
 /** Parse `git worktree list --porcelain` into `[{ worktree, branch }]`. */
 function parseWorktreeListPorcelain(text) {
   const entries = [];
@@ -1003,6 +1022,7 @@ module.exports = {
   cleanupWorktree,
   salvageWorktreeDiff,
   salvageDirtyDelta,
+  isBranchMergedIntoHead,
   parseWorktreeListPorcelain,
   reconcileWorktreesOnBoot,
   sweepStaleWorktreeCheckouts,

package/src/main/lib/landedSinceRun.cjs

@@ -52,4 +52,44 @@ function landedSinceRun(cwd, sinceIso, paths, { timeoutMs = LANDED_SINCE_RUN_TIM
   });
 }
 
-module.exports = { landedSinceRun, LANDED_SINCE_RUN_TIMEOUT_MS };
+/**
+ * Commits reachable from `main` in `cwd` since `sinceIso` that touch any of
+ * `paths` — the evidence query behind PRD 1136's already-satisfied-on-main
+ * commit-guard exemption. Deliberately narrower than landedSinceRun in one
+ * axis (scoped to `main`, not `--all` — a commit on a stray branch is not
+ * "satisfied") and identical in the other (path-scoped, so an unrelated
+ * commit elsewhere in the repo is never credited to this job).
+ *
+ * Falls back from local `main` to `origin/main` when the local branch ref
+ * doesn't exist (a worktree/CI checkout that never checked main out
+ * locally) — never throws either way; git-unavailable, a non-repo cwd, an
+ * unresolvable ref, or an empty `paths` list all resolve to `[]`.
+ *
+ * @param {string} cwd
+ * @param {string} sinceIso
+ * @param {string[]} paths
+ * @param {{ timeoutMs?: number }} [opts]
+ * @returns {Promise<string[]>} full commit SHAs, newest first
+ */
+function landedOnMainSince(cwd, sinceIso, paths, { timeoutMs = LANDED_SINCE_RUN_TIMEOUT_MS } = {}) {
+  const runLog = (ref) => new Promise((resolve) => {
+    execFile(
+      'git',
+      ['-C', cwd, 'log', ref, `--since=${sinceIso}`, '--format=%H', '--', ...paths],
+      { timeout: timeoutMs, windowsHide: true },
+      (err, stdout) => {
+        if (err) { resolve(null); return; }
+        resolve(String(stdout || '').trim().split('\n').filter(Boolean));
+      },
+    );
+  });
+  return (async () => {
+    if (!cwd || !sinceIso || !Array.isArray(paths) || paths.length === 0) return [];
+    const viaLocal = await runLog('main');
+    if (viaLocal !== null) return viaLocal;
+    const viaRemote = await runLog('origin/main');
+    return viaRemote ?? [];
+  })();
+}
+
+module.exports = { landedSinceRun, landedOnMainSince, LANDED_SINCE_RUN_TIMEOUT_MS };

package/src/main/lib/rateLimitWindow.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * rateLimitWindow.cjs — reads the BINDING rate-limit window's reset time
+ * straight off a run's own log, instead of trusting the billing usage
+ * endpoint's five_hour window (PRD 1118). A run can be 429'd by a
+ * different window than five_hour (seven_day, seven_day_overage_included)
+ * while five_hour utilization is still 0 — pausing against five_hour's
+ * reset in that case arms the resume timer against the wrong clock, and
+ * the billing endpoint can itself be 429'ing when this is needed most.
+ *
+ * Pure: log path in, reset value out. No electron import, so it is
+ * unit-testable without scheduler.cjs (mirrors reaperHelpers.cjs's split).
+ */
+
+const { readTail } = require('./fileTail.cjs');
+
+// Authoritative window block rides on the LAST rate_limit_event in the log
+// (often the one attached to the final result), so mirror classifyRunOutcome's
+// 64 KB tail rather than detectRateLimitInLog's smaller 16 KB one.
+const TAIL_BYTES = 64 * 1024;
+
+/**
+ * Scans a run log's tail for rate_limit_event entries and returns the
+ * UNIX-seconds resetsAt of the window that actually bound (utilization >= 1.0)
+ * in the LAST such event. When multiple windows bind in that event, the
+ * latest resetsAt wins. Returns null when no rate_limit_event is found, or
+ * none of its windows are at/above 1.0 utilization.
+ */
+function resolveBindingRateLimitReset(logPath) {
+  const text = readTail(logPath, TAIL_BYTES);
+  if (!text) return null;
+
+  let lastWindows = null;
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed[0] !== '{') continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const windows = event?.rate_limit_info?.unifiedWindows;
+    if (event?.type === 'rate_limit_event' && windows && typeof windows === 'object') {
+      lastWindows = windows;
+    }
+  }
+  if (!lastWindows) return null;
+
+  let latestBoundReset = null;
+  for (const window of Object.values(lastWindows)) {
+    if (!window || typeof window.utilization !== 'number' || typeof window.resetsAt !== 'number') continue;
+    if (window.utilization < 1.0) continue;
+    if (latestBoundReset === null || window.resetsAt > latestBoundReset) {
+      latestBoundReset = window.resetsAt;
+    }
+  }
+  return latestBoundReset;
+}
+
+module.exports = { resolveBindingRateLimitReset };