github-issue-tower-defence-management 1.97.4 → 1.98.0

package/src/adapter/entry-points/handlers/InTmuxByHumanSessionTokenCountHandler.test.ts

@@ -0,0 +1,123 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import {
+  AWAITING_QUALITY_CHECK_STATUS_NAME,
+  IN_TMUX_STATUS_NAME,
+} from '../../../domain/entities/WorkflowStatus';
+import {
+  ClaudeInteractiveSession,
+  ClaudeInteractiveSessionRepository,
+} from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
+import { InTmuxByHumanSessionTokenCountHandler } from './InTmuxByHumanSessionTokenCountHandler';
+
+class FakeClaudeInteractiveSessionRepository implements ClaudeInteractiveSessionRepository {
+  constructor(private readonly sessions: ClaudeInteractiveSession[]) {}
+  listInteractiveSessions = (): ClaudeInteractiveSession[] => this.sessions;
+}
+
+const issueUrlA = 'https://github.com/HiromiShikata/example/issues/1';
+const issueUrlB = 'https://github.com/HiromiShikata/example/issues/2';
+
+const issue = (url: string, status: string): Issue => ({
+  nameWithOwner: 'HiromiShikata/example',
+  number: 1,
+  title: 'Example issue',
+  state: 'OPEN',
+  status,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url,
+  assignees: ['hiromi'],
+  labels: [],
+  org: 'HiromiShikata',
+  repo: 'example',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-01-01T00:00:00Z'),
+  author: 'hiromi',
+});
+
+describe('InTmuxByHumanSessionTokenCountHandler', () => {
+  let tokenListPath: string;
+
+  beforeEach(() => {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'token-list-'));
+    tokenListPath = path.join(directory, 'tokens.json');
+    fs.writeFileSync(
+      tokenListPath,
+      JSON.stringify([
+        { name: 'alpha', token: 'token-alpha' },
+        { name: 'beta', token: 'token-beta' },
+      ]),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(path.dirname(tokenListPath), { recursive: true, force: true });
+  });
+
+  it('writes one tab-separated line per token with In-Tmux-by-human counts', () => {
+    const handler = new InTmuxByHumanSessionTokenCountHandler(
+      new InTmuxByHumanSessionTokenCountUseCase(),
+      new FakeClaudeInteractiveSessionRepository([
+        { token: 'token-alpha', sessionId: 'session-a', issueUrl: issueUrlA },
+        { token: 'token-alpha', sessionId: 'session-a', issueUrl: issueUrlA },
+        { token: 'token-beta', sessionId: 'session-b', issueUrl: issueUrlB },
+      ]),
+    );
+
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      issues: [
+        issue(issueUrlA, IN_TMUX_STATUS_NAME),
+        issue(issueUrlB, AWAITING_QUALITY_CHECK_STATUS_NAME),
+      ],
+    });
+
+    expect(output.lines).toEqual(['alpha\t1', 'beta\t0']);
+  });
+
+  it('reports a diagnostic when no token list path is available', () => {
+    const handler = new InTmuxByHumanSessionTokenCountHandler(
+      new InTmuxByHumanSessionTokenCountUseCase(),
+      new FakeClaudeInteractiveSessionRepository([]),
+    );
+    const previous = process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
+    delete process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH;
+
+    const output = handler.handle({ tokenListJsonPath: null, issues: [] });
+
+    expect(output.lines).toEqual([]);
+    expect(output.diagnostics[0]).toContain('No token list path provided');
+
+    if (previous !== undefined) {
+      process.env.CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH = previous;
+    }
+  });
+
+  it('reports a diagnostic when the token list file has no usable entries', () => {
+    fs.writeFileSync(tokenListPath, JSON.stringify([]));
+    const handler = new InTmuxByHumanSessionTokenCountHandler(
+      new InTmuxByHumanSessionTokenCountUseCase(),
+      new FakeClaudeInteractiveSessionRepository([]),
+    );
+
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      issues: [],
+    });
+
+    expect(output.lines).toEqual([]);
+    expect(output.diagnostics[0]).toContain('No usable token entries');
+  });
+});

package/src/adapter/entry-points/handlers/InTmuxByHumanSessionTokenCountHandler.ts

