github-issue-tower-defence-management 1.109.2 → 1.110.1

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

@@ -0,0 +1,217 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
+import { TranscriptSessionSubAgentActivityRepository } from './TranscriptSessionSubAgentActivityRepository';
+
+describe('TranscriptSessionSubAgentActivityRepository', () => {
+  let rootDirectory: string;
+  const now = new Date('2026-06-27T12:00:00.000Z');
+  const nowEpochSeconds = Math.floor(now.getTime() / 1000);
+
+  beforeEach(() => {
+    rootDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'subagent-tx-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDirectory, { force: true, recursive: true });
+  });
+
+  const subAgentsDirFor = (sessionName: string): string => {
+    const dir = path.join(
+      rootDirectory,
+      sessionName.replace(/\//g, '_'),
+      'subagents',
+    );
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+  };
+
+  const writeAgentTranscript = (
+    sessionName: string,
+    agentId: string,
+    entries: object[],
+    mtimeEpochSeconds: number,
+  ): string => {
+    const dir = subAgentsDirFor(sessionName);
+    const filePath = path.join(dir, `agent-${agentId}.jsonl`);
+    fs.writeFileSync(
+      filePath,
+      entries.map((entry) => JSON.stringify(entry)).join('\n'),
+      'utf8',
+    );
+    fs.utimesSync(filePath, mtimeEpochSeconds, mtimeEpochSeconds);
+    return filePath;
+  };
+
+  const createResolver = (): SubAgentTranscriptDirectoryResolver => ({
+    resolveSubAgentsDirectory: (sessionName) =>
+      path.join(rootDirectory, sessionName.replace(/\//g, '_'), 'subagents'),
+  });
+
+  const runningEntries = (startTimestamp: string): object[] => [
+    { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
+    {
+      type: 'assistant',
+      timestamp: startTimestamp,
+      message: { role: 'assistant', stop_reason: 'tool_use' },
+    },
+  ];
+
+  const finishedEntries = (startTimestamp: string): object[] => [
+    { type: 'user', timestamp: startTimestamp, message: { role: 'user' } },
+    {
+      type: 'assistant',
+      timestamp: startTimestamp,
+      message: { role: 'assistant', stop_reason: 'end_turn' },
+    },
+  ];
+
+  it('reports a running sub-agent with silent seconds from the file mtime and running seconds from the first entry', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    const startTimestamp = '2026-06-27T11:45:00.000Z';
+    writeAgentTranscript(
+      sessionName,
+      'aaa111',
+      runningEntries(startTimestamp),
+      nowEpochSeconds - 120,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName([
+      sessionName,
+    ]);
+
+    expect(result.get(sessionName)).toEqual([
+      { label: 'agent-aaa111', silentSeconds: 120, runningSeconds: 900 },
+    ]);
+  });
+
+  it('excludes a finished sub-agent whose last entry stop_reason is end_turn', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeAgentTranscript(
+      sessionName,
+      'done1',
+      finishedEntries('2026-06-27T11:00:00.000Z'),
+      nowEpochSeconds - 30,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName([
+      sessionName,
+    ]);
+
+    expect(result.size).toBe(0);
+  });
+
+  it('follows a symlinked transcript when computing silent seconds', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    const targetDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'subagent-target-'),
+    );
+    const targetPath = path.join(targetDir, 'real-agent.jsonl');
+    fs.writeFileSync(
+      targetPath,
+      runningEntries('2026-06-27T11:50:00.000Z')
+        .map((entry) => JSON.stringify(entry))
+        .join('\n'),
+      'utf8',
+    );
+    fs.utimesSync(targetPath, nowEpochSeconds - 60, nowEpochSeconds - 60);
+    const dir = subAgentsDirFor(sessionName);
+    fs.symlinkSync(targetPath, path.join(dir, 'agent-link1.jsonl'));
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName([
+      sessionName,
+    ]);
+
+    expect(result.get(sessionName)).toEqual([
+      { label: 'agent-link1', silentSeconds: 60, runningSeconds: 600 },
+    ]);
+    fs.rmSync(targetDir, { force: true, recursive: true });
+  });
+
+  it('returns an empty map when the resolver returns null', async () => {
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      { resolveSubAgentsDirectory: () => null },
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName([
+      'https_//github_com/owner/repo/issues/9',
+    ]);
+
+    expect(result.size).toBe(0);
+  });
+
+  it('ignores a session whose subagents directory does not exist', async () => {
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName([
+      'https_//github_com/owner/repo/issues/404',
+    ]);
+
+    expect(result.size).toBe(0);
+  });
+
+  it('groups multiple running sub-agents under the same session', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeAgentTranscript(
+      sessionName,
+      'one',
+      runningEntries('2026-06-27T11:55:00.000Z'),
+      nowEpochSeconds - 10,
+    );
+    writeAgentTranscript(
+      sessionName,
+      'two',
+      runningEntries('2026-06-27T11:55:00.000Z'),
+      nowEpochSeconds - 20,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName([
+      sessionName,
+    ]);
+
+    expect(result.get(sessionName)).toHaveLength(2);
+  });
+
+  it('clamps negative silent and running seconds to zero', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeAgentTranscript(
+      sessionName,
+      'future',
+      runningEntries('2026-06-27T13:00:00.000Z'),
+      nowEpochSeconds + 100,
+    );
+    const repository = new TranscriptSessionSubAgentActivityRepository(
+      createResolver(),
+      now,
+    );
+
+    const result = await repository.listSubAgentActivitiesBySessionName([
+      sessionName,
+    ]);
+
+    expect(result.get(sessionName)).toEqual([
+      { label: 'agent-future', silentSeconds: 0, runningSeconds: 0 },
+    ]);
+  });
+});

