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

package/src/domain/usecases/NotifySilentLiveSessionsUseCase.ts

@@ -1,18 +1,15 @@
-import { Issue } from '../entities/Issue';
 import { LiveSessionActivitySnapshot } from '../entities/LiveSessionActivitySnapshot';
-import { Project } from '../entities/Project';
-import { IN_TMUX_STATUS_NAME } from '../entities/WorkflowStatus';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { InteractiveLiveSession } from '../entities/InteractiveLiveSession';
+import { LiveSessionProcessSnapshotProvider } from './adapter-interfaces/LiveSessionProcessSnapshotProvider';
+import { InteractiveLiveSessionTranscriptResolver } from './adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
 import { OwnerCallStatusProvider } from './adapter-interfaces/OwnerCallStatusProvider';
 import { SessionOutputActivityRepository } from './adapter-interfaces/SessionOutputActivityRepository';
 import { SessionSubAgentActivityRepository } from './adapter-interfaces/SessionSubAgentActivityRepository';
 import { SilentSessionMessageComposer } from './adapter-interfaces/SilentSessionMessageComposer';
 import { SilentSessionNotificationRepository } from './adapter-interfaces/SilentSessionNotificationRepository';
 import { Sleeper } from './adapter-interfaces/Sleeper';
-import { TmuxSessionRepository } from './adapter-interfaces/TmuxSessionRepository';
-import { toTmuxSessionName } from './intmux/InTmuxByHumanSessionReconcileUseCase';
+import { ResolveInteractiveLiveSessionsUseCase } from './ResolveInteractiveLiveSessionsUseCase';
 
-export const DEFAULT_MONITORED_STATUS = IN_TMUX_STATUS_NAME;
 export const DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS = 10 * 60;
 export const DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS = 5 * 60;
 export const DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS = 15 * 60;