@@ -0,0 +1,77 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { ClaudeInteractiveSessionRepository } from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
+import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
+import { ProcClaudeInteractiveSessionRepository } from '../../repositories/ProcClaudeInteractiveSessionRepository';
+import { loadTokenEntries } from '../../proxy/TokenListLoader';
+import { resolveTokenListJsonPath } from './OauthTokenSelectHandler';
+
+export type InTmuxByHumanSessionTokenCountHandlerInput = {
+  tokenListJsonPath: string | null;
+  issues: Issue[];
+};
+
+export type InTmuxByHumanSessionTokenCountHandlerOutput = {
+  lines: string[];
+  diagnostics: string[];
+};
+
+export class InTmuxByHumanSessionTokenCountHandler {
+  constructor(
+    private readonly useCase: InTmuxByHumanSessionTokenCountUseCase = new InTmuxByHumanSessionTokenCountUseCase(),
+    private readonly interactiveSessionRepository: ClaudeInteractiveSessionRepository = new ProcClaudeInteractiveSessionRepository(),
+  ) {}
+
+  handle = (
+    input: InTmuxByHumanSessionTokenCountHandlerInput,
+  ): InTmuxByHumanSessionTokenCountHandlerOutput => {
+    const tokenListJsonPath = resolveTokenListJsonPath(input.tokenListJsonPath);
+    if (tokenListJsonPath === null) {
+      return {
+        lines: [],
+        diagnostics: [
+          'No token list path provided. Pass --tokenListJsonPath or set CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH.',
+        ],
+      };
+    }
+
+    const entries = loadTokenEntries(tokenListJsonPath);
+    if (entries === null) {
+      return {
+        lines: [],
+        diagnostics: [
+          `No usable token entries loaded from ${tokenListJsonPath}.`,
+        ],
+      };
+    }
+
+    const candidates: OauthTokenCandidate[] = entries.map(
+      ({ name, token }) => ({
+        name,
+        token,
+        snapshot: null,
+      }),
+    );
+
+    const interactiveSessions =
+      this.interactiveSessionRepository.listInteractiveSessions();
+
+    const result = this.useCase.run(
+      candidates,
+      interactiveSessions,
+      input.issues,
+    );
+
+    const lines = result.counts.map((count) => `${count.name}\t${count.count}`);
+
+    const totalSessions = result.counts.reduce(
+      (sum, count) => sum + count.count,
+      0,
+    );
+    const diagnostics = [
+      `Counted ${totalSessions} live In-Tmux-by-human session(s) across ${result.counts.length} token(s).`,
+    ];
+
+    return { lines, diagnostics };
+  };
+}

package/src/adapter/repositories/ProcClaudeInteractiveSessionRepository.test.ts