package/src/adapter/repositories/TranscriptSessionSubAgentActivityRepository.ts

@@ -0,0 +1,145 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { SubAgentActivity } from '../../domain/entities/LiveSessionActivitySnapshot';
+import { SessionSubAgentActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionSubAgentActivityRepository';
+import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const readString = (
+  value: Record<string, unknown>,
+  key: string,
+): string | null => {
+  const candidate = value[key];
+  return typeof candidate === 'string' ? candidate : null;
+};
+
+const parseEpochSeconds = (timestamp: string | null): number | null => {
+  if (timestamp === null) {
+    return null;
+  }
+  const parsed = Date.parse(timestamp);
+  return Number.isNaN(parsed) ? null : Math.floor(parsed / 1000);
+};
+
+type ParsedTranscript = {
+  firstEntryEpochSeconds: number | null;
+  lastStopReason: string | null;
+};
+
+const parseTranscript = (content: string): ParsedTranscript => {
+  let firstEntryEpochSeconds: number | null = null;
+  let lastStopReason: string | null = null;
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) {
+      continue;
+    }
+    const epochSeconds = parseEpochSeconds(readString(parsed, 'timestamp'));
+    if (firstEntryEpochSeconds === null && epochSeconds !== null) {
+      firstEntryEpochSeconds = epochSeconds;
+    }
+    const message = parsed.message;
+    if (isRecord(message)) {
+      const stopReason = readString(message, 'stop_reason');
+      if (stopReason !== null) {
+        lastStopReason = stopReason;
+      }
+    }
+  }
+  return { firstEntryEpochSeconds, lastStopReason };
+};
+
+const clampToZero = (value: number): number => (value > 0 ? value : 0);
+
+export class TranscriptSessionSubAgentActivityRepository implements SessionSubAgentActivityRepository {
+  constructor(
+    private readonly directoryResolver: SubAgentTranscriptDirectoryResolver,
+    private readonly now: Date,
+  ) {}
+
+  listSubAgentActivitiesBySessionName = async (
+    sessionNames: string[],
+  ): Promise<Map<string, SubAgentActivity[]>> => {
+    const result = new Map<string, SubAgentActivity[]>();
+    const nowEpochSeconds = Math.floor(this.now.getTime() / 1000);
+    for (const sessionName of sessionNames) {
+      const directory =
+        this.directoryResolver.resolveSubAgentsDirectory(sessionName);
+      if (directory === null) {
+        continue;
+      }
+      const activities = this.collectActivities(directory, nowEpochSeconds);
+      if (activities.length > 0) {
+        result.set(sessionName, activities);
+      }
+    }
+    return result;
+  };
+
+  private collectActivities = (
+    directory: string,
+    nowEpochSeconds: number,
+  ): SubAgentActivity[] => {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const activities: SubAgentActivity[] = [];
+    for (const entry of entries) {
+      const fileName = entry.name;
+      if (!fileName.startsWith('agent-') || !fileName.endsWith('.jsonl')) {
+        continue;
+      }
+      const filePath = path.join(directory, fileName);
+      const activity = this.toActivity(filePath, fileName, nowEpochSeconds);
+      if (activity !== null) {
+        activities.push(activity);
+      }
+    }
+    return activities;
+  };
+
+  private toActivity = (
+    filePath: string,
+    fileName: string,
+    nowEpochSeconds: number,
+  ): SubAgentActivity | null => {
+    let content: string;
+    let stats: fs.Stats;
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+      stats = fs.statSync(filePath);
+    } catch {
+      return null;
+    }
+    const transcript = parseTranscript(content);
+    if (transcript.lastStopReason === 'end_turn') {
+      return null;
+    }
+    const silentSeconds = clampToZero(
+      nowEpochSeconds - Math.floor(stats.mtimeMs / 1000),
+    );
+    const runningSeconds =
+      transcript.firstEntryEpochSeconds === null
+        ? 0
+        : clampToZero(nowEpochSeconds - transcript.firstEntryEpochSeconds);
+    return {
+      label: fileName.replace(/\.jsonl$/, ''),
+      silentSeconds,
+      runningSeconds,
+    };
+  };
+}