@@ -25,12 +22,12 @@ type NotifyCandidate = {
 };
 
 export class NotifySilentLiveSessionsUseCase {
+  private readonly resolveInteractiveLiveSessions =
+    new ResolveInteractiveLiveSessionsUseCase();
+
   constructor(
-    private readonly issueRepository: Pick<IssueRepository, 'getAllOpened'>,
-    private readonly tmuxSessionRepository: Pick<
-      TmuxSessionRepository,
-      'listLiveSessionNames'
-    >,
+    private readonly liveSessionProcessSnapshotProvider: LiveSessionProcessSnapshotProvider,
+    private readonly interactiveLiveSessionTranscriptResolver: InteractiveLiveSessionTranscriptResolver,
     private readonly sessionOutputActivityRepository: SessionOutputActivityRepository,
     private readonly subAgentActivityRepository: SessionSubAgentActivityRepository,
     private readonly ownerCallStatusProvider: OwnerCallStatusProvider,
@@ -40,9 +37,6 @@ export class NotifySilentLiveSessionsUseCase {
   ) {}
 
   run = async (params: {
-    project: Project;
-    allowCacheMinutes: number;
-    monitoredStatus: string;
     mainSilentThresholdSeconds: number;
     subAgentSilentThresholdSeconds: number;
     subAgentRunningThresholdSeconds: number;
@@ -50,29 +44,26 @@ export class NotifySilentLiveSessionsUseCase {
     staggerSeconds: number;
     now: Date;
   }): Promise<void> => {
-    const liveSessionNames = new Set(
-      await this.tmuxSessionRepository.listLiveSessionNames(),
-    );
-    const openIssues = await this.issueRepository.getAllOpened(
-      params.project,
-      params.allowCacheMinutes,
-    );
-    const monitoredSessionNames = this.selectMonitoredSessionNames(
-      openIssues,
-      liveSessionNames,
-      params.monitoredStatus,
-    );
+    const snapshot =
+      await this.liveSessionProcessSnapshotProvider.getSnapshot();
+    const interactiveSessions =
+      this.resolveInteractiveLiveSessions.resolve(snapshot);
+    const transcriptPathBySessionName =
+      this.interactiveLiveSessionTranscriptResolver.resolveTranscriptPaths(
+        interactiveSessions,
+      );
 
     const snapshots = await this.collectSnapshots(
-      monitoredSessionNames,
+      interactiveSessions,
+      transcriptPathBySessionName,
       params.now,
     );
 
     const candidates: NotifyCandidate[] = [];
-    for (const snapshot of snapshots) {
-      const message = this.composeMessage(snapshot, params);
+    for (const sessionSnapshot of snapshots) {
+      const message = this.composeMessage(sessionSnapshot, params);
       if (message !== null) {
-        candidates.push({ sessionName: snapshot.sessionName, message });
+        candidates.push({ sessionName: sessionSnapshot.sessionName, message });
       }
     }
     candidates.sort((left, right) =>
@@ -84,7 +75,7 @@ export class NotifySilentLiveSessionsUseCase {
     );
 
     console.log(
-      `Silent live session notification: ${candidates.length} candidate(s) of ${monitoredSessionNames.length} monitored session(s).`,
+      `Silent live session notification: ${candidates.length} candidate(s) of ${interactiveSessions.length} interactive session(s).`,
     );
 
     const nowEpochSeconds = Math.floor(params.now.getTime() / 1000);
@@ -122,12 +113,17 @@ export class NotifySilentLiveSessionsUseCase {
   };
 
   private collectSnapshots = async (
-    monitoredSessionNames: string[],
+    interactiveSessions: InteractiveLiveSession[],
+    transcriptPathBySessionName: Map<string, string>,
     now: Date,
   ): Promise<LiveSessionActivitySnapshot[]> => {
+    const sessionNames = interactiveSessions.map(
+      (session) => session.sessionName,
+    );
+
     const activities =
       await this.sessionOutputActivityRepository.listSessionOutputActivities(
-        monitoredSessionNames,
+        transcriptPathBySessionName,
       );
     const lastOutputBySessionName = new Map<string, number>();
     for (const activity of activities) {
@@ -139,16 +135,16 @@ export class NotifySilentLiveSessionsUseCase {
 
     const subAgentsBySessionName =
       await this.subAgentActivityRepository.listSubAgentActivitiesBySessionName(
-        monitoredSessionNames,
+        sessionNames,
       );
 
     const sessionNamesWithUnansweredOwnerCall =
       await this.ownerCallStatusProvider.listSessionNamesWithUnansweredOwnerCall(
-        monitoredSessionNames,
+        transcriptPathBySessionName,
       );
 
     const nowEpochSeconds = Math.floor(now.getTime() / 1000);
-    return monitoredSessionNames.map((sessionName) => {
+    return sessionNames.map((sessionName) => {
       const lastOutputEpochSeconds = lastOutputBySessionName.get(sessionName);
       const mainSilentSeconds =
         lastOutputEpochSeconds === undefined
@@ -202,22 +198,4 @@ export class NotifySilentLiveSessionsUseCase {
     }
     return sections.join('\n\n');
   };
-
-  private selectMonitoredSessionNames = (
-    openIssues: Issue[],
-    liveSessionNames: Set<string>,
-    monitoredStatus: string,
-  ): string[] => {
-    const monitoredSessionNames: string[] = [];
-    for (const issue of openIssues) {
-      if (issue.status !== monitoredStatus) {
-        continue;
-      }
-      const sessionName = toTmuxSessionName(issue.url);
-      if (liveSessionNames.has(sessionName)) {
-        monitoredSessionNames.push(sessionName);
-      }
-    }
-    return monitoredSessionNames;
-  };
 }

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

@@ -0,0 +1,220 @@
+import { ResolveInteractiveLiveSessionsUseCase } from './ResolveInteractiveLiveSessionsUseCase';
+import { LiveSessionProcessSnapshot } from '../entities/LiveSessionProcessSnapshot';
+
+describe('ResolveInteractiveLiveSessionsUseCase', () => {
+  const useCase = new ResolveInteractiveLiveSessionsUseCase();
+
+  it('resolves an issue-url-named session through its pane child process', () => {
+    const snapshot: LiveSessionProcessSnapshot = {
+      sessions: [
+        {
+          sessionName: 'https_//github_com/owner/repo/issues/9',
+          panePids: [100],
+        },
+      ],
+      processes: [
+        {
+          pid: 100,
+          ppid: 1,
+          commandLine: 'tmux pane shell',
+          sessionId: null,
+          configDir: null,
+        },
+        {
+          pid: 101,
+          ppid: 100,
+          commandLine: 'claude --model opus --resume abc',
+          sessionId: 'abc',
+          configDir: '/config/issues-9',
+        },
+      ],
+    };
+
+    const result = useCase.resolve(snapshot);
+
+    expect(result).toEqual([
+      {
+        sessionName: 'https_//github_com/owner/repo/issues/9',
+        sessionId: 'abc',
+        configDir: '/config/issues-9',
+      },
+    ]);
+  });
+
+  it('resolves a plain-named session such as workbench', () => {
+    const snapshot: LiveSessionProcessSnapshot = {
+      sessions: [{ sessionName: 'workbench', panePids: [200] }],
+      processes: [
+        {
+          pid: 200,
+          ppid: 1,
+          commandLine: 'shell',
+          sessionId: null,
+          configDir: null,
+        },
+        {
+          pid: 201,
+          ppid: 200,
+          commandLine: 'claude --model opus --name workbench',
+          sessionId: 'wb-uuid',
+          configDir: '/config/workbench',
+        },
+      ],
+    };
+
+    const result = useCase.resolve(snapshot);
+
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        sessionId: 'wb-uuid',
+        configDir: '/config/workbench',
+      },
+    ]);
+  });
+
+  it('finds the interactive process several levels below the pane', () => {
+    const snapshot: LiveSessionProcessSnapshot = {
+      sessions: [{ sessionName: 'control-room', panePids: [300] }],
+      processes: [
+        {
+          pid: 300,
+          ppid: 1,
+          commandLine: 'shell',
+          sessionId: null,
+          configDir: null,
+        },
+        {
+          pid: 301,
+          ppid: 300,
+          commandLine: 'node wrapper',
+          sessionId: null,
+          configDir: null,
+        },
+        {
+          pid: 302,
+          ppid: 301,
+          commandLine: 'claude --name control-room',
+          sessionId: 'cr-uuid',
+          configDir: '/config/control-room',
+        },
+      ],
+    };
+
+    const result = useCase.resolve(snapshot);
+
+    expect(result).toEqual([
+      {
+        sessionName: 'control-room',
+        sessionId: 'cr-uuid',
+        configDir: '/config/control-room',
+      },
+    ]);
+  });
+
+  it('excludes a session whose only claude process is an owner-handover spawn', () => {
+    const snapshot: LiveSessionProcessSnapshot = {
+      sessions: [{ sessionName: 'aw-host', panePids: [400] }],
+      processes: [
+        {
+          pid: 400,
+          ppid: 1,
+          commandLine: 'shell',
+          sessionId: null,
+          configDir: null,
+        },
+        {
+          pid: 401,
+          ppid: 400,
+          commandLine:
+            'claude --verbose -p Take ownership of https://example.com/issues/1 and finish it',
+          sessionId: 'aw-uuid',
+          configDir: '/config/aw',
+        },
+      ],
+    };
+
+    const result = useCase.resolve(snapshot);
+
+    expect(result).toEqual([]);
+  });
+
+  it('skips a session whose interactive process exposes no session id or config dir', () => {
+    const snapshot: LiveSessionProcessSnapshot = {
+      sessions: [{ sessionName: 'partial', panePids: [500] }],
+      processes: [
+        {
+          pid: 501,
+          ppid: 500,
+          commandLine: 'claude --model opus',
+          sessionId: null,
+          configDir: '/config/partial',
+        },
+      ],
+    };
+
+    const result = useCase.resolve(snapshot);
+
+    expect(result).toEqual([]);
+  });
+
+  it('ignores non-claude descendants such as monitors', () => {
+    const snapshot: LiveSessionProcessSnapshot = {
+      sessions: [{ sessionName: 'monitored', panePids: [600] }],
+      processes: [
+        {
+          pid: 601,
+          ppid: 600,
+          commandLine: 'node monitor.js',
+          sessionId: 'mon-uuid',
+          configDir: '/config/monitor',
+        },
+      ],
+    };
+
+    const result = useCase.resolve(snapshot);
+
+    expect(result).toEqual([]);
+  });
+
+  it('resolves multiple sessions and drops the ones without an interactive process', () => {
+    const snapshot: LiveSessionProcessSnapshot = {
+      sessions: [
+        { sessionName: 'workbench', panePids: [700] },
+        { sessionName: 'empty', panePids: [800] },
+      ],
+      processes: [
+        {
+          pid: 701,
+          ppid: 700,
+          commandLine: 'claude --name workbench',
+          sessionId: 'wb-uuid',
+          configDir: '/config/workbench',
+        },
+        {
+          pid: 801,
+          ppid: 800,
+          commandLine: 'bash idle',
+          sessionId: null,
+          configDir: null,
+        },
+      ],
+    };
+
+    const result = useCase.resolve(snapshot);
+
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        sessionId: 'wb-uuid',
+        configDir: '/config/workbench',
+      },
+    ]);
+  });
+
+  it('returns an empty list when there are no sessions', () => {
+    const result = useCase.resolve({ sessions: [], processes: [] });
+
+    expect(result).toEqual([]);
+  });
+});

package/src/domain/usecases/ResolveInteractiveLiveSessionsUseCase.ts

@@ -0,0 +1,105 @@
+import { InteractiveLiveSession } from '../entities/InteractiveLiveSession';
+import {
+  LiveSessionProcessInfo,
+  LiveSessionProcessSnapshot,
+} from '../entities/LiveSessionProcessSnapshot';
+
+// Command-line substring that identifies an "owner-handover" agent spawn (for
+// example a background implementation agent started with a prompt beginning
+// "Take ownership of ..."). These spawns are not interactive owner sessions and
+// MUST NOT be notified, so any process whose command line contains this marker
+// is excluded even if it somehow appears under a monitored pane.
+export const OWNER_HANDOVER_COMMAND_MARKER = 'Take ownership of';
+
+// Command-name substring that identifies the interactive Claude Code process.
+const INTERACTIVE_PROCESS_COMMAND_MARKER = 'claude';
+
+const isInteractiveCandidate = (process: LiveSessionProcessInfo): boolean => {
+  if (process.commandLine.includes(OWNER_HANDOVER_COMMAND_MARKER)) {
+    return false;
+  }
+  if (!process.commandLine.includes(INTERACTIVE_PROCESS_COMMAND_MARKER)) {
+    return false;
+  }
+  return process.sessionId !== null && process.configDir !== null;
+};
+
+/**
+ * Selects the interactive Claude Code sessions that are eligible for the silent
+ * self-check notification, independently of session naming or any GitHub issue
+ * linkage.
+ *
+ * Selection works purely from a process snapshot: for each live tmux session,
+ * the descendants of its pane processes are walked, and the first descendant
+ * that looks like an interactive Claude Code process (command line contains
+ * `claude`, does not contain the owner-handover marker, and exposes both a
+ * session id and a config directory in its environment) is taken as the
+ * session's interactive process. Because the walk is anchored on tmux panes,
+ * background owner-handover spawns, the preparation daemon, and monitor
+ * processes — none of which run inside an interactive tmux pane — are naturally
+ * excluded; the explicit owner-handover marker check is an additional guard.
+ */
+export class ResolveInteractiveLiveSessionsUseCase {
+  resolve = (
+    snapshot: LiveSessionProcessSnapshot,
+  ): InteractiveLiveSession[] => {
+    const processByPid = new Map<number, LiveSessionProcessInfo>();
+    const childrenByPpid = new Map<number, LiveSessionProcessInfo[]>();
+    for (const process of snapshot.processes) {
+      processByPid.set(process.pid, process);
+      const siblings = childrenByPpid.get(process.ppid) ?? [];
+      siblings.push(process);
+      childrenByPpid.set(process.ppid, siblings);
+    }
+
+    const sessions: InteractiveLiveSession[] = [];
+    for (const session of snapshot.sessions) {
+      const interactiveProcess = this.findInteractiveProcess(
+        session.panePids,
+        processByPid,
+        childrenByPpid,
+      );
+      if (
+        interactiveProcess === null ||
+        interactiveProcess.sessionId === null ||
+        interactiveProcess.configDir === null
+      ) {
+        continue;
+      }
+      sessions.push({
+        sessionName: session.sessionName,
+        sessionId: interactiveProcess.sessionId,
+        configDir: interactiveProcess.configDir,
+      });
+    }
+    return sessions;
+  };
+
+  private findInteractiveProcess = (
+    panePids: number[],
+    processByPid: Map<number, LiveSessionProcessInfo>,
+    childrenByPpid: Map<number, LiveSessionProcessInfo[]>,
+  ): LiveSessionProcessInfo | null => {
+    const visited = new Set<number>();
+    const queue: number[] = [...panePids];
+    let head = 0;
+    while (head < queue.length) {
+      const pid = queue[head];
+      head += 1;
+      if (visited.has(pid)) {
+        continue;
+      }
+      visited.add(pid);
+      const process = processByPid.get(pid);
+      if (process !== undefined && isInteractiveCandidate(process)) {
+        return process;
+      }
+      for (const child of childrenByPpid.get(pid) ?? []) {
+        if (!visited.has(child.pid)) {
+          queue.push(child.pid);
+        }
+      }
+    }
+    return null;
+  };
+}

package/src/domain/usecases/adapter-interfaces/InteractiveLiveSessionTranscriptResolver.ts

@@ -0,0 +1,7 @@
+import { InteractiveLiveSession } from '../../entities/InteractiveLiveSession';
+
+export interface InteractiveLiveSessionTranscriptResolver {
+  resolveTranscriptPaths: (
+    sessions: InteractiveLiveSession[],
+  ) => Map<string, string>;
+}

package/src/domain/usecases/adapter-interfaces/LiveSessionProcessSnapshotProvider.ts

@@ -0,0 +1,5 @@
+import { LiveSessionProcessSnapshot } from '../../entities/LiveSessionProcessSnapshot';
+
+export interface LiveSessionProcessSnapshotProvider {
+  getSnapshot: () => Promise<LiveSessionProcessSnapshot>;
+}

package/src/domain/usecases/adapter-interfaces/OwnerCallStatusProvider.ts

@@ -1,5 +1,5 @@
 export interface OwnerCallStatusProvider {
   listSessionNamesWithUnansweredOwnerCall: (
-    sessionNames: string[],
+    transcriptPathBySessionName: Map<string, string>,
   ) => Promise<Set<string>>;
 }

package/src/domain/usecases/adapter-interfaces/ProcessEnvironReader.ts

@@ -0,0 +1,3 @@
+export interface ProcessEnvironReader {
+  readEnviron: (pid: number) => Record<string, string> | null;
+}

package/src/domain/usecases/adapter-interfaces/SessionOutputActivityRepository.ts

@@ -2,6 +2,6 @@ import { LiveSessionOutputActivity } from '../../entities/LiveSessionOutputActiv
 
 export interface SessionOutputActivityRepository {
   listSessionOutputActivities: (
-    sessionNames: string[],
+    transcriptPathBySessionName: Map<string, string>,
   ) => Promise<LiveSessionOutputActivity[]>;
 }

package/types/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAiD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,KAChB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CA8iBP;CACH"}
+{"version":3,"file":"HandleScheduledEventUseCaseHandler.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAiD3D,qBAAa,kCAAkC;IAC7C,MAAM,GACJ,gBAAgB,MAAM,EACtB,UAAU,OAAO,KAChB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,KAAK,EAAE,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,eAAe,EAAE,IAAI,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC,CAoiBP;CACH"}

package/types/adapter/entry-points/handlers/notifySilentTmuxSessions.d.ts

@@ -1,16 +1,12 @@
-import { Project } from '../../../domain/entities/Project';
 import { LocalCommandRunner } from '../../../domain/usecases/adapter-interfaces/LocalCommandRunner';
-import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
 import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
 import { SilentSessionMessageTemplates } from '../../repositories/ConfigurableSilentSessionMessageComposer';
 export type NotifySilentTmuxSessionsParams = {
-    project: Project;
-    allowCacheMinutes: number;
-    issueRepository: Pick<IssueRepository, 'getAllOpened'>;
+    enabled: boolean;
     localCommandRunner: LocalCommandRunner;
+    processEnvironReader?: ProcessEnvironReader;
     cacheRepository: Pick<LocalStorageCacheRepository, 'getLatest' | 'set'>;
-    sessionOutputRootDirectory: string | null;
-    sessionTranscriptRootDirectory: string | null;
     ownerCallMarker: string | null;
     subAgentOutputRootDirectory: string | null;
     subAgentProcessMatchPattern: string | null;

package/types/adapter/entry-points/handlers/notifySilentTmuxSessions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notifySilentTmuxSessions.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gEAAgE,CAAC;AACpG,OAAO,EAAE,eAAe,EAAE,MAAM,6DAA6D,CAAC;AAgB9F,OAAO,EAAE,2BAA2B,EAAE,MAAM,gDAAgD,CAAC;AAQ7F,OAAO,EAEL,6BAA6B,EAC9B,MAAM,6DAA6D,CAAC;AAGrE,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;IACvD,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,eAAe,EAAE,IAAI,CAAC,2BAA2B,EAAE,WAAW,GAAG,KAAK,CAAC,CAAC;IACxE,0BAA0B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,8BAA8B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,0BAA0B,EAAE,MAAM,CAAC;IACnC,8BAA8B,EAAE,MAAM,CAAC;IACvC,+BAA+B,EAAE,MAAM,CAAC;IACxC,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,6BAA6B,CAAC;IAChD,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AA4CF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,8BAA8B,KACrC,OAAO,CAAC,IAAI,CAoEd,CAAC;AAEF,eAAO,MAAM,0CAA0C;;;;;;CAM7C,CAAC"}
+{"version":3,"file":"notifySilentTmuxSessions.d.ts","sourceRoot":"","sources":["../../../../src/adapter/entry-points/handlers/notifySilentTmuxSessions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gEAAgE,CAAC;AAGpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,kEAAkE,CAAC;AAexG,OAAO,EAAE,2BAA2B,EAAE,MAAM,gDAAgD,CAAC;AAQ7F,OAAO,EAEL,6BAA6B,EAC9B,MAAM,6DAA6D,CAAC;AAGrE,MAAM,MAAM,8BAA8B,GAAG;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,eAAe,EAAE,IAAI,CAAC,2BAA2B,EAAE,WAAW,GAAG,KAAK,CAAC,CAAC;IACxE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,2BAA2B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,0BAA0B,EAAE,MAAM,CAAC;IACnC,8BAA8B,EAAE,MAAM,CAAC;IACvC,+BAA+B,EAAE,MAAM,CAAC;IACxC,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,6BAA6B,CAAC;IAChD,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAoCF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,8BAA8B,KACrC,OAAO,CAAC,IAAI,CA0Dd,CAAC;AAEF,eAAO,MAAM,0CAA0C;;;;;;CAM7C,CAAC"}

package/types/adapter/repositories/FileSystemInteractiveLiveSessionTranscriptResolver.d.ts

@@ -0,0 +1,18 @@
+import { InteractiveLiveSession } from '../../domain/entities/InteractiveLiveSession';
+import { InteractiveLiveSessionTranscriptResolver } from '../../domain/usecases/adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
+/**
+ * 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 declare class FileSystemInteractiveLiveSessionTranscriptResolver implements InteractiveLiveSessionTranscriptResolver {
+    resolveTranscriptPaths: (sessions: InteractiveLiveSession[]) => Map<string, string>;
+    private resolveTranscriptPath;
+}
+//# sourceMappingURL=FileSystemInteractiveLiveSessionTranscriptResolver.d.ts.map

package/types/adapter/repositories/FileSystemInteractiveLiveSessionTranscriptResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileSystemInteractiveLiveSessionTranscriptResolver.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileSystemInteractiveLiveSessionTranscriptResolver.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,8CAA8C,CAAC;AACtF,OAAO,EAAE,wCAAwC,EAAE,MAAM,mFAAmF,CAAC;AAW7I;;;;;;;;;;GAUG;AACH,qBAAa,kDAAmD,YAAW,wCAAwC;IACjH,sBAAsB,GACpB,UAAU,sBAAsB,EAAE,KACjC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CASpB;IAEF,OAAO,CAAC,qBAAqB,CAkC3B;CACH"}

package/types/adapter/repositories/FileSystemSessionOutputActivityRepository.d.ts

@@ -1,10 +1,14 @@
 import { LiveSessionOutputActivity } from '../../domain/entities/LiveSessionOutputActivity';
 import { SessionOutputActivityRepository } from '../../domain/usecases/adapter-interfaces/SessionOutputActivityRepository';
+/**
+ * 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 declare class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
-    private readonly rootDirectory;
-    constructor(rootDirectory: string | null);
-    listSessionOutputActivities: (sessionNames: string[]) => Promise<LiveSessionOutputActivity[]>;
-    private readLastOutputEpochSeconds;
-    private toOutputFileName;
+    listSessionOutputActivities: (transcriptPathBySessionName: Map<string, string>) => Promise<LiveSessionOutputActivity[]>;
+    private readLastAssistantOutputEpochSeconds;
 }
 //# sourceMappingURL=FileSystemSessionOutputActivityRepository.d.ts.map

package/types/adapter/repositories/FileSystemSessionOutputActivityRepository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileSystemSessionOutputActivityRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,iDAAiD,CAAC;AAC5F,OAAO,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAE3H,qBAAa,yCAA0C,YAAW,+BAA+B;IACnF,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,MAAM,GAAG,IAAI;IAEzD,2BAA2B,GACzB,cAAc,MAAM,EAAE,KACrB,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAarC;IAEF,OAAO,CAAC,0BAA0B,CAkBhC;IAEF,OAAO,CAAC,gBAAgB,CACU;CACnC"}
+{"version":3,"file":"FileSystemSessionOutputActivityRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,iDAAiD,CAAC;AAC5F,OAAO,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAqB3H;;;;;;GAMG;AACH,qBAAa,yCAA0C,YAAW,+BAA+B;IAC/F,2BAA2B,GACzB,6BAA6B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAC/C,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAUrC;IAEF,OAAO,CAAC,mCAAmC,CAuCzC;CACH"}

package/types/adapter/repositories/LocalProcessLiveSessionProcessSnapshotProvider.d.ts

@@ -0,0 +1,21 @@
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { LiveSessionProcessSnapshotProvider } from '../../domain/usecases/adapter-interfaces/LiveSessionProcessSnapshotProvider';
+import { ProcessEnvironReader } from '../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
+import { LiveSessionProcessSnapshot } from '../../domain/entities/LiveSessionProcessSnapshot';
+/**
+ * Builds a live-session process snapshot from the local host: it lists the live
+ * tmux sessions and each session's pane process ids, lists the full process
+ * tree with command lines, and reads each process environment to expose the
+ * Claude Code session id and config directory. The snapshot is consumed by a
+ * pure resolver, so all host access is contained in this adapter.
+ */
+export declare class LocalProcessLiveSessionProcessSnapshotProvider implements LiveSessionProcessSnapshotProvider {
+    private readonly localCommandRunner;
+    private readonly environReader;
+    constructor(localCommandRunner: LocalCommandRunner, environReader: ProcessEnvironReader);
+    getSnapshot: () => Promise<LiveSessionProcessSnapshot>;
+    private listSessionNames;
+    private listPanePids;
+    private listProcesses;
+}
+//# sourceMappingURL=LocalProcessLiveSessionProcessSnapshotProvider.d.ts.map

package/types/adapter/repositories/LocalProcessLiveSessionProcessSnapshotProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalProcessLiveSessionProcessSnapshotProvider.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/LocalProcessLiveSessionProcessSnapshotProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAC;AACjG,OAAO,EAAE,kCAAkC,EAAE,MAAM,6EAA6E,CAAC;AACjI,OAAO,EAAE,oBAAoB,EAAE,MAAM,+DAA+D,CAAC;AACrG,OAAO,EAGL,0BAA0B,EAC3B,MAAM,kDAAkD,CAAC;AAK1D;;;;;;GAMG;AACH,qBAAa,8CAA+C,YAAW,kCAAkC;IAErG,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa;gBADb,kBAAkB,EAAE,kBAAkB,EACtC,aAAa,EAAE,oBAAoB;IAGtD,WAAW,QAAa,OAAO,CAAC,0BAA0B,CAAC,CASzD;IAEF,OAAO,CAAC,gBAAgB,CAYtB;IAEF,OAAO,CAAC,YAAY,CAYlB;IAEF,OAAO,CAAC,aAAa,CA2BnB;CACH"}

package/types/adapter/repositories/NoUnansweredOwnerCallStatusProvider.d.ts

@@ -1,5 +1,5 @@
 import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
 export declare class NoUnansweredOwnerCallStatusProvider implements OwnerCallStatusProvider {
-    listSessionNamesWithUnansweredOwnerCall: (_sessionNames: string[]) => Promise<Set<string>>;
+    listSessionNamesWithUnansweredOwnerCall: (_transcriptPathBySessionName: Map<string, string>) => Promise<Set<string>>;
 }
 //# sourceMappingURL=NoUnansweredOwnerCallStatusProvider.d.ts.map

package/types/adapter/repositories/NoUnansweredOwnerCallStatusProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NoUnansweredOwnerCallStatusProvider.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/NoUnansweredOwnerCallStatusProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kEAAkE,CAAC;AAE3G,qBAAa,mCAAoC,YAAW,uBAAuB;IACjF,uCAAuC,GACrC,eAAe,MAAM,EAAE,KACtB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAErB;CACH"}
+{"version":3,"file":"NoUnansweredOwnerCallStatusProvider.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/NoUnansweredOwnerCallStatusProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kEAAkE,CAAC;AAE3G,qBAAa,mCAAoC,YAAW,uBAAuB;IACjF,uCAAuC,GACrC,8BAA8B,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAChD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAErB;CACH"}