@@ -0,0 +1,184 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ProcClaudeInteractiveSessionRepository } from './ProcClaudeInteractiveSessionRepository';
+
+type FakeProcess = {
+  pid: number;
+  cmdline: string;
+  environ: Record<string, string>;
+};
+
+const issueUrl = 'https://github.com/HiromiShikata/example/issues/1';
+
+const argv = (...parts: string[]): string => `${parts.join('\0')}\0`;
+
+describe('ProcClaudeInteractiveSessionRepository', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-proc-int-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(procDirectory, { recursive: true, force: true });
+  });
+
+  const writeProcess = (fakeProcess: FakeProcess): void => {
+    const processDirectory = path.join(procDirectory, String(fakeProcess.pid));
+    fs.mkdirSync(processDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(processDirectory, 'cmdline'),
+      fakeProcess.cmdline,
+    );
+    const environBuffer = Object.entries(fakeProcess.environ)
+      .map(([key, value]) => `${key}=${value}\0`)
+      .join('');
+    fs.writeFileSync(path.join(processDirectory, 'environ'), environBuffer);
+  };
+
+  it('reads token, session id and issue url from a cl-launched interactive process', () => {
+    writeProcess({
+      pid: 201,
+      cmdline: argv('claude', '--model', 'opus', '--name', issueUrl),
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-a',
+        CLAUDE_CODE_SESSION_ID: 'session-a',
+      },
+    });
+
+    const repository = new ProcClaudeInteractiveSessionRepository(
+      procDirectory,
+    );
+
+    expect(repository.listInteractiveSessions()).toEqual([
+      { token: 'token-a', sessionId: 'session-a', issueUrl },
+    ]);
+  });
+
+  it('ignores a process without a --name issue url argument', () => {
+    writeProcess({
+      pid: 202,
+      cmdline: argv('claude', '--model', 'opus'),
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-b',
+        CLAUDE_CODE_SESSION_ID: 'session-b',
+      },
+    });
+
+    const repository = new ProcClaudeInteractiveSessionRepository(
+      procDirectory,
+    );
+
+    expect(repository.listInteractiveSessions()).toEqual([]);
+  });
+
+  it('excludes a Take ownership aw spawn even when it carries the token', () => {
+    writeProcess({
+      pid: 203,
+      cmdline: argv(
+        'claude-agent',
+        '--agent',
+        'impl',
+        '-p',
+        `Take ownership of ${issueUrl} and finish it`,
+      ),
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-c',
+        CLAUDE_CODE_SESSION_ID: 'session-c',
+      },
+    });
+
+    const repository = new ProcClaudeInteractiveSessionRepository(
+      procDirectory,
+    );
+
+    expect(repository.listInteractiveSessions()).toEqual([]);
+  });
+
+  it('ignores a --name process without an oauth token', () => {
+    writeProcess({
+      pid: 204,
+      cmdline: argv('claude', '--name', issueUrl),
+      environ: {
+        CLAUDE_CODE_SESSION_ID: 'session-d',
+        ANTHROPIC_API_KEY: 'api-key',
+      },
+    });
+
+    const repository = new ProcClaudeInteractiveSessionRepository(
+      procDirectory,
+    );
+
+    expect(repository.listInteractiveSessions()).toEqual([]);
+  });
+
+  it('ignores a --name process without a session id', () => {
+    writeProcess({
+      pid: 205,
+      cmdline: argv('claude', '--name', issueUrl),
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-e',
+      },
+    });
+
+    const repository = new ProcClaudeInteractiveSessionRepository(
+      procDirectory,
+    );
+
+    expect(repository.listInteractiveSessions()).toEqual([]);
+  });
+
+  it('ignores a --name value that is not an http url', () => {
+    writeProcess({
+      pid: 206,
+      cmdline: argv('claude', '--name', 'just-a-label'),
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-f',
+        CLAUDE_CODE_SESSION_ID: 'session-f',
+      },
+    });
+
+    const repository = new ProcClaudeInteractiveSessionRepository(
+      procDirectory,
+    );
+
+    expect(repository.listInteractiveSessions()).toEqual([]);
+  });
+
+  it('returns one entry per child process so the use case can dedupe by session id', () => {
+    writeProcess({
+      pid: 207,
+      cmdline: argv('claude', '--name', issueUrl),
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-g',
+        CLAUDE_CODE_SESSION_ID: 'session-g',
+      },
+    });
+    writeProcess({
+      pid: 208,
+      cmdline: argv('claude', '--name', issueUrl),
+      environ: {
+        CLAUDE_CODE_OAUTH_TOKEN: 'token-g',
+        CLAUDE_CODE_SESSION_ID: 'session-g',
+      },
+    });
+
+    const repository = new ProcClaudeInteractiveSessionRepository(
+      procDirectory,
+    );
+
+    expect(repository.listInteractiveSessions()).toEqual([
+      { token: 'token-g', sessionId: 'session-g', issueUrl },
+      { token: 'token-g', sessionId: 'session-g', issueUrl },
+    ]);
+  });
+
+  it('returns an empty list when the proc directory does not exist', () => {
+    const repository = new ProcClaudeInteractiveSessionRepository(
+      path.join(procDirectory, 'missing'),
+    );
+
+    expect(repository.listInteractiveSessions()).toEqual([]);
+  });
+});

package/src/adapter/repositories/ProcClaudeInteractiveSessionRepository.ts