package/src/domain/entities/LiveSessionActivitySnapshot.ts

@@ -0,0 +1,12 @@
+export type SubAgentActivity = {
+  label: string;
+  silentSeconds: number;
+  runningSeconds: number;
+};
+
+export type LiveSessionActivitySnapshot = {
+  sessionName: string;
+  mainSilentSeconds: number | null;
+  subAgents: SubAgentActivity[];
+  hasUnansweredOwnerCall: boolean;
+};

package/src/domain/entities/LiveSessionOutputActivity.ts

@@ -0,0 +1,4 @@
+export type LiveSessionOutputActivity = {
+  sessionName: string;
+  lastOutputEpochSeconds: number;
+};

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

@@ -0,0 +1,52 @@
+import { DefaultSilentSessionMessageComposer } from './DefaultSilentSessionMessageComposer';
+
+describe('DefaultSilentSessionMessageComposer', () => {
+  const composer = new DefaultSilentSessionMessageComposer();
+
+  it('renders the configured main-stalled message with the silent minutes substituted', () => {
+    const section = composer.composeMainStalledSection(600);
+    expect(section).toContain('You have produced no output for 10 minutes.');
+    expect(section).toContain('Idle waiting wastes this live session');
+    expect(section).toContain(
+      'Always work proactively and stay ahead of the work',
+    );
+    expect(section).toContain('never wait passively');
+    expect(section).toContain('Self-check now:');
+    expect(section).toContain('1.');
+    expect(section).toContain('2.');
+    expect(section).toContain('3.');
+    expect(section).toContain('4.');
+    expect(section).toContain(
+      'report an estimate of how many minutes you expect to need',
+    );
+  });
+
+  it('floors the silent seconds to whole minutes', () => {
+    const section = composer.composeMainStalledSection(659);
+    expect(section).toContain('You have produced no output for 10 minutes.');
+  });
+
+  it('lists each sub-agent with its silent and running minutes', () => {
+    const section = composer.composeSubAgentSection([
+      { label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 },
+      { label: 'sub-process-2', silentSeconds: 0, runningSeconds: 960 },
+    ]);
+    expect(section).toContain('sub-process-1');
+    expect(section).toContain('silent for 6m');
+    expect(section).toContain('running for 20m');
+    expect(section).toContain('sub-process-2');
+    expect(section).toContain('running for 16m');
+  });
+
+  it('does not contain any host-specific or internal identifiers', () => {
+    const mainSection = composer.composeMainStalledSection(600);
+    const subSection = composer.composeSubAgentSection([
+      { label: 'sub-process-1', silentSeconds: 360, runningSeconds: 1200 },
+    ]);
+    const combined = `${mainSection}\n${subSection}`.toLowerCase();
+    expect(combined).not.toContain('claude');
+    expect(combined).not.toContain('take ownership');
+    expect(combined).not.toContain('/home/');
+    expect(combined).not.toContain('.jsonl');
+  });
+});

package/src/domain/usecases/DefaultSilentSessionMessageComposer.ts

