agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/issue-tracker.spec.ts

@@ -0,0 +1,890 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  GitHubIssueTracker,
+  LinearIssueTracker,
+  JiraIssueTracker,
+  createIssueTracker
+} from '../src/application/services/issue-tracker-service.js';
+import type { GhRunner, HttpRunner } from '../src/application/services/issue-tracker-service.js';
+
+function makeGhRunner(stdout: string, exitCode = 0): GhRunner {
+  return vi.fn(async () => ({ stdout, exitCode }));
+}
+
+function makeHttpRunner(
+  responses: Array<{ status?: number; ok?: boolean; body?: unknown }>
+): HttpRunner & ReturnType<typeof vi.fn> {
+  const queue = [...responses];
+  const runner = vi.fn(async () => {
+    const next = queue.shift() ?? { status: 500, ok: false, body: '' };
+    const body =
+      typeof next.body === 'string'
+        ? next.body
+        : next.body === undefined
+          ? ''
+          : JSON.stringify(next.body);
+    return {
+      status: next.status ?? 200,
+      ok: next.ok ?? true,
+      body
+    };
+  });
+  return runner as HttpRunner & ReturnType<typeof vi.fn>;
+}
+
+describe('G9: Multi-Tracker Support', () => {
+  describe('GitHubIssueTracker', () => {
+    it('getIssue parses gh CLI output', async () => {
+      const payload = JSON.stringify({
+        number: 42,
+        title: 'Add dark mode',
+        body: 'Users want dark mode.',
+        state: 'OPEN',
+        url: 'https://github.com/org/repo/issues/42'
+      });
+      const runner = makeGhRunner(payload);
+      const tracker = new GitHubIssueTracker({ repo: 'org/repo' }, runner);
+
+      const issue = await tracker.getIssue('42');
+      expect(issue.id).toBe('42');
+      expect(issue.title).toBe('Add dark mode');
+      expect(issue.status).toBe('open');
+      expect(issue.url).toContain('issues/42');
+    });
+
+    it('getIssue returns empty fallback when gh is not available', async () => {
+      const runner = makeGhRunner('', 127);
+      const tracker = new GitHubIssueTracker({}, runner);
+
+      const issue = await tracker.getIssue('99');
+      expect(issue.id).toBe('99');
+      expect(issue.title).toBe('');
+      expect(issue.status).toBe('unknown');
+    });
+
+    it('updateIssueStatus and addComment route through gh CLI args', async () => {
+      const runner = makeGhRunner('');
+      const tracker = new GitHubIssueTracker({ repo: 'org/repo' }, runner);
+
+      await tracker.updateIssueStatus('42', 'merged');
+      await tracker.addComment('42', 'AOP: status -> merged');
+
+      expect(runner).toHaveBeenCalledWith(expect.arrayContaining(['issue', 'edit', '42', '--state', 'closed']));
+      expect(runner).toHaveBeenCalledWith(
+        expect.arrayContaining(['issue', 'comment', '42', '--body', 'AOP: status -> merged'])
+      );
+    });
+
+    it('GIVEN_no_ghRunner_injected_WHEN_getIssue_called_THEN_returns_fallback_issue', async () => {
+      const tracker = new GitHubIssueTracker({});
+      const issue = await tracker.getIssue('999');
+      expect(issue.id).toBe('999');
+      expect(issue.status).toBe('unknown');
+    });
+  });
+
+  describe('LinearIssueTracker', () => {
+    it('GIVEN_linear_issue_exists_WHEN_getIssue_called_THEN_parses_graphql_response', async () => {
+      const httpRunner = makeHttpRunner([
+        {
+          body: {
+            data: {
+              issueByIdentifier: {
+                id: 'lin_uuid_1',
+                identifier: 'LIN-123',
+                title: 'Ship feature flag',
+                description: 'Implement rollout toggle',
+                url: 'https://linear.app/acme/issue/LIN-123',
+                state: { name: 'In Progress' }
+              }
+            }
+          }
+        }
+      ]);
+      const tracker = new LinearIssueTracker(
+        {
+          token: 'linear-token',
+          base_url: 'https://api.linear.app/graphql'
+        },
+        httpRunner
+      );
+
+      const issue = await tracker.getIssue('LIN-123');
+
+      expect(issue).toMatchObject({
+        id: 'LIN-123',
+        title: 'Ship feature flag',
+        body: 'Implement rollout toggle',
+        status: 'in progress',
+        url: 'https://linear.app/acme/issue/LIN-123'
+      });
+      expect(httpRunner).toHaveBeenCalledTimes(1);
+      expect(httpRunner).toHaveBeenCalledWith(
+        'https://api.linear.app/graphql',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer linear-token'
+          })
+        })
+      );
+    });
+
+    it('GIVEN_state_id_mapping_WHEN_updateIssueStatus_called_THEN_issues_graphql_issueUpdate_mutation', async () => {
+      const httpRunner = makeHttpRunner([
+        {
+          body: {
+            data: {
+              issueByIdentifier: {
+                id: 'lin_uuid_2',
+                identifier: 'LIN-200',
+                title: 'Refactor queue',
+                description: '',
+                url: 'https://linear.app/acme/issue/LIN-200',
+                state: { name: 'Todo' }
+              }
+            }
+          }
+        },
+        {
+          body: {
+            data: {
+              issueUpdate: {
+                success: true
+              }
+            }
+          }
+        }
+      ]);
+      const tracker = new LinearIssueTracker(
+        {
+          state_id_building: 'state_in_progress'
+        },
+        httpRunner
+      );
+
+      await tracker.updateIssueStatus('LIN-200', 'building');
+
+      expect(httpRunner).toHaveBeenCalledTimes(2);
+      const secondCallBody = JSON.parse(String(httpRunner.mock.calls[1]?.[1]?.body));
+      expect(secondCallBody.query).toContain('issueUpdate');
+      expect(secondCallBody.variables).toMatchObject({
+        id: 'lin_uuid_2',
+        stateId: 'state_in_progress'
+      });
+    });
+
+    it('GIVEN_issue_exists_WHEN_addComment_called_THEN_posts_commentCreate_mutation', async () => {
+      const httpRunner = makeHttpRunner([
+        {
+          body: {
+            data: {
+              issueByIdentifier: {
+                id: 'lin_uuid_3',
+                identifier: 'LIN-300',
+                title: 'Fix race condition',
+                description: '',
+                url: 'https://linear.app/acme/issue/LIN-300',
+                state: { name: 'Todo' }
+              }
+            }
+          }
+        },
+        {
+          body: {
+            data: {
+              commentCreate: {
+                success: true
+              }
+            }
+          }
+        }
+      ]);
+      const tracker = new LinearIssueTracker({}, httpRunner);
+
+      await tracker.addComment('LIN-300', 'AOP: feature status changed to `qa`');
+
+      expect(httpRunner).toHaveBeenCalledTimes(2);
+      const secondCallBody = JSON.parse(String(httpRunner.mock.calls[1]?.[1]?.body));
+      expect(secondCallBody.query).toContain('commentCreate');
+      expect(secondCallBody.variables).toMatchObject({
+        issueId: 'lin_uuid_3',
+        body: 'AOP: feature status changed to `qa`'
+      });
+    });
+
+    it('GIVEN_linear_api_failure_WHEN_getIssue_called_THEN_returns_unknown_fallback', async () => {
+      const httpRunner = makeHttpRunner([{ ok: false, status: 500, body: '' }]);
+      const tracker = new LinearIssueTracker({}, httpRunner);
+
+      const issue = await tracker.getIssue('LIN-500');
+      expect(issue).toEqual({
+        id: 'LIN-500',
+        title: '',
+        body: '',
+        status: 'unknown',
+        url: ''
+      });
+    });
+  });
+
+  describe('JiraIssueTracker', () => {
+    it('GIVEN_jira_issue_exists_WHEN_getIssue_called_THEN_parses_rest_fields', async () => {
+      const httpRunner = makeHttpRunner([
+        {
+          body: {
+            key: 'PROJ-42',
+            fields: {
+              summary: 'Fix flaky pipeline',
+              description: 'Investigate and stabilize',
+              status: { name: 'In Progress' }
+            }
+          }
+        }
+      ]);
+      const tracker = new JiraIssueTracker(
+        {
+          base_url: 'https://jira.example.com',
+          email: 'dev@example.com',
+          token: 'jira-token'
+        },
+        httpRunner
+      );
+
+      const issue = await tracker.getIssue('PROJ-42');
+      expect(issue).toMatchObject({
+        id: 'PROJ-42',
+        title: 'Fix flaky pipeline',
+        body: 'Investigate and stabilize',
+        status: 'in progress',
+        url: 'https://jira.example.com/browse/PROJ-42'
+      });
+      expect(httpRunner).toHaveBeenCalledWith(
+        'https://jira.example.com/rest/api/2/issue/PROJ-42?fields=summary,description,status',
+        expect.objectContaining({
+          method: 'GET',
+          headers: expect.objectContaining({
+            Authorization: expect.stringContaining('Basic ')
+          })
+        })
+      );
+    });
+
+    it('GIVEN_matching_transition_WHEN_updateIssueStatus_called_THEN_posts_transition_update', async () => {
+      const httpRunner = makeHttpRunner([
+        {
+          body: {
+            transitions: [
+              { id: '11', name: 'To Do' },
+              { id: '22', name: 'In Progress' },
+              { id: '33', name: 'Done' }
+            ]
+          }
+        },
+        {
+          body: {}
+        }
+      ]);
+      const tracker = new JiraIssueTracker(
+        {
+          base_url: 'https://jira.example.com',
+          transition_building: 'In Progress'
+        },
+        httpRunner
+      );
+
+      await tracker.updateIssueStatus('PROJ-7', 'building');
+
+      expect(httpRunner).toHaveBeenCalledTimes(2);
+      expect(httpRunner).toHaveBeenNthCalledWith(
+        2,
+        'https://jira.example.com/rest/api/2/issue/PROJ-7/transitions',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({ transition: { id: '22' } })
+        })
+      );
+    });
+
+    it('GIVEN_comment_WHEN_addComment_called_THEN_posts_comment_payload', async () => {
+      const httpRunner = makeHttpRunner([{ body: {} }]);
+      const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com' }, httpRunner);
+
+      await tracker.addComment('PROJ-8', 'AOP: feature status changed to `merged`');
+
+      expect(httpRunner).toHaveBeenCalledWith(
+        'https://jira.example.com/rest/api/2/issue/PROJ-8/comment',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({ body: 'AOP: feature status changed to `merged`' })
+        })
+      );
+    });
+  });
+
+  describe('createIssueTracker factory', () => {
+    it('returns tracker instances for known types and honors enabled=false', () => {
+      const github = createIssueTracker({ type: 'github', config: { repo: 'o/r' } });
+      const linear = createIssueTracker({ type: 'linear' });
+      const jira = createIssueTracker({ type: 'jira' });
+      const disabled = createIssueTracker({ type: 'github', enabled: false });
+
+      expect(github).toBeInstanceOf(GitHubIssueTracker);
+      expect(linear).toBeInstanceOf(LinearIssueTracker);
+      expect(jira).toBeInstanceOf(JiraIssueTracker);
+      expect(disabled).toBeUndefined();
+    });
+
+    it('returns undefined for unknown type and undefined config', () => {
+      expect(createIssueTracker({ type: 'unknown-tracker' })).toBeUndefined();
+      expect(createIssueTracker(undefined)).toBeUndefined();
+    });
+  });
+});
+
+describe('issue-tracker-service branch coverage', () => {
+  describe('createGhRunner', () => {
+    it('GIVEN_function_provided_WHEN_createGhRunner_called_THEN_returns_that_function', async () => {
+      const { createGhRunner } = await import('../src/application/services/issue-tracker-service.js');
+      const custom = vi.fn(async () => ({ stdout: 'ok', exitCode: 0 }));
+      const runner = createGhRunner(custom as GhRunner);
+      expect(runner).toBe(custom);
+    });
+  });
+
+  describe('GitHubIssueTracker', () => {
+    it('GIVEN_gh_not_found_WHEN_getIssue_called_THEN_returns_fallback', async () => {
+      const runner: GhRunner = async () => ({ stdout: '', exitCode: 127 });
+      const tracker = new GitHubIssueTracker({}, runner);
+      const issue = await tracker.getIssue('123');
+      expect(issue.id).toBe('123');
+      expect(issue.url).toBe('');
+    });
+
+    it('GIVEN_invalid_json_WHEN_getIssue_called_THEN_returns_fallback', async () => {
+      const runner: GhRunner = async () => ({ stdout: '', exitCode: 0 });
+      const tracker = new GitHubIssueTracker({}, runner);
+      const issue = await tracker.getIssue('456');
+      expect(issue.id).toBe('456');
+    });
+  });
+
+  describe('LinearIssueTracker', () => {
+    it('GIVEN_status_blocked_WHEN_updateIssueStatus_called_THEN_maps_to_blocked', async () => {
+      const calls: Array<[string, string, string]> = [];
+      const runner: HttpRunner = async (_url, init) => {
+        const body = JSON.parse(init.body as string) as Record<string, unknown>;
+        const vars = body['variables'] as Record<string, unknown> | undefined;
+        calls.push([body['query'] as string, vars?.['issueId'] as string, vars?.['stateId'] as string]);
+        return { status: 200, ok: true, body: JSON.stringify({ data: { issueUpdate: { success: true } } }) };
+      };
+      const tracker = new LinearIssueTracker({ token: 'tok', state_blocked: 'state_b' }, runner);
+      await tracker.updateIssueStatus('LIN-1', 'blocked');
+      expect(calls.length).toBeGreaterThan(0);
+    });
+
+    it('GIVEN_http_failure_WHEN_getIssue_called_THEN_returns_fallback_unknown', async () => {
+      const runner: HttpRunner = async () => { throw new Error('network error'); };
+      const tracker = new LinearIssueTracker({ token: 'tok' }, runner as never);
+      const issue = await tracker.getIssue('LIN-999');
+      expect(issue.id).toBe('LIN-999');
+    });
+  });
+
+  describe('JiraIssueTracker', () => {
+    it('GIVEN_status_planning_WHEN_updateIssueStatus_called_THEN_maps_to_to_do_transition', async () => {
+      const calls: Array<unknown> = [];
+      const runner: HttpRunner = async (_url, init) => {
+        calls.push(JSON.parse(init.body as string));
+        return { status: 204, ok: true, body: '' };
+      };
+      // Need to stub getTransitions first (GET /transitions returns match)
+      let callCount = 0;
+      const mockRunner: HttpRunner = async (url, init) => {
+        callCount += 1;
+        if (url.includes('transitions') && (!init.method || init.method === 'GET')) {
+          return {
+            status: 200, ok: true, body: JSON.stringify({
+              transitions: [{ id: 't1', name: 'To Do' }]
+            })
+          };
+        }
+        return runner(url, init);
+      };
+      const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok', email: 'me@example.com' }, mockRunner);
+      await tracker.updateIssueStatus('PROJ-1', 'planning');
+      expect(callCount).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe('JiraIssueTracker additional branch coverage', () => {
+  it('GIVEN_requestJson_returns_null_WHEN_getIssue_called_THEN_returns_fallback', async () => {
+    // Return non-ok response → requestJson returns null
+    const runner: HttpRunner = async () => ({ status: 404, ok: false, body: '' });
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok' }, runner);
+    const issue = await tracker.getIssue('PROJ-999');
+    expect(issue.id).toBe('PROJ-999');
+    expect(issue.status).toBe('unknown');
+  });
+
+  it('GIVEN_no_matching_transition_WHEN_updateIssueStatus_called_THEN_returns_without_posting', async () => {
+    const calls: string[] = [];
+    const runner: HttpRunner = async (url, init) => {
+      calls.push(`${String(init.method ?? 'GET')} ${url}`);
+      // Only GET for transitions, no matching transition name
+      return {
+        status: 200, ok: true, body: JSON.stringify({ transitions: [{ id: 'x', name: 'To Do' }] })
+      };
+    };
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok' }, runner);
+    // 'building' maps to 'in progress' but transitions only have 'To Do'
+    await tracker.updateIssueStatus('PROJ-1', 'building');
+    // Only GET should have been called (no POST)
+    expect(calls.every((c) => c.startsWith('GET'))).toBe(true);
+  });
+
+  it('GIVEN_no_base_url_WHEN_requestJson_called_THEN_returns_null_and_getIssue_returns_fallback', async () => {
+    const runner: HttpRunner = async () => ({ status: 200, ok: true, body: '{}' });
+    const tracker = new JiraIssueTracker({}, runner); // no base_url
+    const issue = await tracker.getIssue('PROJ-0');
+    expect(issue.status).toBe('unknown');
+  });
+
+  it('GIVEN_token_but_no_email_WHEN_authHeader_called_via_getIssue_THEN_uses_bearer_token', async () => {
+    let capturedAuth: string | undefined;
+    const runner: HttpRunner = async (_, init) => {
+      capturedAuth = (init.headers as Record<string, string>)?.['Authorization'];
+      return { status: 200, ok: true, body: JSON.stringify({ key: 'PROJ-1', fields: { summary: 'Test', status: { name: 'Open' } } }) };
+    };
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'mytoken' }, runner);
+    await tracker.getIssue('PROJ-1');
+    expect(capturedAuth).toBe('Bearer mytoken');
+  });
+});
+
+describe('issue-tracker-service additional branch coverage', () => {
+  it('GIVEN_jira_object_description_WHEN_toJiraDescription_called_THEN_returns_json_stringified', async () => {
+    // toJiraDescription is called internally when updating an issue that has an object description field
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: JSON.stringify({
+        key: 'PROJ-1',
+        fields: { summary: 'Test', description: { type: 'doc', content: [] }, status: { name: 'Open' } }
+      })
+    });
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok' }, runner);
+    // getIssue passes the description through toJiraDescription when calling addComment
+    const issue = await tracker.getIssue('PROJ-1');
+    // description field (object) should be stringified
+    expect(typeof issue.title).toBe('string');
+  });
+
+  it('GIVEN_jira_config_transition_override_WHEN_updateIssueStatus_THEN_uses_explicit_transition', async () => {
+    const calls: string[] = [];
+    const runner: HttpRunner = async (url, init) => {
+      calls.push(`${init.method} ${url}`);
+      if (init.method === 'GET') {
+        return {
+          status: 200,
+          ok: true,
+          body: JSON.stringify({ transitions: [{ id: '99', name: 'Custom Done' }] })
+        };
+      }
+      return { status: 204, ok: true, body: '' };
+    };
+    // config has explicit transition for 'merged' → 'custom done'
+    const tracker = new JiraIssueTracker(
+      { base_url: 'https://jira.example.com', token: 'tok', transition_merged: 'custom done' },
+      runner
+    );
+    await tracker.updateIssueStatus('PROJ-2', 'merged');
+    // POST should have been called since 'custom done' matches 'Custom Done' (case-insensitive)
+    expect(calls.some((c) => c.startsWith('POST'))).toBe(true);
+  });
+
+  it('GIVEN_linear_planning_status_WHEN_updateIssueStatus_THEN_maps_to_backlog', async () => {
+    const bodies: string[] = [];
+    const runner: HttpRunner = async (_, init) => {
+      bodies.push(init.body ?? '');
+      // First call: resolveIssueNode → return a valid issue
+      if (bodies.length === 1) {
+        return {
+          status: 200, ok: true,
+          body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-uuid-1', identifier: 'LIN-1', title: 'T', description: '', url: '', state: { name: 'Backlog' } } } })
+        };
+      }
+      // Second call: mutation
+      return { status: 200, ok: true, body: JSON.stringify({ data: { issueUpdate: { success: true } } }) };
+    };
+    // Provide state_id_backlog so resolveStateId returns non-null → mutation is called
+    const tracker = new LinearIssueTracker({ token: 'tok', state_id_backlog: 'state-backlog-id' }, runner);
+    await tracker.updateIssueStatus('LIN-1', 'planning');
+    // mapDefaultLinearStatus('planning') → 'backlog' → state_id_backlog → mutation called
+    expect(bodies.length).toBe(2);
+    expect(bodies[1]).toContain('issueUpdate');
+  });
+
+  it('GIVEN_linear_qa_status_WHEN_updateIssueStatus_THEN_maps_to_in_review', async () => {
+    const bodies: string[] = [];
+    const runner: HttpRunner = async (_, init) => {
+      bodies.push(init.body ?? '');
+      if (bodies.length === 1) {
+        return {
+          status: 200, ok: true,
+          body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-uuid-2', identifier: 'LIN-2', title: 'T', description: '', url: '', state: { name: 'In Review' } } } })
+        };
+      }
+      return { status: 200, ok: true, body: JSON.stringify({ data: { issueUpdate: { success: true } } }) };
+    };
+    // Provide state_id_in_review so resolveStateId returns non-null → mutation is called
+    const tracker = new LinearIssueTracker({ token: 'tok', state_id_in_review: 'state-inreview-id' }, runner);
+    await tracker.updateIssueStatus('LIN-2', 'qa');
+    // mapDefaultLinearStatus('qa') → 'in_review' → state_id_in_review → mutation called
+    expect(bodies.length).toBe(2);
+    expect(bodies[1]).toContain('issueUpdate');
+  });
+
+  it('GIVEN_jira_building_status_WHEN_updateIssueStatus_THEN_maps_to_in_progress', async () => {
+    const calls: string[] = [];
+    const runner: HttpRunner = async (url, init) => {
+      calls.push(`${init.method} ${url}`);
+      if (init.method === 'GET') {
+        return {
+          status: 200,
+          ok: true,
+          body: JSON.stringify({ transitions: [{ id: '5', name: 'In Progress' }] })
+        };
+      }
+      return { status: 204, ok: true, body: '' };
+    };
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok' }, runner);
+    await tracker.updateIssueStatus('PROJ-3', 'building');
+    // mapDefaultJiraTransition('building') → 'in progress' → matches 'In Progress'
+    expect(calls.some((c) => c.startsWith('POST'))).toBe(true);
+  });
+
+  it('GIVEN_jira_planning_status_WHEN_updateIssueStatus_THEN_maps_to_to_do', async () => {
+    const calls: string[] = [];
+    const runner: HttpRunner = async (url, init) => {
+      calls.push(`${init.method} ${url}`);
+      if (init.method === 'GET') {
+        return {
+          status: 200,
+          ok: true,
+          body: JSON.stringify({ transitions: [{ id: '1', name: 'To Do' }] })
+        };
+      }
+      return { status: 204, ok: true, body: '' };
+    };
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok' }, runner);
+    await tracker.updateIssueStatus('PROJ-4', 'planning');
+    // mapDefaultJiraTransition('planning') → 'to do' → matches 'To Do'
+    expect(calls.some((c) => c.startsWith('POST'))).toBe(true);
+  });
+
+  it('GIVEN_jira_blocked_status_WHEN_updateIssueStatus_THEN_maps_to_blocked', async () => {
+    const calls: string[] = [];
+    const runner: HttpRunner = async (url, init) => {
+      calls.push(`${init.method} ${url}`);
+      if (init.method === 'GET') {
+        return {
+          status: 200,
+          ok: true,
+          body: JSON.stringify({ transitions: [{ id: '7', name: 'Blocked' }] })
+        };
+      }
+      return { status: 204, ok: true, body: '' };
+    };
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok' }, runner);
+    await tracker.updateIssueStatus('PROJ-5', 'blocked');
+    expect(calls.some((c) => c.startsWith('POST'))).toBe(true);
+  });
+});
+
+describe('Issue tracker additional branch coverage', () => {
+  it('GIVEN_createHttpRunner_called_without_fn_WHEN_fetch_throws_THEN_returns_zero_status', async () => {
+    const { createHttpRunner } = await import('../src/application/services/issue-tracker-service.js');
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('network error'));
+    const runner = createHttpRunner();
+    const result = await runner('https://example.com', { method: 'GET' });
+    expect(result.status).toBe(0);
+    expect(result.ok).toBe(false);
+    expect(result.body).toBe('');
+    fetchSpy.mockRestore();
+  });
+
+  it('GIVEN_linear_graphql_response_with_errors_array_WHEN_getIssue_THEN_returns_fallback', async () => {
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: JSON.stringify({ data: {}, errors: [{ message: 'GraphQL error' }] })
+    });
+    const tracker = new LinearIssueTracker({ token: 'tok' }, runner);
+    const issue = await tracker.getIssue('LIN-99');
+    expect(issue.id).toBe('LIN-99');
+    expect(issue.title).toBe('');
+    expect(issue.status).toBe('unknown');
+  });
+
+  it('GIVEN_linear_response_with_non_object_parsed_WHEN_getIssue_THEN_returns_fallback', async () => {
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: JSON.stringify({ data: null })
+    });
+    const tracker = new LinearIssueTracker({ token: 'tok' }, runner);
+    const issue = await tracker.getIssue('LIN-100');
+    expect(issue.status).toBe('unknown');
+  });
+
+  it('GIVEN_linear_with_unknown_status_WHEN_updateIssueStatus_THEN_uses_in_progress_default', async () => {
+    const bodies: string[] = [];
+    const runner: HttpRunner = async (_, init) => {
+      bodies.push(init.body ?? '');
+      if (bodies.length === 1) {
+        return {
+          status: 200, ok: true,
+          body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-uuid-3', identifier: 'LIN-3', title: 'T', description: '', url: '', state: null } } })
+        };
+      }
+      return { status: 200, ok: true, body: JSON.stringify({ data: { issueUpdate: { success: true } } }) };
+    };
+    // Provide state_id_in_progress to cover the 'in_progress' default mapping for unknown status
+    const tracker = new LinearIssueTracker({ token: 'tok', state_id_in_progress: 'state-inprogress-id' }, runner);
+    await tracker.updateIssueStatus('LIN-3', 'some_random_unknown_status');
+    // mapDefaultLinearStatus returns 'in_progress' → state_id_in_progress → mutation called
+    expect(bodies.length).toBe(2);
+  });
+
+  it('GIVEN_linear_resolveStateId_no_explicit_no_default_WHEN_updateIssueStatus_THEN_no_mutation', async () => {
+    let callCount = 0;
+    const runner: HttpRunner = async () => {
+      callCount += 1;
+      if (callCount === 1) {
+        return {
+          status: 200, ok: true,
+          body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-uuid-4', identifier: 'LIN-4', title: 'T', description: '', url: '', state: null } } })
+        };
+      }
+      return { status: 200, ok: true, body: JSON.stringify({ data: {} }) };
+    };
+    // No state_id_* keys → resolveStateId returns null → no mutation
+    const tracker = new LinearIssueTracker({ token: 'tok' }, runner);
+    await tracker.updateIssueStatus('LIN-4', 'some_status');
+    // Only resolveIssueNode call (2 queries: by identifier + by id), no mutation
+    expect(callCount).toBeLessThanOrEqual(3);
+  });
+
+  it('GIVEN_jira_token_only_no_email_WHEN_requestJson_called_THEN_uses_bearer_auth', async () => {
+    const calls: { auth?: string }[] = [];
+    const runner: HttpRunner = async (_, init) => {
+      calls.push({ auth: (init.headers as Record<string, string>)['Authorization'] });
+      return { status: 200, ok: true, body: JSON.stringify({ key: 'PROJ-1', fields: { summary: 'Test', description: 'Body', status: { name: 'Open' } } }) };
+    };
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'my-token' }, runner);
+    const issue = await tracker.getIssue('PROJ-1');
+    expect(issue.title).toBe('Test');
+    expect(calls[0].auth).toMatch(/^Bearer /);
+  });
+
+  it('GIVEN_jira_no_base_url_WHEN_getIssue_called_THEN_returns_fallback', async () => {
+    const runner: HttpRunner = vi.fn(async () => ({ status: 200, ok: true, body: '' }));
+    const tracker = new JiraIssueTracker({}, runner);
+    const issue = await tracker.getIssue('PROJ-1');
+    expect(issue.title).toBe('');
+    expect(issue.status).toBe('unknown');
+  });
+
+  it('GIVEN_jira_no_matching_transition_WHEN_updateIssueStatus_THEN_no_post_made', async () => {
+    const calls: string[] = [];
+    const runner: HttpRunner = async (_url, init) => {
+      calls.push(init.method ?? 'GET');
+      return { status: 200, ok: true, body: JSON.stringify({ transitions: [{ id: '1', name: 'Open' }] }) };
+    };
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok' }, runner);
+    await tracker.updateIssueStatus('PROJ-1', 'merged'); // mapDefaultJiraTransition → 'done', no matching transition
+    expect(calls.filter((m) => m === 'POST')).toHaveLength(0);
+  });
+
+  it('GIVEN_jira_no_auth_WHEN_requestJson_called_THEN_no_authorization_header', async () => {
+    const calls: { hasAuth: boolean }[] = [];
+    const runner: HttpRunner = async (_, init) => {
+      calls.push({ hasAuth: 'Authorization' in (init.headers as Record<string, string>) });
+      return { status: 200, ok: true, body: JSON.stringify({ key: 'PROJ-1', fields: { summary: '', description: null, status: { name: 'Open' } } }) };
+    };
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com' }, runner);
+    await tracker.getIssue('PROJ-1');
+    expect(calls[0].hasAuth).toBe(false);
+  });
+
+  it('GIVEN_linear_http_response_not_ok_WHEN_graphQl_called_THEN_returns_null_and_fallback', async () => {
+    const runner: HttpRunner = async () => ({ status: 500, ok: false, body: '' });
+    const tracker = new LinearIssueTracker({ token: 'tok' }, runner);
+    const issue = await tracker.getIssue('LIN-500');
+    expect(issue.status).toBe('unknown');
+  });
+
+  it('GIVEN_jira_description_is_object_WHEN_getIssue_called_THEN_returns_json_string', async () => {
+    const runner: HttpRunner = async () => ({
+      status: 200, ok: true,
+      body: JSON.stringify({
+        key: 'PROJ-2',
+        fields: {
+          summary: 'Test',
+          description: { type: 'doc', content: [] },
+          status: { name: 'In Progress' }
+        }
+      })
+    });
+    const tracker = new JiraIssueTracker({ base_url: 'https://jira.example.com', token: 'tok' }, runner);
+    const issue = await tracker.getIssue('PROJ-2');
+    expect(issue.body).toContain('doc');
+  });
+});
+
+describe('LinearIssueTracker addComment and updateIssueStatus guard branches', () => {
+  it('GIVEN_issue_not_found_WHEN_addComment_called_THEN_returns_without_posting', async () => {
+    // resolveIssueNode returns null → !issue?.id guard returns early (lines 314-315)
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: JSON.stringify({ data: { issueByIdentifier: null } })
+    });
+    // Should not throw and should not call graphql mutation
+    let callCount = 0;
+    const countingRunner: HttpRunner = async (url, init) => {
+      callCount++;
+      return runner(url, init);
+    };
+    const tracker2 = new LinearIssueTracker({}, countingRunner);
+    await tracker2.addComment('LIN-999', 'some comment');
+    // Only the resolveIssueNode queries are called, no mutation
+    expect(callCount).toBeLessThanOrEqual(2);
+  });
+
+  it('GIVEN_resolved_issue_with_no_id_field_WHEN_addComment_called_THEN_returns_early', async () => {
+    // resolveIssueNode returns issue node but without id → !issue?.id guard
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: JSON.stringify({ data: { issueByIdentifier: { identifier: 'LIN-1', title: 'T', description: '', url: '' } } })
+    });
+    const tracker = new LinearIssueTracker({}, runner);
+    await expect(tracker.addComment('LIN-1', 'comment')).resolves.toBeUndefined();
+  });
+
+  it('GIVEN_issue_not_found_WHEN_updateIssueStatus_called_THEN_returns_without_mutation', async () => {
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: JSON.stringify({ data: { issueByIdentifier: null } })
+    });
+    const tracker = new LinearIssueTracker({ token: 'tok', state_id_building: 'state-id' }, runner);
+    await expect(tracker.updateIssueStatus('LIN-999', 'building')).resolves.toBeUndefined();
+  });
+});
+
+describe('LinearIssueTracker graphQl invalid body branch', () => {
+  it('GIVEN_response_body_is_invalid_json_WHEN_graphQl_called_THEN_returns_null_fallback', async () => {
+    // Returns ok:true but body is not valid JSON → tryParseJson returns null → lines 218-219 covered
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: 'not valid json {{ response'
+    });
+    const tracker = new LinearIssueTracker({}, runner);
+    const issue = await tracker.getIssue('LIN-invalid-json');
+    expect(issue.status).toBe('unknown');
+    expect(issue.id).toBe('LIN-invalid-json');
+  });
+
+  it('GIVEN_response_body_is_empty_string_WHEN_graphQl_called_THEN_returns_null_fallback', async () => {
+    // tryParseJson returns null for empty string → lines 218-219 covered
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: ''
+    });
+    const tracker = new LinearIssueTracker({}, runner);
+    const issue = await tracker.getIssue('LIN-empty-body');
+    expect(issue.status).toBe('unknown');
+  });
+});
+
+describe('LinearIssueTracker mapDefaultLinearStatus building branch', () => {
+  it('GIVEN_building_status_no_explicit_id_but_has_in_progress_WHEN_updateIssueStatus_THEN_uses_mapped_state', async () => {
+    // status='building' → normalizeAopStatus='building' → explicit (state_id_building) not in config
+    // → mapDefaultLinearStatus('building') → returns 'in_progress' → lines 168-169 covered
+    let callCount = 0;
+    const runner: HttpRunner = async () => {
+      callCount++;
+      if (callCount === 1) {
+        return { status: 200, ok: true, body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-uuid-build', identifier: 'LIN-B', title: 'T', description: '', url: '', state: null } } }) };
+      }
+      return { status: 200, ok: true, body: JSON.stringify({ data: { issueUpdate: { success: true } } }) };
+    };
+    // No state_id_building but has state_id_in_progress → mapDefaultLinearStatus('building') → 'in_progress'
+    const tracker = new LinearIssueTracker({ token: 'tok', state_id_in_progress: 'state-ip-id' }, runner);
+    await tracker.updateIssueStatus('LIN-B', 'building');
+    // Mutation should be called (callCount > 2 if resolveIssueNode needs 2 calls)
+    expect(callCount).toBeGreaterThan(1);
+  });
+});
+
+describe('LinearIssueTracker mapDefaultLinearStatus OR branches and lowerCaseStatus', () => {
+  it('GIVEN_status_closed_WHEN_updateIssueStatus_THEN_uses_done_default_mapping', async () => {
+    // 'closed' → normalized='closed' → line 155: merged||closed - 'merged' is FALSE, 'closed' is TRUE (Branch 0 covered)
+    let callCount = 0;
+    const runner: HttpRunner = async () => {
+      callCount++;
+      if (callCount === 1) {
+        return { status: 200, ok: true, body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-closed', identifier: 'LIN-C', title: 'T', description: '', url: '', state: null } } }) };
+      }
+      return { status: 200, ok: true, body: JSON.stringify({ data: { issueUpdate: { success: true } } }) };
+    };
+    const tracker = new LinearIssueTracker({ token: 'tok', state_id_done: 'state-done-id' }, runner);
+    await tracker.updateIssueStatus('LIN-C', 'closed');
+    expect(callCount).toBeGreaterThan(1);
+  });
+
+  it('GIVEN_status_failed_WHEN_updateIssueStatus_THEN_uses_blocked_default_mapping', async () => {
+    // 'failed' → normalized='failed' → line 158: blocked||failed - 'blocked' is FALSE, 'failed' is TRUE (Branch 0 covered)
+    let callCount = 0;
+    const runner: HttpRunner = async () => {
+      callCount++;
+      if (callCount === 1) {
+        return { status: 200, ok: true, body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-failed', identifier: 'LIN-F', title: 'T', description: '', url: '', state: null } } }) };
+      }
+      return { status: 200, ok: true, body: JSON.stringify({ data: { issueUpdate: { success: true } } }) };
+    };
+    const tracker = new LinearIssueTracker({ token: 'tok', state_id_blocked: 'state-blocked-id' }, runner);
+    await tracker.updateIssueStatus('LIN-F', 'failed');
+    expect(callCount).toBeGreaterThan(1);
+  });
+
+  it('GIVEN_issue_with_null_state_WHEN_getIssue_THEN_status_is_unknown', async () => {
+    // null state → state?.name = undefined → ?? '' → lowerCaseStatus('') → '' is falsy → 'unknown' (line 146 FALSE branch + line 291)
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-nostate', identifier: 'LIN-NS', title: 'No State', description: 'desc', url: 'https://x', state: null } } })
+    });
+    const tracker = new LinearIssueTracker({}, runner);
+    const issue = await tracker.getIssue('LIN-NS');
+    expect(issue.status).toBe('unknown');
+  });
+
+  it('GIVEN_issue_without_identifier_WHEN_getIssue_THEN_falls_back_to_id_or_issueId', async () => {
+    // issue.identifier is falsy → falls back to issue.id (line 288 Block 100 Branch 0 covered)
+    const runner: HttpRunner = async () => ({
+      status: 200,
+      ok: true,
+      body: JSON.stringify({ data: { issueByIdentifier: { id: 'lin-raw-id', identifier: '', title: 'T', description: 'desc', url: 'https://x', state: { name: 'In Progress' } } } })
+    });
+    const tracker = new LinearIssueTracker({}, runner);
+    const issue = await tracker.getIssue('LIN-NOID');
+    expect(issue.id).toBe('lin-raw-id');
+  });
+});