@@ -0,0 +1,138 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  ClaudeInteractiveSession,
+  ClaudeInteractiveSessionRepository,
+} from '../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const OAUTH_TOKEN_ENVIRON_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
+const SESSION_ID_ENVIRON_KEY = 'CLAUDE_CODE_SESSION_ID';
+const NAME_ARGUMENT = '--name';
+const TAKE_OWNERSHIP_MARKER = 'Take ownership';
+
+const isIssueUrl = (value: string): boolean =>
+  value.startsWith('http://') || value.startsWith('https://');
+
+const parseCommandLineArguments = (cmdline: string): string[] =>
+  cmdline.split('\0').filter((argument) => argument.length > 0);
+
+const extractIssueUrl = (commandArguments: string[]): string | null => {
+  for (let index = 0; index < commandArguments.length - 1; index += 1) {
+    if (commandArguments[index] === NAME_ARGUMENT) {
+      const value = commandArguments[index + 1] ?? '';
+      if (isIssueUrl(value)) {
+        return value;
+      }
+    }
+  }
+  return null;
+};
+
+const isTakeOwnershipSpawn = (commandArguments: string[]): boolean =>
+  commandArguments.some((argument) => argument.includes(TAKE_OWNERSHIP_MARKER));
+
+export class ProcClaudeInteractiveSessionRepository implements ClaudeInteractiveSessionRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+  ) {}
+
+  listInteractiveSessions = (): ClaudeInteractiveSession[] => {
+    const interactiveSessions: ClaudeInteractiveSession[] = [];
+    for (const pidDirectory of this.listProcessIdDirectories()) {
+      const interactiveSession = this.readInteractiveSession(pidDirectory);
+      if (interactiveSession !== null) {
+        interactiveSessions.push(interactiveSession);
+      }
+    }
+    return interactiveSessions;
+  };
+
+  private listProcessIdDirectories = (): string[] => {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(this.procDirectory);
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => /^\d+$/.test(entry));
+  };
+
+  private readInteractiveSession = (
+    processIdDirectory: string,
+  ): ClaudeInteractiveSession | null => {
+    const commandArguments = this.readCommandArguments(processIdDirectory);
+    if (commandArguments === null) {
+      return null;
+    }
+    if (isTakeOwnershipSpawn(commandArguments)) {
+      return null;
+    }
+    const issueUrl = extractIssueUrl(commandArguments);
+    if (issueUrl === null) {
+      return null;
+    }
+    const environ = this.readEnviron(processIdDirectory);
+    if (environ === null) {
+      return null;
+    }
+    const token = environ.get(OAUTH_TOKEN_ENVIRON_KEY);
+    const sessionId = environ.get(SESSION_ID_ENVIRON_KEY);
+    if (
+      token === undefined ||
+      token.length === 0 ||
+      sessionId === undefined ||
+      sessionId.length === 0
+    ) {
+      return null;
+    }
+    return { token, sessionId, issueUrl };
+  };
+
+  private readCommandArguments = (
+    processIdDirectory: string,
+  ): string[] | null => {
+    const cmdlinePath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'cmdline',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(cmdlinePath, 'utf8');
+    } catch {
+      return null;
+    }
+    return parseCommandLineArguments(raw);
+  };
+
+  private readEnviron = (
+    processIdDirectory: string,
+  ): Map<string, string> | null => {
+    const environPath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'environ',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(environPath, 'utf8');
+    } catch {
+      return null;
+    }
+    const environ = new Map<string, string>();
+    for (const entry of raw.split('\0')) {
+      if (entry.length === 0) {
+        continue;
+      }
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+      const key = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      environ.set(key, value);
+    }
+    return environ;
+  };
+}

package/src/domain/usecases/InTmuxByHumanSessionTokenCountUseCase.test.ts

