claude-code-session-manager 0.79.0 → 0.81.0

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

@@ -79,12 +79,24 @@ describe('pickForProject dependsOn eligibility (PRD 832)', () => {
     expect(res.batch.map((j) => j.slug)).toContain('851-next');
   });
 
-  it('a dep slug with NO queue row counts as done (retired to history)', () => {
+  it('a dep slug with NO queue row counts as done when found in history/archive (PRD 1122)', () => {
     const dependent = job('853-next', 'pending', 853, { dependsOn: ['852-archived-long-ago'] });
-    const res = pickForProject([dependent], new Set(), 3);
+    // Caller (scheduler.cjs's computeDepHistorySatisfaction) precomputes this
+    // Set from history.jsonl/prds-archived — pickForProject never does I/O.
+    const satisfiedSlugs = new Set(['852-archived-long-ago']);
+    const res = pickForProject([dependent], new Set(), 3, new Map(), satisfiedSlugs);
     expect(res.batch.map((j) => j.slug)).toContain('853-next');
   });
 
+  it('a dep slug with NO queue row and NO history/archive record HOLDS as unresolved (PRD 1122)', () => {
+    const dependent = job('853-next', 'pending', 853, { dependsOn: ['852-archived-long-ago'] });
+    const res = pickForProject([dependent], new Set(), 3);
+    expect(res.batch).toEqual([]);
+    expect(res.reason).toMatch(/unresolvable/);
+    expect(res.reason).toContain('853-next');
+    expect(res.reason).toContain('852-archived-long-ago');
+  });
+
   it('a FAILED dep holds the dependent with an explicit depends-gate reason', () => {
     const dep = job('854-base', 'failed', 854);
     const dependent = job('855-next', 'pending', 855, { dependsOn: ['854-base'] });

package/src/main/ipcSchemas.cjs

@@ -313,6 +313,13 @@ const NO_NEWLINE_RE = /^[^\r\n]*$/;
 // prdCreate.cjs's createPrd via prdAgentType.cjs's assertAgentTypeWritable —
 // this schema only enforces the name SHAPE.
 const PrdAgentTypeSchema = z.string().regex(PERSONA_NAME_RE, 'agent name must be lowercase, hyphenated (e.g. "dev-lead")');
+// Shared shape for a `dependsOn` slug entry — schedulerCreatePrd and
+// adminUpdatePrd (scheduler_update_prd, PRD 1124) must accept the exact same
+// slug shape or an update could write a dependsOn value create would have
+// rejected. Array-level constraints (`.max(20)`, `.optional()`) stay at each
+// call site since update also allows an explicit empty array to CLEAR the
+// dependency, which create has no reason to accept.
+const DepSlugSchema = z.string().min(1).max(160).regex(/^[A-Za-z0-9][\w.-]*$/);
 const schedulerCreatePrd = z.object({
   title: z.string().min(1).max(200).regex(NO_NEWLINE_RE, 'must not contain newlines'),
   // Optional (PRD: worktree-cwd Epic-lookup hazard) — when omitted, prdCreate.cjs's
@@ -332,7 +339,7 @@ const schedulerCreatePrd = z.object({
   parallelGroup: z.number().int().min(1).max(999999).optional(),
   // Explicit ordering (PRD 832): slugs that must complete before this PRD
   // becomes eligible. Written to frontmatter as `dependsOn: [a, b]`.
-  dependsOn: z.array(z.string().min(1).max(160).regex(/^[A-Za-z0-9][\w.-]*$/)).max(20).optional(),
+  dependsOn: z.array(DepSlugSchema).max(20).optional(),
   // An EXISTING Epic's promptSessionId (PRD 748) — NOT a PromptTicket.id.
   // ensureEpic() (epicMint.cjs) joins the Epic whose active-index.json
   // sessions key literally equals this value; the renderer only ever sends
@@ -455,6 +462,13 @@ const adminPrdFrontmatterPatch = z.object({
   // Opt-in exclusive-lease flag (PRD 1107) — patchable after creation too,
   // same as every other recognized key here.
   quietMachine: z.boolean().optional(),
+  // Explicit ordering (PRD 832), promoted to patchable by PRD 1124 — see
+  // prdFrontmatter.cjs's header. An explicit `[]` CLEARS the dependency
+  // (updatePrd's array-emptiness check skips writing the key at all); a
+  // non-empty array is validated write-time against the SAME resolver
+  // (depSlugResolve.cjs) scheduler_create_prd uses, so update and create
+  // can never disagree about what a dependsOn entry resolves to.
+  dependsOn: z.array(DepSlugSchema).max(20).optional(),
 });
 
 const adminUpdatePrd = z.object({

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

@@ -0,0 +1,164 @@
+/**
+ * branchSweep.test.cjs — PRD 1135: recovering `sm-job/<slug>` branches left
+ * stranded (unmerged, owning job row terminal or gone) never gets swept away
+ * by hand months later.
+ *
+ * Exercises the real `git` plumbing against throwaway repos under
+ * os.tmpdir() (fast — no network, no Electron).
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/branchSweep.test.cjs
+ */
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const { sweepStrandedJobBranches } = require('../branchSweep.cjs');
+
+let tmpRoot;
+let repoCwd;
+let worktreeDir;
+
+function git(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8' });
+}
+
+function initRepo(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  git(['init', '-q'], dir);
+  git(['config', 'user.email', 'test@example.com'], dir);
+  git(['config', 'user.name', 'Test'], dir);
+  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
+  git(['add', '-A'], dir);
+  git(['commit', '-q', '-m', 'initial'], dir);
+}
+
+beforeEach(() => {
+  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-'));
+  repoCwd = path.join(tmpRoot, 'repo');
+  initRepo(repoCwd);
+  delete process.env.SM_BRANCH_SWEEP_DISABLE;
+});
+
+afterEach(() => {
+  if (worktreeDir && fs.existsSync(worktreeDir)) {
+    try { git(['worktree', 'remove', '--force', worktreeDir], repoCwd); } catch { /* best effort */ }
+  }
+  worktreeDir = undefined;
+  delete process.env.SM_BRANCH_SWEEP_DISABLE;
+  fs.rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+/** Create an `sm-job/<slug>` branch with one commit beyond HEAD, without checking it out. */
+function makeStrandedBranch(cwd, slug, fileContents = 'stranded work\n') {
+  const branch = `sm-job/${slug}`;
+  git(['branch', branch], cwd);
+  const tmpCheckout = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-checkout-'));
+  git(['worktree', 'add', '-q', tmpCheckout, branch], cwd);
+  fs.writeFileSync(path.join(tmpCheckout, `${slug}.txt`), fileContents, 'utf8');
+  git(['add', '-A'], tmpCheckout);
+  git(['commit', '-q', '-m', `job ${slug} work`], tmpCheckout);
+  git(['worktree', 'remove', '--force', tmpCheckout], cwd);
+  return branch;
+}
+
+test('stranded branch with a terminal job row is integrated', async () => {
+  const branch = makeStrandedBranch(repoCwd, 'alpha');
+  const jobs = [{ slug: 'alpha', status: 'completed' }];
+  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
+  const r = results.find((x) => x.branch === branch);
+  expect(r.action).toBe('integrated');
+  expect(fs.existsSync(path.join(repoCwd, 'alpha.txt'))).toBe(true);
+});
+
+test('stranded branch with NO job row at all is also integrated', async () => {
+  const branch = makeStrandedBranch(repoCwd, 'ghost');
+  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs: [], attemptedBranches: new Set() });
+  const r = results.find((x) => x.branch === branch);
+  expect(r.action).toBe('integrated');
+});
+
+test('branch already merged into HEAD is a silent no-op', async () => {
+  const branch = makeStrandedBranch(repoCwd, 'bravo');
+  git(['merge', '--no-ff', '--no-edit', branch], repoCwd);
+  const jobs = [{ slug: 'bravo', status: 'completed' }];
+  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
+  const r = results.find((x) => x.branch === branch);
+  expect(r.action).toBe('no-op-merged');
+});
+
+test('branch checked out in a live worktree is skipped entirely', async () => {
+  const branch = makeStrandedBranch(repoCwd, 'charlie');
+  worktreeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-live-'));
+  git(['worktree', 'add', '-q', worktreeDir, branch], repoCwd);
+  const jobs = [{ slug: 'charlie', status: 'running' }];
+  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
+  const r = results.find((x) => x.branch === branch);
+  expect(r.action).toBe('skip-checked-out');
+});
+
+test('branch owned by a NON-terminal job row is left alone, never integrated', async () => {
+  const branch = makeStrandedBranch(repoCwd, 'delta');
+  const jobs = [{ slug: 'delta', status: 'needs_review' }];
+  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
+  const r = results.find((x) => x.branch === branch);
+  expect(r.action).toBe('skip-active-row');
+  expect(fs.existsSync(path.join(repoCwd, 'delta.txt'))).toBe(false);
+});
+
+test('conflicting branch is flagged, never forced, and the branch is never deleted', async () => {
+  // Same path committed differently on both HEAD and the branch → real conflict.
+  fs.writeFileSync(path.join(repoCwd, 'shared.txt'), 'main tree version\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'main tree edits shared.txt'], repoCwd);
+
+  const branch = 'sm-job/echo';
+  git(['branch', branch, 'HEAD~1'], repoCwd);
+  const tmpCheckout = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-conflict-'));
+  git(['worktree', 'add', '-q', tmpCheckout, branch], repoCwd);
+  fs.writeFileSync(path.join(tmpCheckout, 'shared.txt'), 'branch version — conflicts\n', 'utf8');
+  git(['add', '-A'], tmpCheckout);
+  git(['commit', '-q', '-m', 'job echo edits shared.txt'], tmpCheckout);
+  git(['worktree', 'remove', '--force', tmpCheckout], repoCwd);
+
+  const jobs = [{ slug: 'echo', status: 'failed' }];
+  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
+  const r = results.find((x) => x.branch === branch);
+  expect(r.action).toBe('conflict');
+  expect(r.integration.ok).toBe(false);
+  // Branch itself must survive a conflict, untouched.
+  const stillExists = git(['rev-parse', '--verify', branch], repoCwd).trim();
+  expect(stillExists.length).toBe(40);
+});
+
+test('a branch is retried at most once per process lifetime via the shared attempted set', async () => {
+  fs.writeFileSync(path.join(repoCwd, 'shared2.txt'), 'main\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'main edits shared2'], repoCwd);
+  const branch = 'sm-job/foxtrot';
+  git(['branch', branch, 'HEAD~1'], repoCwd);
+  const tmpCheckout = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-branchsweep-retry-'));
+  git(['worktree', 'add', '-q', tmpCheckout, branch], repoCwd);
+  fs.writeFileSync(path.join(tmpCheckout, 'shared2.txt'), 'branch — conflicts\n', 'utf8');
+  git(['add', '-A'], tmpCheckout);
+  git(['commit', '-q', '-m', 'job foxtrot edits shared2'], tmpCheckout);
+  git(['worktree', 'remove', '--force', tmpCheckout], repoCwd);
+
+  const jobs = [{ slug: 'foxtrot', status: 'failed' }];
+  const attemptedBranches = new Set();
+  const first = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches });
+  expect(first.results.find((x) => x.branch === branch).action).toBe('conflict');
+  const second = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches });
+  expect(second.results.find((x) => x.branch === branch).action).toBe('skip-already-attempted');
+});
+
+test('SM_BRANCH_SWEEP_DISABLE=1 restores today\'s behaviour exactly — no scan, no integration', async () => {
+  makeStrandedBranch(repoCwd, 'golf');
+  process.env.SM_BRANCH_SWEEP_DISABLE = '1';
+  const jobs = [{ slug: 'golf', status: 'completed' }];
+  const { results } = await sweepStrandedJobBranches({ cwd: repoCwd, jobs, attemptedBranches: new Set() });
+  expect(results).toEqual([]);
+  expect(fs.existsSync(path.join(repoCwd, 'golf.txt'))).toBe(false);
+});

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__/gitWorktree.test.cjs

@@ -186,7 +186,7 @@ test('[job] integration is skipped (carried-wip-only) when the branch only commi
   await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: !outcome.ok });
 });
 
-test('[job] a branch that commits carried paths ALONGSIDE its own work still attempts integration normally (no silent drop)', async () => {
+test('[job] a branch that commits carried paths ALONGSIDE its own work auto-resolves the merge (PRD 1125: carried path is byte-identical duplicate, real work still lands)', async () => {
   const slug = 'test-slug-carried-plus-own-work';
   fs.writeFileSync(path.join(repoCwd, 'README.md'), 'uncommitted tracked edit\n', 'utf8');
   const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
@@ -198,16 +198,20 @@ test('[job] a branch that commits carried paths ALONGSIDE its own work still att
   git(['commit', '-q', '-m', 'job commit touching carried path + own work'], worktree.dir);
 
   const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug, carriedPaths: worktree.carriedPaths });
-  // The base tree still holds README.md dirty, so a real merge attempt here
-  // is expected to fail exactly like the existing worktreeIntegrationFailure
-  // path — branch preserved, not merged, not silently discarded.
-  expect(outcome.ok).toBe(false);
-  expect(outcome.reason).toBeTruthy();
-
-  const branches = git(['branch', '--list', worktree.branch], repoCwd);
-  expect(branches).toContain(worktree.branch.replace('sm-job/', ''));
+  // The base tree still holds README.md dirty, but its content is BYTE
+  // IDENTICAL to the branch's committed copy (the branch never edited it,
+  // only carried it through) — this is exactly the shape PRD 1125 teaches
+  // integrateBranch to auto-resolve: discard the duplicate, retry once, land
+  // the job's real new-file.txt commit too. Not the carried-wip-only
+  // shortcut (that only fires when the branch's ONLY changes are carried
+  // paths) — here the merge itself is what resolves.
+  expect(outcome.ok).toBe(true);
+  expect(outcome.integrated).toBe(true);
+  expect(outcome.autoResolved).toBe('identical_working_tree_duplicates');
+  expect(outcome.resolvedPaths).toEqual(['README.md']);
+  expect(fs.existsSync(path.join(repoCwd, 'new-file.txt'))).toBe(true);
 
-  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: !outcome.ok });
 });
 
 test('[job] a branch that ADDS its own edit on top of the carried content on the SAME path is never classified carried-wip-only (content-verify, not path-only)', async () => {
@@ -683,3 +687,118 @@ test('[job] reconcileWorktreesOnBoot logs a one-shot report line with reclaimed
     logSpy.mockRestore();
   }
 });
+
+// ──────────────────────────────────────────── PRD 1125: auto-resolve identical-duplicate merge blocks
+
+test('[job] integrateBranch auto-resolves when every blocking path (tracked + untracked) is byte-identical to the branch', async () => {
+  const slug = 'test-slug-identical-duplicates';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  // The job's own real work, committed on its branch.
+  fs.writeFileSync(path.join(worktree.dir, 'fileA'), 'shared-value\n', 'utf8');
+  fs.mkdirSync(path.join(worktree.dir, 'newdir'), { recursive: true });
+  fs.writeFileSync(path.join(worktree.dir, 'newdir', 'fileU'), 'untracked-shared-value\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job commit'], worktree.dir);
+
+  // The shared main tree independently ends up with the SAME bytes on both
+  // a tracked path (dirty, uncommitted) and an untracked path — exactly the
+  // 2026-09-06 starry-night-ships incident shape: a prior in-place run left
+  // these duplicates behind uncommitted.
+  fs.writeFileSync(path.join(repoCwd, 'fileA'), 'shared-value\n', 'utf8');
+  fs.mkdirSync(path.join(repoCwd, 'newdir'), { recursive: true });
+  fs.writeFileSync(path.join(repoCwd, 'newdir', 'fileU'), 'untracked-shared-value\n', 'utf8');
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(true);
+  expect(outcome.integrated).toBe(true);
+  expect(outcome.mergeCommit ?? outcome.fastForward).toBeTruthy();
+  expect(outcome.autoResolved).toBe('identical_working_tree_duplicates');
+  expect(outcome.resolvedPaths.sort()).toEqual(['fileA', 'newdir/fileU'].sort());
+
+  expect(fs.readFileSync(path.join(repoCwd, 'fileA'), 'utf8')).toBe('shared-value\n');
+  expect(fs.readFileSync(path.join(repoCwd, 'newdir', 'fileU'), 'utf8')).toBe('untracked-shared-value\n');
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: !outcome.ok });
+});
+
+test('[job] integrateBranch does NOT auto-resolve when one blocking path differs from the branch — same reason as today', async () => {
+  const slug = 'test-slug-one-differing-path';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  fs.writeFileSync(path.join(worktree.dir, 'fileA'), 'branch-value\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job commit'], worktree.dir);
+
+  // Main tree's dirty copy diverges from the branch's committed content —
+  // real information is at risk, so this must NOT be discarded.
+  fs.writeFileSync(path.join(repoCwd, 'fileA'), 'different-local-value\n', 'utf8');
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.reason).toMatch(/merge failed \(likely a real content conflict\)/);
+  expect(fs.readFileSync(path.join(repoCwd, 'fileA'), 'utf8')).toBe('different-local-value\n');
+  expect(git(['status', '--porcelain'], repoCwd).trim()).not.toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] integrateBranch falls through to today\'s failure when stderr has no parseable blocking-path block (a genuine content conflict)', async () => {
+  const slug = 'test-slug-unparseable-stderr';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  fs.writeFileSync(path.join(worktree.dir, 'README.md'), 'job edit\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job edits README'], worktree.dir);
+
+  // A committed (not dirty) diverging edit on the main tree produces git's
+  // ordinary "CONFLICT (content)" stderr shape, not the "would be
+  // overwritten" block parseBlockingMergePaths looks for.
+  fs.writeFileSync(path.join(repoCwd, 'README.md'), 'main tree edit\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'main tree edits README'], repoCwd);
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.reason).toMatch(/merge failed \(likely a real content conflict\)/);
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});
+
+test('[job] integrateBranch aborts cleanly when the single retry also fails on a genuine conflict elsewhere', async () => {
+  const slug = 'test-slug-retry-fails';
+  const worktree = await gitWorktree.createJobWorktree({ cwd: repoCwd, slug });
+  expect(worktree.ok).toBe(true);
+
+  // The branch's own real work: extends fileA (existing, tracked since
+  // initRepo's README.md commit doesn't cover it — add it fresh here) and
+  // ADDS a brand-new fileB.txt.
+  fs.writeFileSync(path.join(worktree.dir, 'fileA'), 'shared-value\n', 'utf8');
+  fs.writeFileSync(path.join(worktree.dir, 'fileB.txt'), 'branch B change\n', 'utf8');
+  git(['add', '-A'], worktree.dir);
+  git(['commit', '-q', '-m', 'job commit: fileA + fileB'], worktree.dir);
+
+  // Main tree independently ADDS the SAME path with DIFFERENT content — a
+  // genuine "both added, diverging content" conflict on fileB.txt.
+  fs.writeFileSync(path.join(repoCwd, 'fileB.txt'), 'base B change\n', 'utf8');
+  git(['add', '-A'], repoCwd);
+  git(['commit', '-q', '-m', 'main tree diverges fileB'], repoCwd);
+  // ...and ALSO leaves fileA dirty with content byte-identical to the branch
+  // — the one blocking path the initial merge attempt refuses on, and the
+  // one the auto-resolve retry successfully discards.
+  fs.writeFileSync(path.join(repoCwd, 'fileA'), 'shared-value\n', 'utf8');
+
+  const outcome = await gitWorktree.integrateJobBranch({ cwd: repoCwd, branch: worktree.branch, slug });
+  expect(outcome.ok).toBe(false);
+  expect(outcome.reason).toMatch(/merge failed \(likely a real content conflict\)/);
+  // The retry's half-applied merge must be aborted, not left mid-merge.
+  expect(git(['status', '--porcelain'], repoCwd).trim()).toBe('');
+  expect(fs.existsSync(path.join(repoCwd, '.git', 'MERGE_HEAD'))).toBe(false);
+
+  await gitWorktree.cleanupJobWorktree({ cwd: repoCwd, dir: worktree.dir, branch: worktree.branch, keepBranch: true });
+});

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);
+});