github-issue-tower-defence-management 1.110.0 → 1.111.0

package/src/adapter/proxy/RateLimitCache.ts

@@ -80,6 +80,16 @@ const readModelWeeklyLimits = (
   return result;
 };
 
+const readSubscriptionDisabledEpoch = (
+  payload: Record<string, unknown>,
+): { subscriptionDisabledEpoch: number } | Record<string, never> => {
+  const stored = payload.subscriptionDisabledEpoch;
+  if (typeof stored === 'number') {
+    return { subscriptionDisabledEpoch: stored };
+  }
+  return {};
+};
+
 const cooldownEndFromRetryAfter = (
   retryAfterSeconds: number | null,
   nowEpochSeconds: number,
@@ -141,6 +151,7 @@ export const writeRateLimit = (
   }
   const existing = readPayload(filePath);
   const payload = {
+    ...readSubscriptionDisabledEpoch(existing),
     ts: Date.now() / 1000,
     headers: rateLimitHeaders,
     modelWeeklyLimits: readModelWeeklyLimits(existing),

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

@@ -0,0 +1,147 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemInteractiveLiveSessionTranscriptResolver } from './FileSystemInteractiveLiveSessionTranscriptResolver';
+
+describe('FileSystemInteractiveLiveSessionTranscriptResolver', () => {
+  let configRoot: string;
+
+  beforeEach(() => {
+    configRoot = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'interactive-transcript-'),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(configRoot, { force: true, recursive: true });
+  });
+
+  const writeTranscript = (params: {
+    configDir: string;
+    cwdSlug: string;
+    sessionId: string;
+    mtimeEpochSeconds?: number;
+  }): string => {
+    const projectDirectory = path.join(
+      params.configDir,
+      'projects',
+      params.cwdSlug,
+    );
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    const filePath = path.join(projectDirectory, `${params.sessionId}.jsonl`);
+    fs.writeFileSync(filePath, '{"type":"custom-title"}', 'utf8');
+    if (params.mtimeEpochSeconds !== undefined) {
+      fs.utimesSync(
+        filePath,
+        params.mtimeEpochSeconds,
+        params.mtimeEpochSeconds,
+      );
+    }
+    return filePath;
+  };
+
+  it('resolves a transcript by config dir and session id for a plain-named session', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    const filePath = writeTranscript({
+      configDir,
+      cwdSlug: '-home-user',
+      sessionId: 'wb-uuid',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+    ]);
+
+    expect(result.get('workbench')).toBe(filePath);
+  });
+
+  it('chooses the most recently modified match across project directories', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    writeTranscript({
+      configDir,
+      cwdSlug: '-home-user-old',
+      sessionId: 'wb-uuid',
+      mtimeEpochSeconds: 1700000000,
+    });
+    const newerPath = writeTranscript({
+      configDir,
+      cwdSlug: '-home-user-new',
+      sessionId: 'wb-uuid',
+      mtimeEpochSeconds: 1700000500,
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+    ]);
+
+    expect(result.get('workbench')).toBe(newerPath);
+  });
+
+  it('resolves several sessions in one call', () => {
+    const workbenchConfig = path.join(configRoot, 'workbench');
+    const controlRoomConfig = path.join(configRoot, 'control-room');
+    const workbenchPath = writeTranscript({
+      configDir: workbenchConfig,
+      cwdSlug: '-home-user',
+      sessionId: 'wb-uuid',
+    });
+    const controlRoomPath = writeTranscript({
+      configDir: controlRoomConfig,
+      cwdSlug: '-home-user',
+      sessionId: 'cr-uuid',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      {
+        sessionName: 'workbench',
+        sessionId: 'wb-uuid',
+        configDir: workbenchConfig,
+      },
+      {
+        sessionName: 'control-room',
+        sessionId: 'cr-uuid',
+        configDir: controlRoomConfig,
+      },
+    ]);
+
+    expect(result.get('workbench')).toBe(workbenchPath);
+    expect(result.get('control-room')).toBe(controlRoomPath);
+  });
+
+  it('omits a session whose transcript file is absent', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    fs.mkdirSync(path.join(configDir, 'projects', '-home-user'), {
+      recursive: true,
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      { sessionName: 'workbench', sessionId: 'missing-uuid', configDir },
+    ]);
+
+    expect(result.has('workbench')).toBe(false);
+  });
+
+  it('omits a session whose config dir has no projects directory', () => {
+    const configDir = path.join(configRoot, 'workbench');
+    fs.mkdirSync(configDir, { recursive: true });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([
+      { sessionName: 'workbench', sessionId: 'wb-uuid', configDir },
+    ]);
+
+    expect(result.has('workbench')).toBe(false);
+  });
+
+  it('returns an empty map for an empty session list', () => {
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver();
+
+    const result = resolver.resolveTranscriptPaths([]);
+
+    expect(result.size).toBe(0);
+  });
+});

