tlc-claude-code 2.4.10 → 2.5.0

package/server/lib/github/plan-sync.test.js

@@ -0,0 +1,805 @@
+/**
+ * @file plan-sync.test.js
+ * @description Tests for plan-to-issues sync (Phase 97, Task 3).
+ *
+ * Tests the module that parses PLAN.md, creates GitHub issues for tasks,
+ * adds them to a project board, and writes issue markers back into the plan.
+ *
+ * All external dependencies (ghClient, ghProjects, fs) are mocked via DI.
+ *
+ * TDD: RED phase — these tests are written BEFORE the implementation.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  parsePlanTasks,
+  injectIssueMarkers,
+  syncPlan,
+  updateTaskStatuses,
+} from './plan-sync.js';
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const SAMPLE_PLAN = `# Phase 97: GitHub Deep Integration - Plan
+
+## Overview
+
+Bidirectional sync between TLC and GitHub.
+
+## Tasks
+
+### Task 1: GitHub Client — Issues + PRs [ ]
+
+**Goal:** Module that wraps \`gh\` CLI for issue and PR operations.
+
+**Acceptance Criteria:**
+- [ ] createIssue works
+- [ ] closeIssue works
+
+---
+
+### Task 2: GitHub Client — Projects V2 [>@alice]
+
+**Goal:** Module for GitHub Projects V2 via GraphQL.
+
+**Acceptance Criteria:**
+- [ ] discoverProject works
+
+---
+
+### Task 3: Plan-to-Issues Sync [ ]
+
+**Goal:** Sync plan tasks to GitHub issues.
+
+**Acceptance Criteria:**
+- [ ] syncPlan works
+
+---
+
+### Task 4: Hook Integration [x]
+
+**Goal:** Wire sync into the TLC command flow.
+
+**Acceptance Criteria:**
+- [x] Hooks integrated
+
+---
+
+### Task 5: Config + Setup [x@bob]
+
+**Goal:** Configuration management.
+
+**Acceptance Criteria:**
+- [x] Config works
+`;
+
+const PLAN_WITH_MARKERS = `# Phase 42: Test Phase - Plan
+
+## Tasks
+
+### Task 1: First Task [ ] <!-- #101 -->
+
+**Goal:** Do first thing.
+
+---
+
+### Task 2: Second Task [>@carol] <!-- #102 -->
+
+**Goal:** Do second thing.
+
+---
+
+### Task 3: Third Task [ ]
+
+**Goal:** Do third thing.
+`;
+
+const PLAN_NO_TASKS = `# Phase 50: Empty Phase - Plan
+
+## Overview
+
+Nothing here yet.
+
+## Tasks
+
+No tasks defined.
+`;
+
+const PLAN_SINGLE_TASK = `# Phase 10: Tiny Phase - Plan
+
+## Tasks
+
+### Task 1: Only Task [ ]
+
+**Goal:** The only task.
+`;
+
+// ---------------------------------------------------------------------------
+// parsePlanTasks
+// ---------------------------------------------------------------------------
+
+describe('parsePlanTasks', () => {
+  it('extracts phase title correctly', () => {
+    const result = parsePlanTasks(SAMPLE_PLAN);
+
+    expect(result.phaseNumber).toBe(97);
+    expect(result.phaseTitle).toBe('GitHub Deep Integration');
+  });
+
+  it('extracts 5 tasks with correct numbers and titles', () => {
+    const result = parsePlanTasks(SAMPLE_PLAN);
+
+    expect(result.tasks).toHaveLength(5);
+    expect(result.tasks[0].number).toBe(1);
+    expect(result.tasks[0].title).toBe('GitHub Client — Issues + PRs');
+    expect(result.tasks[1].number).toBe(2);
+    expect(result.tasks[1].title).toBe('GitHub Client — Projects V2');
+    expect(result.tasks[2].number).toBe(3);
+    expect(result.tasks[2].title).toBe('Plan-to-Issues Sync');
+    expect(result.tasks[3].number).toBe(4);
+    expect(result.tasks[3].title).toBe('Hook Integration');
+    expect(result.tasks[4].number).toBe(5);
+    expect(result.tasks[4].title).toBe('Config + Setup');
+  });
+
+  it('detects todo/in_progress/done status markers', () => {
+    const result = parsePlanTasks(SAMPLE_PLAN);
+
+    expect(result.tasks[0].status).toBe('todo');        // [ ]
+    expect(result.tasks[1].status).toBe('in_progress');  // [>@alice]
+    expect(result.tasks[2].status).toBe('todo');         // [ ]
+    expect(result.tasks[3].status).toBe('done');         // [x]
+    expect(result.tasks[4].status).toBe('done');         // [x@bob]
+  });
+
+  it('extracts existing issue markers', () => {
+    const result = parsePlanTasks(PLAN_WITH_MARKERS);
+
+    expect(result.tasks[0].issueNumber).toBe(101);
+    expect(result.tasks[1].issueNumber).toBe(102);
+    expect(result.tasks[2].issueNumber).toBeNull();
+  });
+
+  it('handles plan with no tasks gracefully', () => {
+    const result = parsePlanTasks(PLAN_NO_TASKS);
+
+    expect(result.phaseNumber).toBe(50);
+    expect(result.phaseTitle).toBe('Empty Phase');
+    expect(result.tasks).toEqual([]);
+  });
+
+  it('extracts assignee from [>@alice]', () => {
+    const result = parsePlanTasks(SAMPLE_PLAN);
+
+    expect(result.tasks[1].assignee).toBe('alice');
+    expect(result.tasks[0].assignee).toBeNull();
+    expect(result.tasks[3].assignee).toBeNull();  // [x] has no assignee
+  });
+
+  it('extracts assignee from [x@bob]', () => {
+    const result = parsePlanTasks(SAMPLE_PLAN);
+
+    expect(result.tasks[4].assignee).toBe('bob');
+  });
+
+  it('handles single task plan', () => {
+    const result = parsePlanTasks(PLAN_SINGLE_TASK);
+
+    expect(result.phaseNumber).toBe(10);
+    expect(result.tasks).toHaveLength(1);
+    expect(result.tasks[0].number).toBe(1);
+    expect(result.tasks[0].title).toBe('Only Task');
+    expect(result.tasks[0].status).toBe('todo');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// injectIssueMarkers
+// ---------------------------------------------------------------------------
+
+describe('injectIssueMarkers', () => {
+  it('adds markers after task headings', () => {
+    const taskIssueMap = { 1: 201, 3: 203 };
+    const result = injectIssueMarkers(SAMPLE_PLAN, taskIssueMap);
+
+    expect(result).toContain('### Task 1: GitHub Client — Issues + PRs [ ] <!-- #201 -->');
+    expect(result).toContain('### Task 3: Plan-to-Issues Sync [ ] <!-- #203 -->');
+    // Tasks without mapping should be unchanged
+    expect(result).toContain('### Task 2: GitHub Client — Projects V2 [>@alice]');
+    expect(result).not.toContain('### Task 2: GitHub Client — Projects V2 [>@alice] <!-- #');
+  });
+
+  it('is idempotent (does not duplicate existing markers)', () => {
+    const taskIssueMap = { 1: 101, 2: 102, 3: 300 };
+    const result = injectIssueMarkers(PLAN_WITH_MARKERS, taskIssueMap);
+
+    // Count occurrences of <!-- #101 -->
+    const matches101 = result.match(/<!-- #101 -->/g);
+    expect(matches101).toHaveLength(1);
+
+    // Count occurrences of <!-- #102 -->
+    const matches102 = result.match(/<!-- #102 -->/g);
+    expect(matches102).toHaveLength(1);
+
+    // Task 3 should now have the new marker
+    expect(result).toContain('### Task 3: Third Task [ ] <!-- #300 -->');
+  });
+
+  it('preserves existing markers when no new map entries', () => {
+    const taskIssueMap = {};
+    const result = injectIssueMarkers(PLAN_WITH_MARKERS, taskIssueMap);
+
+    expect(result).toContain('<!-- #101 -->');
+    expect(result).toContain('<!-- #102 -->');
+    expect(result).toBe(PLAN_WITH_MARKERS);
+  });
+
+  it('handles empty taskIssueMap', () => {
+    const result = injectIssueMarkers(SAMPLE_PLAN, {});
+
+    expect(result).toBe(SAMPLE_PLAN);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Mock factories for syncPlan / updateTaskStatuses
+// ---------------------------------------------------------------------------
+
+function makeConfig({
+  org = 'KashaTech',
+  repo = 'my-project',
+  owner = 'KashaTech',
+  project = 'CashierLogic',
+  sprintField = 'Sprint',
+  statusField = 'Status',
+  phasePrefix = 'S',
+} = {}) {
+  return {
+    github: {
+      autoSync: true,
+      project,
+      org,
+      sprintField,
+      statusField,
+      phasePrefix,
+    },
+    owner,
+    repo,
+  };
+}
+
+function makeGhClient() {
+  return {
+    createIssue: vi.fn().mockReturnValue({ number: 200, url: 'https://github.com/o/r/issues/200', id: 'I_200' }),
+    closeIssue: vi.fn().mockReturnValue({ closed: true }),
+    listIssues: vi.fn().mockReturnValue([]),
+    assignIssue: vi.fn().mockReturnValue({ assigned: true }),
+    addLabels: vi.fn().mockReturnValue({ labeled: true }),
+  };
+}
+
+function makeGhProjects() {
+  return {
+    getProjectInfo: vi.fn().mockReturnValue({
+      projectId: 'PVT_abc123',
+      title: 'CashierLogic',
+      number: 1,
+      fields: [
+        { id: 'PVTF_title', name: 'Title', type: 'field' },
+        {
+          id: 'PVTSSF_status',
+          name: 'Status',
+          type: 'single_select',
+          options: [
+            { id: 'opt_backlog', name: 'Backlog' },
+            { id: 'opt_inprogress', name: 'In progress' },
+            { id: 'opt_done', name: 'Done' },
+          ],
+        },
+        {
+          id: 'PVTSSF_sprint',
+          name: 'Sprint',
+          type: 'single_select',
+          options: [
+            { id: 'opt_s96', name: 'S96' },
+          ],
+        },
+      ],
+    }),
+    addItem: vi.fn().mockReturnValue({ itemId: 'PVTI_item1' }),
+    setField: vi.fn().mockReturnValue({ success: true }),
+    createOption: vi.fn().mockReturnValue({ optionId: 'opt_s97' }),
+    findField: vi.fn().mockImplementation((name) => {
+      if (name === 'Status') {
+        return {
+          id: 'PVTSSF_status',
+          name: 'Status',
+          type: 'single_select',
+          options: [
+            { id: 'opt_backlog', name: 'Backlog' },
+            { id: 'opt_inprogress', name: 'In progress' },
+            { id: 'opt_done', name: 'Done' },
+          ],
+        };
+      }
+      if (name === 'Sprint') {
+        return {
+          id: 'PVTSSF_sprint',
+          name: 'Sprint',
+          type: 'single_select',
+          options: [
+            { id: 'opt_s96', name: 'S96' },
+          ],
+        };
+      }
+      return null;
+    }),
+    findOption: vi.fn().mockImplementation((field, optionName) => {
+      if (!field || !field.options) return null;
+      return field.options.find(o => o.name.toLowerCase() === optionName.toLowerCase()) || null;
+    }),
+    getItems: vi.fn().mockReturnValue([]),
+  };
+}
+
+function makeMockFs(planContent = SAMPLE_PLAN) {
+  return {
+    readFileSync: vi.fn().mockReturnValue(planContent),
+    writeFileSync: vi.fn(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// syncPlan
+// ---------------------------------------------------------------------------
+
+describe('syncPlan', () => {
+  let ghClient, ghProjects, config, mockFs;
+
+  beforeEach(() => {
+    ghClient = makeGhClient();
+    ghProjects = makeGhProjects();
+    config = makeConfig();
+    mockFs = makeMockFs();
+  });
+
+  it('creates parent phase issue', () => {
+    // listIssues returns empty (no existing phase issue)
+    ghClient.listIssues.mockReturnValue([]);
+
+    syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should create parent issue with phase title
+    expect(ghClient.createIssue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: expect.stringContaining('Phase 97'),
+      })
+    );
+  });
+
+  it('creates sub-issues for each task', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    // Return different issue numbers for each creation
+    let issueCounter = 300;
+    ghClient.createIssue.mockImplementation(() => {
+      const num = issueCounter++;
+      return { number: num, url: `https://github.com/o/r/issues/${num}`, id: `I_${num}` };
+    });
+
+    const result = syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // 1 parent + 5 tasks = 6 createIssue calls
+    expect(ghClient.createIssue).toHaveBeenCalledTimes(6);
+
+    // Verify task issue titles contain [Phase 97]
+    const calls = ghClient.createIssue.mock.calls;
+    // Second call onward should be tasks (first is parent)
+    expect(calls[1][0].title).toContain('[Phase 97] Task 1:');
+    expect(calls[2][0].title).toContain('[Phase 97] Task 2:');
+
+    expect(result.created).toBeGreaterThan(0);
+  });
+
+  it('skips tasks that already have issue markers', () => {
+    mockFs = makeMockFs(PLAN_WITH_MARKERS);
+    ghClient.listIssues.mockReturnValue([]);
+
+    let issueCounter = 500;
+    ghClient.createIssue.mockImplementation(() => {
+      const num = issueCounter++;
+      return { number: num, url: `https://github.com/o/r/issues/${num}`, id: `I_${num}` };
+    });
+
+    const result = syncPlan({
+      planPath: '/project/.planning/phases/42-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Tasks 1 and 2 already have markers, only Task 3 + parent should be created
+    // Parent + 1 new task = 2 createIssue calls
+    expect(result.skipped).toBeGreaterThanOrEqual(2);
+    expect(result.created).toBe(1); // only Task 3
+  });
+
+  it('adds issues to project board with correct sprint', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    ghClient.createIssue.mockReturnValue({ number: 400, url: 'https://github.com/o/r/issues/400', id: 'I_400' });
+
+    syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should add items to project board
+    expect(ghProjects.addItem).toHaveBeenCalled();
+
+    // Should set Sprint field
+    expect(ghProjects.setField).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fieldId: 'PVTSSF_sprint',
+      })
+    );
+  });
+
+  it('auto-creates sprint option if missing', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    ghClient.createIssue.mockReturnValue({ number: 400, url: 'https://github.com/o/r/issues/400', id: 'I_400' });
+
+    // Sprint "S97" does not exist in current options (only S96)
+    // findOption for sprint should return null for S97
+    ghProjects.findOption.mockImplementation((field, optionName) => {
+      if (!field || !field.options) return null;
+      return field.options.find(o => o.name.toLowerCase() === optionName.toLowerCase()) || null;
+    });
+
+    syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should have created sprint option "S97"
+    expect(ghProjects.createOption).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fieldId: 'PVTSSF_sprint',
+        name: 'S97',
+      })
+    );
+  });
+
+  it('sets Status field based on task marker', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    let issueCounter = 700;
+    ghClient.createIssue.mockImplementation(() => {
+      const num = issueCounter++;
+      return { number: num, url: `https://github.com/o/r/issues/${num}`, id: `I_${num}` };
+    });
+
+    syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should set Status for each task
+    // Task 1 [ ] → Backlog, Task 2 [>@alice] → In progress, Task 4 [x] → Done, etc.
+    const setFieldCalls = ghProjects.setField.mock.calls;
+    const statusCalls = setFieldCalls.filter(c => c[0].fieldId === 'PVTSSF_status');
+
+    // There should be status calls for each task
+    expect(statusCalls.length).toBeGreaterThan(0);
+
+    // Check that different option IDs are used for different statuses
+    const optionIds = statusCalls.map(c => c[0].optionId);
+    // Should see both backlog and in-progress and done
+    expect(optionIds).toContain('opt_backlog');
+    expect(optionIds).toContain('opt_inprogress');
+    expect(optionIds).toContain('opt_done');
+  });
+
+  it('writes markers back to PLAN.md', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    let issueCounter = 800;
+    ghClient.createIssue.mockImplementation(() => {
+      const num = issueCounter++;
+      return { number: num, url: `https://github.com/o/r/issues/${num}`, id: `I_${num}` };
+    });
+
+    syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should write back to the plan file
+    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+      '/project/.planning/phases/97-PLAN.md',
+      expect.stringContaining('<!-- #')
+    );
+  });
+
+  it('returns correct created/updated/skipped counts', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    let issueCounter = 900;
+    ghClient.createIssue.mockImplementation(() => {
+      const num = issueCounter++;
+      return { number: num, url: `https://github.com/o/r/issues/${num}`, id: `I_${num}` };
+    });
+
+    const result = syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    expect(result).toHaveProperty('created');
+    expect(result).toHaveProperty('updated');
+    expect(result).toHaveProperty('skipped');
+    expect(result).toHaveProperty('errors');
+    expect(result.created).toBe(5);
+    expect(result.skipped).toBe(0);
+    expect(Array.isArray(result.errors)).toBe(true);
+  });
+
+  it('handles ghClient errors gracefully (logs, continues with next task)', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    let callCount = 0;
+    ghClient.createIssue.mockImplementation(() => {
+      callCount++;
+      // First call (parent) succeeds, second call (task 1) fails, rest succeed
+      if (callCount === 2) {
+        return { error: 'API rate limit exceeded', code: 'GH_API_ERROR' };
+      }
+      return { number: callCount * 100, url: `https://github.com/o/r/issues/${callCount * 100}`, node_id: `I_${callCount * 100}` };
+    });
+
+    const result = syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should continue creating other issues despite the failure
+    expect(ghClient.createIssue.mock.calls.length).toBeGreaterThan(2);
+    // Should report the error
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+
+  it('uses phasePrefix "S" to build sprint name "S97"', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    ghClient.createIssue.mockReturnValue({ number: 400, url: 'https://github.com/o/r/issues/400', id: 'I_400' });
+    config.github.phasePrefix = 'S';
+
+    syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Check that createOption was called with "S97" (not "Phase-97")
+    if (ghProjects.createOption.mock.calls.length > 0) {
+      expect(ghProjects.createOption).toHaveBeenCalledWith(
+        expect.objectContaining({ name: 'S97' })
+      );
+    }
+  });
+
+  it('uses phasePrefix "Phase" to build sprint name "Phase-97"', () => {
+    ghClient.listIssues.mockReturnValue([]);
+    ghClient.createIssue.mockReturnValue({ number: 400, url: 'https://github.com/o/r/issues/400', id: 'I_400' });
+    config.github.phasePrefix = 'Phase';
+
+    syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    if (ghProjects.createOption.mock.calls.length > 0) {
+      expect(ghProjects.createOption).toHaveBeenCalledWith(
+        expect.objectContaining({ name: 'Phase-97' })
+      );
+    }
+  });
+
+  it('does not re-create parent phase issue if it already exists', () => {
+    // listIssues returns an existing phase issue
+    ghClient.listIssues.mockReturnValue([
+      { number: 50, title: 'Phase 97: GitHub Deep Integration', state: 'OPEN', labels: [], assignees: [] },
+    ]);
+
+    let issueCounter = 600;
+    ghClient.createIssue.mockImplementation(() => {
+      const num = issueCounter++;
+      return { number: num, url: `https://github.com/o/r/issues/${num}`, id: `I_${num}` };
+    });
+
+    syncPlan({
+      planPath: '/project/.planning/phases/97-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // No call should create a parent issue with "Phase 97:" prefix as title
+    // Only task issues should be created (5 tasks, not 6)
+    expect(ghClient.createIssue).toHaveBeenCalledTimes(5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// updateTaskStatuses
+// ---------------------------------------------------------------------------
+
+describe('updateTaskStatuses', () => {
+  let ghClient, ghProjects, config, mockFs;
+
+  beforeEach(() => {
+    ghClient = makeGhClient();
+    ghProjects = makeGhProjects();
+    config = makeConfig();
+    // Plan with markers: Task 1 todo #101, Task 2 in_progress #102, Task 3 todo (no marker)
+    mockFs = makeMockFs(PLAN_WITH_MARKERS);
+  });
+
+  it('closes issues for done tasks', () => {
+    // Change Task 1 to done in the plan content
+    const donePlan = PLAN_WITH_MARKERS.replace(
+      '### Task 1: First Task [ ] <!-- #101 -->',
+      '### Task 1: First Task [x] <!-- #101 -->'
+    );
+    mockFs = makeMockFs(donePlan);
+
+    // Mock getItems to return current project state (Task 1 was "Backlog")
+    ghProjects.getItems.mockReturnValue([
+      {
+        itemId: 'PVTI_1',
+        contentId: 'I_101',
+        contentType: 'Issue',
+        title: '[Phase 42] Task 1: First Task',
+        fieldValues: { Status: 'Backlog', Sprint: 'S42' },
+      },
+    ]);
+
+    const result = updateTaskStatuses({
+      planPath: '/project/.planning/phases/42-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should close the issue
+    expect(ghClient.closeIssue).toHaveBeenCalledWith(
+      expect.objectContaining({ number: 101 })
+    );
+    expect(result.closed).toBeGreaterThanOrEqual(1);
+  });
+
+  it('assigns issues for claimed tasks', () => {
+    // Task 2 is [>@carol] with marker #102
+    ghProjects.getItems.mockReturnValue([
+      {
+        itemId: 'PVTI_2',
+        contentId: 'I_102',
+        contentType: 'Issue',
+        title: '[Phase 42] Task 2: Second Task',
+        fieldValues: { Status: 'Backlog', Sprint: 'S42' },
+      },
+    ]);
+
+    const result = updateTaskStatuses({
+      planPath: '/project/.planning/phases/42-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should assign carol to issue #102
+    expect(ghClient.assignIssue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        number: 102,
+        assignees: ['carol'],
+      })
+    );
+    expect(result.updated).toBeGreaterThanOrEqual(1);
+  });
+
+  it('sets project Status field correctly', () => {
+    // Task 2 is in_progress — should set Status to "In progress"
+    ghProjects.getItems.mockReturnValue([
+      {
+        itemId: 'PVTI_2',
+        contentId: 'I_102',
+        contentType: 'Issue',
+        title: '[Phase 42] Task 2: Second Task',
+        fieldValues: { Status: 'Backlog', Sprint: 'S42' },
+      },
+    ]);
+
+    const result = updateTaskStatuses({
+      planPath: '/project/.planning/phases/42-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Should set Status to "In progress"
+    expect(ghProjects.setField).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fieldId: 'PVTSSF_status',
+        optionId: 'opt_inprogress',
+      })
+    );
+    expect(result.updated).toBeGreaterThanOrEqual(1);
+  });
+
+  it('skips tasks without issue markers', () => {
+    // Task 3 has no marker — should not attempt any updates for it
+    ghProjects.getItems.mockReturnValue([]);
+
+    const result = updateTaskStatuses({
+      planPath: '/project/.planning/phases/42-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    // Task 3 has no marker, so it should not trigger closeIssue or assignIssue for it
+    // Only Task 1 and Task 2 have markers
+    expect(result).toHaveProperty('updated');
+    expect(result).toHaveProperty('closed');
+  });
+
+  it('returns correct counts', () => {
+    ghProjects.getItems.mockReturnValue([]);
+
+    const result = updateTaskStatuses({
+      planPath: '/project/.planning/phases/42-PLAN.md',
+      config,
+      ghClient,
+      ghProjects,
+      fs: mockFs,
+    });
+
+    expect(typeof result.updated).toBe('number');
+    expect(typeof result.closed).toBe('number');
+  });
+});