@@ -0,0 +1,39 @@
+import { SubAgentActivity } from '../entities/LiveSessionActivitySnapshot';
+import { SilentSessionMessageComposer } from './adapter-interfaces/SilentSessionMessageComposer';
+
+const formatMinutes = (seconds: number): string => {
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m`;
+};
+
+const composeMainStalledMessage = (mainSilentSeconds: number): string => {
+  const minutes = Math.floor(mainSilentSeconds / 60);
+  return [
+    `You have produced no output for ${minutes} minutes. Idle waiting wastes this live session and is unacceptable. Always work proactively and stay ahead of the work: anticipate the next steps and, at every point, choose the fastest path so the whole task finishes as early as possible; never wait passively. Finish every task in the shortest possible time — but "fastest" means correct and incident-free, not merely quick: a fast but wrong result is worthless and causes incidents, so be fast without breaking things. Use parallel execution and your whole team of sub-agents to minimize total wall-clock time. Your goal is to drive every task to completion and have the owner confirm that all tasks are done. Do NOT close this session on your own — it is closed only after the owner has verified completion and tells you to close it. Self-check now:`,
+    `1. Every request from the owner is registered as a session task and your task list is kept current (mark tasks completed when done); verify nothing is missing or stale.`,
+    `2. Your plan is the fastest correct path: parallelize independent work across sub-agents, delegate, and remove needless serialization. Choose the fastest safe method, not the easiest.`,
+    `3. A monitor is in place that detects when any sub-agent produces no output for 5 minutes.`,
+    `4. If you are blocked on an owner decision — or once you believe all tasks are complete — do not wait passively: the owner is not notified of passive waiting and will not reply unless you raise a new call-to-user, so raise one now (to get the decision, or to ask the owner to verify completion). If no owner input is needed yet, resume immediately and drive all remaining tasks to completion.`,
+    `Also, in your next output, report an estimate of how many minutes you expect to need to finish all remaining tasks.`,
+  ].join('\n');
+};
+
+export class DefaultSilentSessionMessageComposer implements SilentSessionMessageComposer {
+  composeMainStalledSection = (mainSilentSeconds: number): string => {
+    return composeMainStalledMessage(mainSilentSeconds);
+  };
+
+  composeSubAgentSection = (subAgents: SubAgentActivity[]): string => {
+    const lines = subAgents.map(
+      (subAgent) =>
+        `- ${subAgent.label}: silent for ${formatMinutes(
+          subAgent.silentSeconds,
+        )}, running for ${formatMinutes(subAgent.runningSeconds)}`,
+    );
+    return [
+      'The following sub-processes have been silent or running for a long time:',
+      ...lines,
+      'If a sub-process is stalled, take action (restart, hand off, or replace it). If it is legitimately waiting on an external dependency (continuous integration, an external API, or another process), let it continue.',
+    ].join('\n');
+  };
+}

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

@@ -11,6 +11,8 @@ const candidate = (name: string): OauthTokenCandidate => ({
   name,
   token: `fake-token-${name}`,
   snapshot: null,
+  subscriptionDisabled: false,
+  unifiedRejected: false,
 });
 
 const session = (

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

@@ -22,10 +22,14 @@ const snapshot = (
 const candidate = (
   name: string,
   snapshotValue: OauthTokenWindowSnapshot | null,
+  subscriptionDisabled = false,
+  unifiedRejected = false,
 ): OauthTokenCandidate => ({
   name,
   token: `fake-token-${name}`,
   snapshot: snapshotValue,
+  subscriptionDisabled,
+  unifiedRejected,
 });
 
 const session = (name: string, sessionId: string): ClaudeLiveSession => ({
@@ -144,4 +148,40 @@ describe('LiveSessionOauthTokenSelectUseCase', () => {
     const lonely = result.metrics.find((m) => m.name === 'lonely');
     expect(lonely?.liveSessionCount).toBe(0);
   });
+
+  it('excludes a subscription-disabled token even when it has zero live sessions', () => {
+    const result = useCase.run(
+      [
+        candidate('disabled', snapshot({}), true),
+        candidate('active', snapshot({}), false),
+      ],
+      [session('active', 'session-a')],
+      NOW,
+    );
+
+    expect(result.selected?.name).toBe('active');
+    const disabled = result.metrics.find((m) => m.name === 'disabled');
+    expect(disabled?.eligible).toBe(false);
+    expect(disabled?.liveSessionCount).toBe(0);
+    expect(disabled?.exclusionReason).toContain(
+      'organization has disabled Claude subscription access for Claude Code',
+    );
+  });
+
+  it('excludes a unified-rejected token even when it has zero live sessions', () => {
+    const result = useCase.run(
+      [
+        candidate('rejected', snapshot({}), false, true),
+        candidate('active', snapshot({}), false, false),
+      ],
+      [session('active', 'session-a')],
+      NOW,
+    );
+
+    expect(result.selected?.name).toBe('active');
+    const rejected = result.metrics.find((m) => m.name === 'rejected');
+    expect(rejected?.eligible).toBe(false);
+    expect(rejected?.liveSessionCount).toBe(0);
+    expect(rejected?.exclusionReason).toContain('rejected');
+  });
 });