package/src/adapter/repositories/FileSystemInteractiveLiveSessionTranscriptResolver.ts

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { InteractiveLiveSession } from '../../domain/entities/InteractiveLiveSession';
+import { InteractiveLiveSessionTranscriptResolver } from '../../domain/usecases/adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
+
+const modifiedEpochMs = (filePath: string): number | null => {
+  try {
+    const stats = fs.statSync(filePath);
+    return stats.isFile() ? stats.mtimeMs : null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Resolves the real transcript path of an interactive Claude Code session from
+ * the session id and config directory taken from the session's process
+ * environment. The transcript lives at
+ * `<configDir>/projects/<cwd-slug>/<sessionId>.jsonl`; this resolver scans the
+ * `projects` subdirectories for a file named `<sessionId>.jsonl` and returns the
+ * most recently modified match. Because resolution is keyed on the process
+ * session id rather than on a session name or issue URL, a plain-named session
+ * (for example one named `workbench`) resolves just as well as an issue-url
+ * named one.
+ */
+export class FileSystemInteractiveLiveSessionTranscriptResolver implements InteractiveLiveSessionTranscriptResolver {
+  resolveTranscriptPaths = (
+    sessions: InteractiveLiveSession[],
+  ): Map<string, string> => {
+    const resolved = new Map<string, string>();
+    for (const session of sessions) {
+      const transcriptPath = this.resolveTranscriptPath(session);
+      if (transcriptPath !== null) {
+        resolved.set(session.sessionName, transcriptPath);
+      }
+    }
+    return resolved;
+  };
+
+  private resolveTranscriptPath = (
+    session: InteractiveLiveSession,
+  ): string | null => {
+    const projectsDirectory = path.join(session.configDir, 'projects');
+    let projectEntries: fs.Dirent[];
+    try {
+      projectEntries = fs.readdirSync(projectsDirectory, {
+        withFileTypes: true,
+      });
+    } catch {
+      return null;
+    }
+    const fileName = `${session.sessionId}.jsonl`;
+    let latestPath: string | null = null;
+    let latestEpochMs = -Infinity;
+    for (const projectEntry of projectEntries) {
+      if (!projectEntry.isDirectory()) {
+        continue;
+      }
+      const candidate = path.join(
+        projectsDirectory,
+        projectEntry.name,
+        fileName,
+      );
+      const epochMs = modifiedEpochMs(candidate);
+      if (epochMs === null) {
+        continue;
+      }
+      if (epochMs > latestEpochMs) {
+        latestEpochMs = epochMs;
+        latestPath = candidate;
+      }
+    }
+    return latestPath;
+  };
+}

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

@@ -16,76 +16,114 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     fs.rmSync(rootDirectory, { force: true, recursive: true });
   });
 