@@ -0,0 +1,169 @@
+import { Issue } from '../entities/Issue';
+import {
+  AWAITING_QUALITY_CHECK_STATUS_NAME,
+  IN_TMUX_STATUS_NAME,
+} from '../entities/WorkflowStatus';
+import { ClaudeInteractiveSession } from './adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { InTmuxByHumanSessionTokenCountUseCase } from './InTmuxByHumanSessionTokenCountUseCase';
+import { OauthTokenCandidate } from './OauthTokenSelectUseCase';
+
+const candidate = (name: string): OauthTokenCandidate => ({
+  name,
+  token: `fake-token-${name}`,
+  snapshot: null,
+});
+
+const session = (
+  name: string,
+  sessionId: string,
+  issueUrl: string,
+): ClaudeInteractiveSession => ({
+  token: `fake-token-${name}`,
+  sessionId,
+  issueUrl,
+});
+
+const issue = (url: string, status: string): Issue => ({
+  nameWithOwner: 'HiromiShikata/example',
+  number: 1,
+  title: 'Example issue',
+  state: 'OPEN',
+  status,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url,
+  assignees: ['hiromi'],
+  labels: [],
+  org: 'HiromiShikata',
+  repo: 'example',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-01-01T00:00:00Z'),
+  author: 'hiromi',
+});
+
+describe('InTmuxByHumanSessionTokenCountUseCase', () => {
+  const useCase = new InTmuxByHumanSessionTokenCountUseCase();
+  const issueUrlA = 'https://github.com/HiromiShikata/example/issues/1';
+  const issueUrlB = 'https://github.com/HiromiShikata/example/issues/2';
+
+  it('counts a session whose issue is in In-Tmux-by-human status', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [session('alpha', 'session-a', issueUrlA)],
+      [issue(issueUrlA, IN_TMUX_STATUS_NAME)],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(1);
+  });
+
+  it('does not count a session whose issue is in another status', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [session('alpha', 'session-a', issueUrlA)],
+      [issue(issueUrlA, AWAITING_QUALITY_CHECK_STATUS_NAME)],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(0);
+  });
+
+  it('does not count a session whose issue is closed even in In-Tmux-by-human status', () => {
+    const closedIssue: Issue = {
+      ...issue(issueUrlA, IN_TMUX_STATUS_NAME),
+      isClosed: true,
+    };
+    const result = useCase.run(
+      [candidate('alpha')],
+      [session('alpha', 'session-a', issueUrlA)],
+      [closedIssue],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(0);
+  });
+
+  it('dedupes distinct sessions sharing one session id under the same token', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [
+        session('alpha', 'session-a', issueUrlA),
+        session('alpha', 'session-a', issueUrlA),
+        session('alpha', 'session-a', issueUrlA),
+      ],
+      [issue(issueUrlA, IN_TMUX_STATUS_NAME)],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(1);
+  });
+
+  it('counts distinct session ids separately under the same token', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [
+        session('alpha', 'session-a', issueUrlA),
+        session('alpha', 'session-b', issueUrlB),
+      ],
+      [
+        issue(issueUrlA, IN_TMUX_STATUS_NAME),
+        issue(issueUrlB, IN_TMUX_STATUS_NAME),
+      ],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(2);
+  });
+
+  it('reports counts per token across multiple tokens', () => {
+    const result = useCase.run(
+      [candidate('alpha'), candidate('beta')],
+      [
+        session('alpha', 'session-a', issueUrlA),
+        session('beta', 'session-b', issueUrlB),
+      ],
+      [
+        issue(issueUrlA, IN_TMUX_STATUS_NAME),
+        issue(issueUrlB, AWAITING_QUALITY_CHECK_STATUS_NAME),
+      ],
+    );
+
+    expect(result.counts).toEqual([
+      { name: 'alpha', token: 'fake-token-alpha', count: 1 },
+      { name: 'beta', token: 'fake-token-beta', count: 0 },
+    ]);
+
+    const beta = result.counts.find((entry) => entry.name === 'beta');
+    expect(beta?.count).toBe(0);
+  });
+
+  it('reports zero for a token with no matching interactive session', () => {
+    const result = useCase.run(
+      [candidate('lonely')],
+      [session('other', 'session-x', issueUrlA)],
+      [issue(issueUrlA, IN_TMUX_STATUS_NAME)],
+    );
+
+    const lonely = result.counts.find((entry) => entry.name === 'lonely');
+    expect(lonely?.count).toBe(0);
+  });
+
+  it('ignores a session whose issue url is not present among the issues', () => {
+    const result = useCase.run(
+      [candidate('alpha')],
+      [session('alpha', 'session-a', issueUrlB)],
+      [issue(issueUrlA, IN_TMUX_STATUS_NAME)],
+    );
+
+    const alpha = result.counts.find((entry) => entry.name === 'alpha');
+    expect(alpha?.count).toBe(0);
+  });
+});