github-issue-tower-defence-management 1.104.4 → 1.106.0

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

@@ -0,0 +1,170 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { Project } from '../../../domain/entities/Project';
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { IN_TMUX_STATUS_NAME } from '../../../domain/entities/WorkflowStatus';
+import { cleanStaleTmuxSessions } from './staleTmuxSessionCleaner';
+
+const NOW = new Date('2026-06-26T00:00:00.000Z');
+const NOW_EPOCH_SECONDS = Math.floor(NOW.getTime() / 1000);
+const ALLOW_CACHE_MINUTES = 10;
+
+const makeProject = (): Project => ({
+  id: 'project-1',
+  url: 'https://github.com/users/user/projects/1',
+  databaseId: 1,
+  name: 'Test Project',
+  status: {
+    name: 'Status',
+    fieldId: 'field-1',
+    statuses: [],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: null,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+});
+
+const makeIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue 1',
+  state: 'OPEN',
+  status: IN_TMUX_STATUS_NAME,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/demo/repo/issues/1',
+  assignees: [],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date(),
+  author: '',
+  closingIssueReferenceUrls: [],
+  ...overrides,
+});
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+const createMockRunner = (): Mocked<LocalCommandRunner> => ({
+  runCommand: jest.fn(),
+});
+
+const createMockIssueRepository = (
+  issues: Issue[],
+): Pick<IssueRepository, 'getAllOpened'> => ({
+  getAllOpened: jest.fn().mockResolvedValue(issues),
+});
+
+describe('cleanStaleTmuxSessions', () => {
+  beforeEach(() => {
+    jest.spyOn(console, 'log').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('kills a session mapping to an open issue whose status is not the excluded status', async () => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: `https_//github_com/demo/repo/issues/1 ${NOW_EPOCH_SECONDS}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    await cleanStaleTmuxSessions({
+      project: makeProject(),
+      allowCacheMinutes: ALLOW_CACHE_MINUTES,
+      issueRepository: createMockIssueRepository([
+        makeIssue({ status: 'In Progress' }),
+      ]),
+      localCommandRunner: runner,
+      now: NOW,
+    });
+
+    const killCall = runner.runCommand.mock.calls.find(
+      (call) => call[0] === 'tmux' && call[1][0] === 'kill-session',
+    );
+    expect(killCall?.[1]).toEqual([
+      'kill-session',
+      '-t',
+      'https_//github_com/demo/repo/issues/1',
+    ]);
+  });
+
+  it('does not kill an excluded-status session that has no reactivation trigger', async () => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: `https_//github_com/demo/repo/issues/1 ${NOW_EPOCH_SECONDS}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    await cleanStaleTmuxSessions({
+      project: makeProject(),
+      allowCacheMinutes: ALLOW_CACHE_MINUTES,
+      issueRepository: createMockIssueRepository([
+        makeIssue({ status: IN_TMUX_STATUS_NAME }),
+      ]),
+      localCommandRunner: runner,
+      now: NOW,
+    });
+
+    const killCalls = runner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'tmux' && call[1][0] === 'kill-session',
+    );
+    expect(killCalls).toHaveLength(0);
+  });
+
+  it('kills a no-task session idle at least 24 hours and spares a recently active one', async () => {
+    const runner = createMockRunner();
+    const idleActivity = NOW_EPOCH_SECONDS - 24 * 60 * 60;
+    const recentActivity = NOW_EPOCH_SECONDS - 24 * 60 * 60 + 1;
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: `idle_no_task ${idleActivity}\nrecent_no_task ${recentActivity}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+
+    await cleanStaleTmuxSessions({
+      project: makeProject(),
+      allowCacheMinutes: ALLOW_CACHE_MINUTES,
+      issueRepository: createMockIssueRepository([]),
+      localCommandRunner: runner,
+      now: NOW,
+    });
+
+    const killCalls = runner.runCommand.mock.calls.filter(
+      (call) => call[0] === 'tmux' && call[1][0] === 'kill-session',
+    );
+    expect(killCalls).toHaveLength(1);
+    expect(killCalls[0][1]).toEqual(['kill-session', '-t', 'idle_no_task']);
+  });
+});

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

@@ -0,0 +1,40 @@
+import { Project } from '../../../domain/entities/Project';
+import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import {
+  StaleTmuxSessionKillUseCase,
+  DEFAULT_EXCLUDED_STATUS,
+  DEFAULT_IDLE_THRESHOLD_SECONDS,
+} from '../../../domain/usecases/StaleTmuxSessionKillUseCase';
+import { NodeTmuxSessionRepository } from '../../repositories/NodeTmuxSessionRepository';
+
+export type CleanStaleTmuxSessionsParams = {
+  project: Project;
+  allowCacheMinutes: number;
+  issueRepository: Pick<IssueRepository, 'getAllOpened'>;
+  localCommandRunner: LocalCommandRunner;
+  now: Date;
+};
+
+export const cleanStaleTmuxSessions = async (
+  params: CleanStaleTmuxSessionsParams,
+): Promise<void> => {
+  const {
+    project,
+    allowCacheMinutes,
+    issueRepository,
+    localCommandRunner,
+    now,
+  } = params;
+  const useCase = new StaleTmuxSessionKillUseCase(
+    issueRepository,
+    new NodeTmuxSessionRepository(localCommandRunner),
+  );
+  await useCase.run({
+    project,
+    allowCacheMinutes,
+    excludedStatus: DEFAULT_EXCLUDED_STATUS,
+    idleThresholdSeconds: DEFAULT_IDLE_THRESHOLD_SECONDS,
+    now,
+  });
+};

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

@@ -0,0 +1,176 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import { ClaudeInteractiveSession } from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { TakeOwnershipSpawn } from '../../../domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository';
+import { RateLimitSnapshot } from '../../proxy/RateLimitCache';
+import { TokenStatusFile, writeTokenStatus } from './tokenStatusWriter';
+
+const readJson = (filePath: string): unknown =>
+  JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
+
+const ASSIGNEE = 'HiromiShikata';
+
+const baseSnapshot = (
+  overrides: Partial<RateLimitSnapshot> = {},
+): RateLimitSnapshot => ({
+  fiveHourUtilization: 0.1,
+  fiveHourReset: 0,
+  sevenDayUtilization: 0.1,
+  sevenDayReset: 0,
+  blocked: false,
+  rejected: false,
+  unifiedRejected: false,
+  fiveHourRejected: false,
+  sevenDayRejected: false,
+  unifiedStatus: 'allowed',
+  overageDisabledReason: null,
+  modelWeeklyLimits: {},
+  lastUpdatedEpoch: 0,
+  blockedUntilEpoch: 0,
+  ...overrides,
+});
+
+const makeIssue = (overrides: Partial<Issue>): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue',
+  state: 'OPEN',
+  status: null,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/demo/repo/issues/1',
+  assignees: [ASSIGNEE],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-06-13T08:18:45.000Z'),
+  author: 'someone',
+  closingIssueReferenceUrls: [],
+  ...overrides,
+});
+
+describe('writeTokenStatus', () => {
+  let dir: string;
+  let tokenListPath: string;
+  const now = new Date('2026-06-26T12:00:00.000Z');
+  const nowEpoch = Math.floor(now.getTime() / 1000);
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-status-'));
+    tokenListPath = path.join(dir, 'tokens.json');
+    fs.writeFileSync(
+      tokenListPath,
+      JSON.stringify([
+        { name: 'alice', token: 'token-a' },
+        { name: 'bob', token: 'token-b' },
+      ]),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('writes token-status.json with per-token color, util, prep and hum', () => {
+    const interactiveSessions: ClaudeInteractiveSession[] = [
+      {
+        token: 'token-a',
+        sessionId: 'session-1',
+        issueUrl: 'https://github.com/demo/repo/issues/1',
+      },
+    ];
+    const spawns: TakeOwnershipSpawn[] = [
+      { token: 'token-a', logPath: '/logs-aw/x.log' },
+      { token: 'token-a', logPath: '/logs-aw/x.log' },
+      { token: 'token-a', logPath: '/logs-aw/y.log' },
+    ];
+
+    writeTokenStatus({
+      dashboardDataDir: dir,
+      tokenListJsonPath: tokenListPath,
+      issues: [
+        makeIssue({
+          status: 'In Tmux by human',
+          url: 'https://github.com/demo/repo/issues/1',
+        }),
+      ],
+      now,
+      readSnapshot: (token) =>
+        token === 'token-a'
+          ? baseSnapshot({
+              fiveHourUtilization: 0.42,
+              fiveHourReset: nowEpoch + 3600,
+              sevenDayUtilization: 0.5,
+              sevenDayReset: nowEpoch + 86400,
+            })
+          : null,
+      interactiveSessionRepository: {
+        listInteractiveSessions: () => interactiveSessions,
+      },
+      spawnRepository: { listSpawns: () => spawns },
+    });
+
+    const written = readJson(path.join(dir, 'token-status.json'));
+    const expected: TokenStatusFile = {
+      capturedAt: '2026-06-26T12:00:00.000Z',
+      tokens: [
+        {
+          name: 'alice',
+          fiveHourUtilizationPercent: 42,
+          fiveHourResetSeconds: 3600,
+          sevenDayUtilizationPercent: 50,
+          sevenDayResetSeconds: 86400,
+          color: 'G',
+          prep: 2,
+          hum: 1,
+        },
+        {
+          name: 'bob',
+          fiveHourUtilizationPercent: null,
+          fiveHourResetSeconds: null,
+          sevenDayUtilizationPercent: null,
+          sevenDayResetSeconds: null,
+          color: 'Y',
+          prep: 0,
+          hum: 0,
+        },
+      ],
+    };
+    expect(written).toEqual(expected);
+  });
+
+  it('is a no-op when dashboardDataDir is unset', () => {
+    writeTokenStatus({
+      dashboardDataDir: null,
+      tokenListJsonPath: tokenListPath,
+      issues: [],
+      readSnapshot: () => null,
+      interactiveSessionRepository: { listInteractiveSessions: () => [] },
+      spawnRepository: { listSpawns: () => [] },
+    });
+    expect(fs.existsSync(path.join(dir, 'token-status.json'))).toBe(false);
+  });
+
+  it('is a no-op when the token list path is unset', () => {
+    writeTokenStatus({
+      dashboardDataDir: dir,
+      tokenListJsonPath: null,
+      issues: [],
+      readSnapshot: () => null,
+      interactiveSessionRepository: { listInteractiveSessions: () => [] },
+      spawnRepository: { listSpawns: () => [] },
+    });
+    expect(fs.existsSync(path.join(dir, 'token-status.json'))).toBe(false);
+  });
+});

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

@@ -0,0 +1,139 @@
+import fs from 'fs';
+import path from 'path';
+import type { Issue } from '../../../domain/entities/Issue';
+import {
+  GenerateTokenStatusUseCase,
+  TokenRateLimitSnapshot,
+  TokenStatus,
+  TokenStatusInput,
+} from '../../../domain/usecases/dashboard/GenerateTokenStatusUseCase';
+import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
+import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
+import { ClaudeInteractiveSessionRepository } from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
+import { TakeOwnershipSpawnRepository } from '../../../domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository';
+import { RateLimitSnapshot, readRateLimit } from '../../proxy/RateLimitCache';
+import { loadTokenEntries } from '../../proxy/TokenListLoader';
+import { ProcClaudeInteractiveSessionRepository } from '../../repositories/ProcClaudeInteractiveSessionRepository';
+import { ProcTakeOwnershipSpawnRepository } from '../../repositories/ProcTakeOwnershipSpawnRepository';
+
+const SEVEN_DAY_SONNET_LIMIT_TYPE = 'seven_day_sonnet';
+const SEVEN_DAY_OPUS_LIMIT_TYPE = 'seven_day_opus';
+
+export type TokenStatusWriterParams = {
+  dashboardDataDir: string | null | undefined;
+  tokenListJsonPath: string | null | undefined;
+  issues: Issue[];
+  now?: Date;
+  readSnapshot?: (token: string) => RateLimitSnapshot | null;
+  interactiveSessionRepository?: ClaudeInteractiveSessionRepository;
+  spawnRepository?: TakeOwnershipSpawnRepository;
+};
+
+export type TokenStatusFile = {
+  tokens: TokenStatus[];
+  capturedAt: string;
+};
+
+const writeJsonAtomic = (filePath: string, data: unknown): void => {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(data));
+  fs.renameSync(tmpPath, filePath);
+};
+
+export const toTokenRateLimitSnapshot = (
+  snapshot: RateLimitSnapshot | null,
+): TokenRateLimitSnapshot | null => {
+  if (snapshot === null) {
+    return null;
+  }
+  const hasWindowData =
+    snapshot.unifiedStatus !== null ||
+    snapshot.fiveHourReset > 0 ||
+    snapshot.sevenDayReset > 0 ||
+    snapshot.fiveHourUtilization > 0 ||
+    snapshot.sevenDayUtilization > 0;
+  return {
+    fiveHourUtilization: snapshot.fiveHourUtilization,
+    fiveHourReset: snapshot.fiveHourReset,
+    sevenDayUtilization: snapshot.sevenDayUtilization,
+    sevenDayReset: snapshot.sevenDayReset,
+    blocked: snapshot.blocked,
+    fiveHourRejected: snapshot.fiveHourRejected,
+    sevenDayRejected: snapshot.sevenDayRejected,
+    unifiedStatus: snapshot.unifiedStatus,
+    sevenDaySonnetRejected:
+      snapshot.modelWeeklyLimits[SEVEN_DAY_SONNET_LIMIT_TYPE]?.rejected ??
+      false,
+    sevenDayOpusRejected:
+      snapshot.modelWeeklyLimits[SEVEN_DAY_OPUS_LIMIT_TYPE]?.rejected ?? false,
+    hasWindowData,
+  };
+};
+
+export const writeTokenStatus = (params: TokenStatusWriterParams): void => {
+  const { dashboardDataDir, tokenListJsonPath, issues } = params;
+  if (!dashboardDataDir || !tokenListJsonPath) {
+    return;
+  }
+
+  const entries = loadTokenEntries(tokenListJsonPath);
+  if (entries === null) {
+    return;
+  }
+
+  const readSnapshot = params.readSnapshot ?? readRateLimit;
+  const interactiveSessionRepository =
+    params.interactiveSessionRepository ??
+    new ProcClaudeInteractiveSessionRepository();
+  const spawnRepository =
+    params.spawnRepository ?? new ProcTakeOwnershipSpawnRepository();
+
+  const tokenInputs: TokenStatusInput[] = entries.map((entry) => ({
+    name: entry.name,
+    token: entry.token,
+    snapshot: toTokenRateLimitSnapshot(readSnapshot(entry.token)),
+  }));
+
+  const distinctLogPathsByToken = new Map<string, Set<string>>();
+  for (const spawn of spawnRepository.listSpawns()) {
+    const logPaths =
+      distinctLogPathsByToken.get(spawn.token) ?? new Set<string>();
+    logPaths.add(spawn.logPath);
+    distinctLogPathsByToken.set(spawn.token, logPaths);
+  }
+  const prepCountByToken = new Map<string, number>();
+  for (const [token, logPaths] of distinctLogPathsByToken.entries()) {
+    prepCountByToken.set(token, logPaths.size);
+  }
+
+  const candidates: OauthTokenCandidate[] = entries.map((entry) => ({
+    name: entry.name,
+    token: entry.token,
+    snapshot: null,
+  }));
+  const humResult = new InTmuxByHumanSessionTokenCountUseCase().run(
+    candidates,
+    interactiveSessionRepository.listInteractiveSessions(),
+    issues,
+  );
+  const humCountByToken = new Map<string, number>(
+    humResult.counts.map((count) => [count.token, count.count]),
+  );
+
+  const now = params.now ?? new Date();
+  const tokens = new GenerateTokenStatusUseCase().run({
+    tokens: tokenInputs,
+    prepCountByToken,
+    humCountByToken,
+    nowEpochSeconds: Math.floor(now.getTime() / 1000),
+  });
+
+  const file: TokenStatusFile = {
+    tokens,
+    capturedAt: now.toISOString(),
+  };
+
+  writeJsonAtomic(path.join(dashboardDataDir, 'token-status.json'), file);
+};

package/src/adapter/proxy/RateLimitCache.test.ts

@@ -180,6 +180,38 @@ describe('RateLimitCache', () => {
       expect(snapshot?.sevenDayRejected).toBe(false);
     });
 
+    it('should surface the raw unified status and overage-disabled reason headers', () => {
+      const token = 'unified-status-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed_warning',
+        'anthropic-ratelimit-unified-overage-disabled-reason': 'out_of_credits',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '50',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '40',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.unifiedStatus).toBe('allowed_warning');
+      expect(snapshot?.overageDisabledReason).toBe('out_of_credits');
+    });
+
+    it('should expose null for the unified status and overage-disabled reason when absent', () => {
+      const token = 'no-unified-status-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '50',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '40',
+      });
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.unifiedStatus).toBeNull();
+      expect(snapshot?.overageDisabledReason).toBeNull();
+    });
+
     it('should return null when file does not exist', () => {
       expect(readRateLimit('never-written-token')).toBeNull();
     });

package/src/adapter/proxy/RateLimitCache.ts

@@ -18,6 +18,8 @@ export interface RateLimitSnapshot {
   unifiedRejected: boolean;
   fiveHourRejected: boolean;
   sevenDayRejected: boolean;
+  unifiedStatus: string | null;
+  overageDisabledReason: string | null;
   modelWeeklyLimits: Record<string, ModelWeeklyLimit>;
   lastUpdatedEpoch: number;
   blockedUntilEpoch: number;
@@ -252,6 +254,8 @@ export const readRateLimit = (
     const status = headers['anthropic-ratelimit-unified-status'];
     const fiveHourStatus = headers['anthropic-ratelimit-unified-5h-status'];
     const sevenDayStatus = headers['anthropic-ratelimit-unified-7d-status'];
+    const overageDisabledReason =
+      headers['anthropic-ratelimit-unified-overage-disabled-reason'];
     const unifiedRejected = status === 'rejected';
     const fiveHourRejected = fiveHourStatus === 'rejected';
     const sevenDayRejected = sevenDayStatus === 'rejected';
@@ -273,6 +277,8 @@ export const readRateLimit = (
       unifiedRejected,
       fiveHourRejected,
       sevenDayRejected,
+      unifiedStatus: status ?? null,
+      overageDisabledReason: overageDisabledReason ?? null,
       modelWeeklyLimits: {
         ...parseModelRateLimitsFromHeaders(headers),
         ...readModelWeeklyLimits(parsed),

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

@@ -44,6 +44,87 @@ describe('NodeTmuxSessionRepository', () => {
     });
   });
 
+  describe('listLiveSessionsWithActivity', () => {
+    it('parses session names and activity epoch seconds and drops blank lines', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout:
+          'https_//github_com/owner/repo/issues/9 1700000000\nno_task_session 1699000000\n\n',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      const result = await repository.listLiveSessionsWithActivity();
+
+      expect(result).toEqual([
+        {
+          sessionName: 'https_//github_com/owner/repo/issues/9',
+          activityEpochSeconds: 1700000000,
+        },
+        {
+          sessionName: 'no_task_session',
+          activityEpochSeconds: 1699000000,
+        },
+      ]);
+      expect(runner.runCommand.mock.calls[0][0]).toBe('tmux');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'list-sessions',
+        '-F',
+        '#{session_name} #{session_activity}',
+      ]);
+    });
+
+    it('returns an empty list when tmux exits non-zero', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: 'no server running',
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      const result = await repository.listLiveSessionsWithActivity();
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('killSession', () => {
+    it('kills the tmux session by name', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.killSession('no_task_session');
+
+      expect(runner.runCommand.mock.calls[0][0]).toBe('tmux');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'kill-session',
+        '-t',
+        'no_task_session',
+      ]);
+    });
+
+    it('throws when tmux exits non-zero', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: "can't find session",
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await expect(repository.killSession('missing_session')).rejects.toThrow(
+        'Failed to kill tmux session "missing_session": exit code 1',
+      );
+    });
+  });
+
   describe('listInteractiveProcessCommandLines', () => {
     it('parses process command lines from ps output', async () => {
       const runner = createMockRunner();