-  const writeOutputFileWithMtime = (
-    sessionName: string,
-    epochSeconds: number,
-  ): void => {
-    const fileName = sessionName.replace(/\//g, '_');
+  const assistantEntry = (timestamp: string): object => ({
+    type: 'assistant',
+    timestamp,
+    message: {
+      role: 'assistant',
+      content: [{ type: 'text', text: 'progress update' }],
+    },
+  });
+
+  const userEntry = (timestamp: string): object => ({
+    type: 'user',
+    timestamp,
+    message: { role: 'user', content: 'go ahead' },
+  });
+
+  const writeTranscript = (fileName: string, lines: object[]): string => {
     const filePath = path.join(rootDirectory, fileName);
-    fs.writeFileSync(filePath, 'output', 'utf8');
-    fs.utimesSync(filePath, epochSeconds, epochSeconds);
+    fs.writeFileSync(
+      filePath,
+      lines.map((line) => JSON.stringify(line)).join('\n'),
+      'utf8',
+    );
+    return filePath;
   };
 
-  it('returns the latest output epoch derived from each session output file mtime', async () => {
-    const sessionName = 'https_//github_com/owner/repo/issues/9';
-    writeOutputFileWithMtime(sessionName, 1700000000);
-    const repository = new FileSystemSessionOutputActivityRepository(
-      rootDirectory,
-    );
+  it('returns the latest assistant entry timestamp as the last output epoch', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+      userEntry('2026-06-27T10:30:00.000Z'),
+      assistantEntry('2026-06-27T10:05:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
 
-    const result = await repository.listSessionOutputActivities([sessionName]);
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
 
     expect(result).toEqual([
-      { sessionName, lastOutputEpochSeconds: 1700000000 },
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:05:00.000Z') / 1000,
+        ),
+      },
     ]);
   });
 
-  it('omits sessions that have no output file', async () => {
-    const presentSessionName = 'https_//github_com/owner/repo/issues/9';
-    const missingSessionName = 'https_//github_com/owner/repo/issues/10';
-    writeOutputFileWithMtime(presentSessionName, 1700000000);
-    const repository = new FileSystemSessionOutputActivityRepository(
-      rootDirectory,
-    );
-
-    const result = await repository.listSessionOutputActivities([
-      presentSessionName,
-      missingSessionName,
+  it('ignores user entries when computing the last output epoch', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+      userEntry('2026-06-27T11:00:00.000Z'),
     ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
 
     expect(result).toEqual([
-      { sessionName: presentSessionName, lastOutputEpochSeconds: 1700000000 },
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+        ),
+      },
     ]);
   });
 
-  it('returns an empty list when the root directory does not exist', async () => {
-    const repository = new FileSystemSessionOutputActivityRepository(
-      path.join(rootDirectory, 'does-not-exist'),
+  it('omits sessions whose transcript file is missing', async () => {
+    const presentPath = writeTranscript('present.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([
+        ['present', presentPath],
+        ['missing', path.join(rootDirectory, 'missing.jsonl')],
+      ]),
     );
 
-    const result = await repository.listSessionOutputActivities([
-      'https_//github_com/owner/repo/issues/9',
+    expect(result).toEqual([
+      {
+        sessionName: 'present',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+        ),
+      },
     ]);
-
-    expect(result).toEqual([]);
   });
 
-  it('returns an empty list when the root directory is null', async () => {
-    const repository = new FileSystemSessionOutputActivityRepository(null);
-
-    const result = await repository.listSessionOutputActivities([
-      'https_//github_com/owner/repo/issues/9',
+  it('omits sessions whose transcript has no assistant entry', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      userEntry('2026-06-27T10:00:00.000Z'),
     ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
 
     expect(result).toEqual([]);
   });
 
-  it('returns an empty list when no session names are requested', async () => {
-    const repository = new FileSystemSessionOutputActivityRepository(
-      rootDirectory,
-    );
+  it('returns an empty list when no sessions are requested', async () => {
+    const repository = new FileSystemSessionOutputActivityRepository();
 
-    const result = await repository.listSessionOutputActivities([]);
+    const result = await repository.listSessionOutputActivities(new Map());
 
     expect(result).toEqual([]);
   });

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts

@@ -1,21 +1,41 @@
 import * as fs from 'fs';
-import * as path from 'path';
 import { LiveSessionOutputActivity } from '../../domain/entities/LiveSessionOutputActivity';
 import { SessionOutputActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionOutputActivityRepository';
 
-export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
-  constructor(private readonly rootDirectory: string | null) {}
+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 parseEpochMilliseconds = (timestamp: string | null): number | null => {
+  if (timestamp === null) {
+    return null;
+  }
+  const parsed = Date.parse(timestamp);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+
+/**
+ * Reads the last main-session output time for each live session from its
+ * already-resolved transcript path. Idle time is computed from the timestamp of
+ * the latest `assistant` entry rather than from the transcript file modification
+ * time, so a transcript touched only by tool results or owner replies still
+ * counts as silent.
+ */
+export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
   listSessionOutputActivities = async (
-    sessionNames: string[],
+    transcriptPathBySessionName: Map<string, string>,
   ): Promise<LiveSessionOutputActivity[]> => {
-    if (this.rootDirectory === null) {
-      return [];
-    }
     const activities: LiveSessionOutputActivity[] = [];
-    for (const sessionName of sessionNames) {
+    for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
       const lastOutputEpochSeconds =
-        this.readLastOutputEpochSeconds(sessionName);
+        this.readLastAssistantOutputEpochSeconds(transcriptPath);
       if (lastOutputEpochSeconds !== null) {
         activities.push({ sessionName, lastOutputEpochSeconds });
       }
@@ -23,26 +43,44 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
     return activities;
   };
 
-  private readLastOutputEpochSeconds = (sessionName: string): number | null => {
-    if (this.rootDirectory === null) {
-      return null;
-    }
-    const filePath = path.join(
-      this.rootDirectory,
-      this.toOutputFileName(sessionName),
-    );
-    let stats: fs.Stats;
+  private readLastAssistantOutputEpochSeconds = (
+    transcriptPath: string,
+  ): number | null => {
+    let content: string;
     try {
-      stats = fs.statSync(filePath);
+      content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
       return null;
     }
-    if (!stats.isFile()) {
+    let lastAssistantEpochMs: number | 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;
+      }
+      if (readString(parsed, 'type') !== 'assistant') {
+        continue;
+      }
+      const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
+      if (epochMs === null) {
+        continue;
+      }
+      if (lastAssistantEpochMs === null || epochMs > lastAssistantEpochMs) {
+        lastAssistantEpochMs = epochMs;
+      }
+    }
+    if (lastAssistantEpochMs === null) {
       return null;
     }
-    return Math.floor(stats.mtimeMs / 1000);
+    return Math.floor(lastAssistantEpochMs / 1000);
   };
-
-  private toOutputFileName = (sessionName: string): string =>
-    sessionName.replace(/\//g, '_');
 }

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

@@ -0,0 +1,138 @@
+import { LocalProcessLiveSessionProcessSnapshotProvider } from './LocalProcessLiveSessionProcessSnapshotProvider';
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+
+describe('LocalProcessLiveSessionProcessSnapshotProvider', () => {
+  const makeRunner = (
+    handlers: Record<
+      string,
+      { stdout: string; stderr?: string; exitCode?: number }
+    >,
+  ): LocalCommandRunner => ({
+    runCommand: jest.fn(async (program: string, args: string[]) => {
+      const key = `${program} ${args.join(' ')}`;
+      const handler = handlers[key];
+      if (handler === undefined) {
+        return { stdout: '', stderr: '', exitCode: 1 };
+      }
+      return {
+        stdout: handler.stdout,
+        stderr: handler.stderr ?? '',
+        exitCode: handler.exitCode ?? 0,
+      };
+    }),
+  });
+
+  const makeEnvironReader = (
+    byPid: Record<number, Record<string, string>>,
+  ): ProcessEnvironReader => ({
+    readEnviron: (pid: number) => byPid[pid] ?? null,
+  });
+
+  it('builds a snapshot of sessions, pane pids, and processes with environment', async () => {
+    const runner = makeRunner({
+      'tmux list-sessions -F #{session_name}': {
+        stdout: 'workbench\nhttps_//github_com/owner/repo/issues/9\n',
+      },
+      'tmux list-panes -t workbench -F #{pane_pid}': { stdout: '200\n' },
+      'tmux list-panes -t https_//github_com/owner/repo/issues/9 -F #{pane_pid}':
+        { stdout: '100\n' },
+      'ps -eo pid=,ppid=,args=': {
+        stdout: [
+          '    100       1 shell',
+          '    101     100 claude --name issues-9',
+          '    200       1 shell',
+          '    201     200 claude --name workbench',
+        ].join('\n'),
+      },
+    });
+    const environReader = makeEnvironReader({
+      101: {
+        CLAUDE_CODE_SESSION_ID: 'issue-uuid',
+        CLAUDE_CONFIG_DIR: '/config/issues-9',
+      },
+      201: {
+        CLAUDE_CODE_SESSION_ID: 'wb-uuid',
+        CLAUDE_CONFIG_DIR: '/config/workbench',
+      },
+    });
+    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
+      runner,
+      environReader,
+    );
+
+    const snapshot = await provider.getSnapshot();
+
+    expect(snapshot.sessions).toEqual([
+      { sessionName: 'workbench', panePids: [200] },
+      {
+        sessionName: 'https_//github_com/owner/repo/issues/9',
+        panePids: [100],
+      },
+    ]);
+    expect(snapshot.processes).toContainEqual({
+      pid: 201,
+      ppid: 200,
+      commandLine: 'claude --name workbench',
+      sessionId: 'wb-uuid',
+      configDir: '/config/workbench',
+    });
+    expect(snapshot.processes).toContainEqual({
+      pid: 100,
+      ppid: 1,
+      commandLine: 'shell',
+      sessionId: null,
+      configDir: null,
+    });
+  });
+
+  it('returns an empty snapshot when tmux reports no sessions', async () => {
+    const runner = makeRunner({
+      'tmux list-sessions -F #{session_name}': { stdout: '' },
+      'ps -eo pid=,ppid=,args=': { stdout: '' },
+    });
+    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
+      runner,
+      makeEnvironReader({}),
+    );
+
+    const snapshot = await provider.getSnapshot();
+
+    expect(snapshot.sessions).toEqual([]);
+    expect(snapshot.processes).toEqual([]);
+  });
+
+  it('skips malformed ps lines', async () => {
+    const runner = makeRunner({
+      'tmux list-sessions -F #{session_name}': { stdout: 'workbench\n' },
+      'tmux list-panes -t workbench -F #{pane_pid}': { stdout: '200\n' },
+      'ps -eo pid=,ppid=,args=': {
+        stdout: [
+          'garbage line',
+          '    201     200 claude --name workbench',
+        ].join('\n'),
+      },
+    });
+    const provider = new LocalProcessLiveSessionProcessSnapshotProvider(
+      runner,
+      makeEnvironReader({
+        201: {
+          CLAUDE_CODE_SESSION_ID: 'wb-uuid',
+          CLAUDE_CONFIG_DIR: '/config/workbench',
+        },
+      }),
+    );
+
+    const snapshot = await provider.getSnapshot();
+
+    expect(snapshot.processes).toEqual([
+      {
+        pid: 201,
+        ppid: 200,
+        commandLine: 'claude --name workbench',
+        sessionId: 'wb-uuid',
+        configDir: '/config/workbench',
+      },
+    ]);
+  });
+});