github-issue-tower-defence-management 1.114.1 → 1.115.0

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

@@ -6,6 +6,7 @@ import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interface
 import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
 import { LocalStorageRepository } from '../../repositories/LocalStorageRepository';
 import { SilentSessionMessageTemplates } from '../../repositories/ConfigurableSilentSessionMessageComposer';
+import { Issue } from '../../../domain/entities/Issue';
 import { SILENT_SESSION_REMINDER_SENTINEL } from '../../../domain/usecases/silentSessionReminderSentinel';
 import {
   notifySilentTmuxSessions,
@@ -130,6 +131,8 @@ describe('notifySilentTmuxSessions', () => {
     subAgentOutputRootDirectory: null,
     subAgentProcessMatchPattern: null,
     subAgentTranscriptRootDirectory: null,
+    activeHubTaskStatus: null,
+    hubTaskStatusResolver: null,
     messageTemplates: EMPTY_TEMPLATES,
     now: NOW,
     ...DEFAULT_NOTIFY_SILENT_TMUX_SESSIONS_PARAMS,
@@ -266,6 +269,123 @@ describe('notifySilentTmuxSessions', () => {
     expect(secondSendCall).toBeUndefined();
   });
 
+  const HUB_TASK_SESSION_NAME =
+    'https://github.com/HiromiShikata/repo/issues/42';
+
+  const writeUrlSessionTranscript = (): void => {
+    const projectDirectory = path.join(configDir, 'projects', '-home-user');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    const silentTimestamp = new Date(
+      (NOW_EPOCH_SECONDS - 11 * 60) * 1000,
+    ).toISOString();
+    fs.writeFileSync(
+      path.join(projectDirectory, `${SESSION_ID}.jsonl`),
+      JSON.stringify({
+        type: 'assistant',
+        timestamp: silentTimestamp,
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'progress update' }],
+        },
+      }),
+      'utf8',
+    );
+  };
+
+  const urlSessionRunner = (): Mocked<LocalCommandRunner> => {
+    const runner = createMockRunner();
+    runner.runCommand.mockImplementation(async (program, args) => {
+      if (program === 'tmux' && args[0] === 'list-sessions') {
+        return {
+          stdout: `${HUB_TASK_SESSION_NAME}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      if (program === 'tmux' && args[0] === 'list-panes') {
+        return { stdout: `${PANE_PID}\n`, stderr: '', exitCode: 0 };
+      }
+      if (program === 'ps') {
+        return {
+          stdout: `  ${PANE_PID}       1 shell\n  ${CLAUDE_PID}     ${PANE_PID} claude --name ${HUB_TASK_SESSION_NAME}\n`,
+          stderr: '',
+          exitCode: 0,
+        };
+      }
+      return { stdout: '', stderr: '', exitCode: 0 };
+    });
+    return runner;
+  };
+
+  const makeIssue = (overrides: {
+    state: Issue['state'];
+    status: string | null;
+  }): Issue => ({
+    nameWithOwner: 'HiromiShikata/repo',
+    number: 42,
+    title: 'Hub task',
+    state: overrides.state,
+    status: overrides.status,
+    story: null,
+    nextActionDate: null,
+    nextActionHour: null,
+    estimationMinutes: null,
+    dependedIssueUrls: [],
+    completionDate50PercentConfidence: null,
+    url: HUB_TASK_SESSION_NAME,
+    assignees: [],
+    labels: [],
+    org: 'HiromiShikata',
+    repo: 'repo',
+    body: '',
+    itemId: 'item-id',
+    isPr: false,
+    isInProgress: false,
+    isClosed: overrides.state !== 'OPEN',
+    createdAt: NOW,
+    author: 'HiromiShikata',
+    closingIssueReferenceUrls: [],
+  });
+
+  it('skips a URL-named session whose hub task is no longer in the active status', async () => {
+    writeUrlSessionTranscript();
+    const runner = urlSessionRunner();
+    const getIssueByUrl = jest
+      .fn()
+      .mockResolvedValue(makeIssue({ state: 'OPEN', status: 'Todo' }));
+
+    await notifySilentTmuxSessions({
+      ...baseParams(runner),
+      activeHubTaskStatus: 'In tmux',
+      hubTaskStatusResolver: { getIssueByUrl },
+    });
+
+    expect(getIssueByUrl).toHaveBeenCalledWith(HUB_TASK_SESSION_NAME);
+    const sendCall = runner.runCommand.mock.calls.find(
+      (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
+    );
+    expect(sendCall).toBeUndefined();
+  });
+
+  it('sends to a URL-named session whose hub task is in the active status', async () => {
+    writeUrlSessionTranscript();
+    const runner = urlSessionRunner();
+    const getIssueByUrl = jest
+      .fn()
+      .mockResolvedValue(makeIssue({ state: 'OPEN', status: 'In tmux' }));
+
+    await notifySilentTmuxSessions({
+      ...baseParams(runner),
+      activeHubTaskStatus: 'In tmux',
+      hubTaskStatusResolver: { getIssueByUrl },
+    });
+
+    const sendCall = runner.runCommand.mock.calls.find(
+      (call) => call[0] === 'tmux' && call[1][0] === 'send-keys',
+    );
+    expect(sendCall?.[1][2]).toBe(HUB_TASK_SESSION_NAME);
+  });
+
   it('re-sends within the cooldown window when each project pass uses its own cache scope', async () => {
     silentAssistantTranscript();
     // This reproduces the per-project cooldown defect: when each project pass

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

@@ -4,6 +4,7 @@ import { OwnerCallStatusProvider } from '../../../domain/usecases/adapter-interf
 import { ProcessEnvironReader } from '../../../domain/usecases/adapter-interfaces/ProcessEnvironReader';
 import {
   NotifySilentLiveSessionsUseCase,
+  HubTaskStatusResolver,
   DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
@@ -44,6 +45,8 @@ export type NotifySilentTmuxSessionsParams = {
   subAgentRunningThresholdSeconds: number;
   cooldownSeconds: number;
   staggerSeconds: number;
+  activeHubTaskStatus: string | null;
+  hubTaskStatusResolver: HubTaskStatusResolver | null;
   messageTemplates: SilentSessionMessageTemplates;
   now: Date;
 };
@@ -99,6 +102,8 @@ export const notifySilentTmuxSessions = async (
     subAgentRunningThresholdSeconds,
     cooldownSeconds,
     staggerSeconds,
+    activeHubTaskStatus,
+    hubTaskStatusResolver,
     messageTemplates,
     now,
   } = params;
@@ -133,6 +138,7 @@ export const notifySilentTmuxSessions = async (
     ),
     messageComposer,
     new RealSleeper(),
+    hubTaskStatusResolver,
   );
   await useCase.run({
     mainSilentThresholdSeconds,
@@ -140,6 +146,7 @@ export const notifySilentTmuxSessions = async (
     subAgentRunningThresholdSeconds,
     cooldownSeconds,
     staggerSeconds,
+    activeHubTaskStatus,
     now,
   });
 };

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

@@ -87,6 +87,52 @@ describe('FileSystemInteractiveLiveSessionTranscriptResolver', () => {
     expect(result.get('workbench')).toBe(rotatedPath);
   });
 
+  it('resolves a non-resume session to the descendant id file when the own launch id file is absent', () => {
+    const configDir = path.join(configRoot, 'non-resume');
+    const harnessPath = writeTranscript({
+      projectsDirectory: path.join(configDir, 'projects'),
+      cwdSlug: '-home-user',
+      sessionId: 'harness-id',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
+
+    const result = resolver.resolveTranscriptPaths([
+      {
+        sessionName: 'non-resume',
+        sessionId: 'launch-id',
+        candidateSessionIds: ['launch-id', 'harness-id'],
+        configDir,
+      },
+    ]);
+
+    expect(result.get('non-resume')).toBe(harnessPath);
+  });
+
+  it('resolves a resume session to the own id file when descendants share the own id', () => {
+    const configDir = path.join(configRoot, 'resume');
+    const ownPath = writeTranscript({
+      projectsDirectory: path.join(configDir, 'projects'),
+      cwdSlug: '-home-user',
+      sessionId: 'own-id',
+    });
+    const resolver = new FileSystemInteractiveLiveSessionTranscriptResolver(
+      sharedProjectsDirectory,
+    );
+
+    const result = resolver.resolveTranscriptPaths([
+      {
+        sessionName: 'resume',
+        sessionId: 'own-id',
+        candidateSessionIds: ['own-id', 'own-id'],
+        configDir,
+      },
+    ]);
+
+    expect(result.get('resume')).toBe(ownPath);
+  });
+
   it('resolves a transcript that lives under the shared projects directory', () => {
     const configDir = path.join(configRoot, 'workbench');
     const sharedPath = writeTranscript({

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

@@ -31,6 +31,17 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     message: { role: 'user', content: 'go ahead' },
   });
 
+  const toolResultEntry = (timestamp: string): object => ({
+    type: 'tool_result',
+    timestamp,
+    toolUseResult: { stdout: 'done', stderr: '' },
+  });
+
+  const untimestampedEntry = (): object => ({
+    type: 'summary',
+    summary: 'no timestamp on this entry',
+  });
+
   const writeTranscript = (fileName: string, lines: object[]): string => {
     const filePath = path.join(rootDirectory, fileName);
     fs.writeFileSync(
@@ -41,7 +52,7 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     return filePath;
   };
 
-  it('returns the latest assistant entry timestamp as the last output epoch', async () => {
+  it('returns the latest entry timestamp of any type as the last activity epoch', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
       userEntry('2026-06-27T10:30:00.000Z'),
@@ -57,13 +68,13 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:05:00.000Z') / 1000,
+          Date.parse('2026-06-27T10:30:00.000Z') / 1000,
         ),
       },
     ]);
   });
 
-  it('ignores user entries when computing the last output epoch', async () => {
+  it('advances the last activity time when a later user entry follows an assistant entry', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       assistantEntry('2026-06-27T10:00:00.000Z'),
       userEntry('2026-06-27T11:00:00.000Z'),
@@ -78,7 +89,28 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       {
         sessionName: 'workbench',
         lastOutputEpochSeconds: Math.floor(
-          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+          Date.parse('2026-06-27T11:00:00.000Z') / 1000,
+        ),
+      },
+    ]);
+  });
+
+  it('advances the last activity time when a tool_result entry is the latest entry', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      assistantEntry('2026-06-27T10:00:00.000Z'),
+      toolResultEntry('2026-06-27T10:45:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:45:00.000Z') / 1000,
         ),
       },
     ]);
@@ -107,7 +139,7 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     ]);
   });
 
-  it('omits sessions whose transcript has no assistant entry', async () => {
+  it('resolves a transcript whose only entry is a non-assistant entry', async () => {
     const transcriptPath = writeTranscript('workbench.jsonl', [
       userEntry('2026-06-27T10:00:00.000Z'),
     ]);
@@ -117,6 +149,26 @@ describe('FileSystemSessionOutputActivityRepository', () => {
       new Map([['workbench', transcriptPath]]),
     );
 
+    expect(result).toEqual([
+      {
+        sessionName: 'workbench',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T10:00:00.000Z') / 1000,
+        ),
+      },
+    ]);
+  });
+
+  it('omits sessions whose transcript has no parseable timestamp', async () => {
+    const transcriptPath = writeTranscript('workbench.jsonl', [
+      untimestampedEntry(),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['workbench', transcriptPath]]),
+    );
+
     expect(result).toEqual([]);
   });
 

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts

@@ -22,11 +22,14 @@ const parseEpochMilliseconds = (timestamp: string | null): number | null => {
 };
 
 /**
- * Reads the last main-session output time for each live session from its
+ * Reads the last main-session activity 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.
+ * the latest entry of any kind (assistant text, owner replies, tool results, or
+ * any other entry type) rather than from the transcript file modification time.
+ * Because a session that is actively running tool calls keeps appending entries
+ * such as `user` and `tool_result` even while it emits no assistant text, every
+ * entry with a parseable timestamp counts as activity, so a working session is
+ * not mistaken for a silent one.
  */
 export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
   listSessionOutputActivities = async (
@@ -35,7 +38,7 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
     const activities: LiveSessionOutputActivity[] = [];
     for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
       const lastOutputEpochSeconds =
-        this.readLastAssistantOutputEpochSeconds(transcriptPath);
+        this.readLastActivityEpochSeconds(transcriptPath);
       if (lastOutputEpochSeconds !== null) {
         activities.push({ sessionName, lastOutputEpochSeconds });
       }
@@ -43,7 +46,7 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
     return activities;
   };
 
-  private readLastAssistantOutputEpochSeconds = (
+  private readLastActivityEpochSeconds = (
     transcriptPath: string,
   ): number | null => {
     let content: string;
@@ -52,7 +55,7 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
     } catch {
       return null;
     }
-    let lastAssistantEpochMs: number | null = null;
+    let lastActivityEpochMs: number | null = null;
     for (const line of content.split('\n')) {
       const trimmed = line.trim();
       if (trimmed.length === 0) {
@@ -67,20 +70,17 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
       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 (lastActivityEpochMs === null || epochMs > lastActivityEpochMs) {
+        lastActivityEpochMs = epochMs;
       }
     }
-    if (lastAssistantEpochMs === null) {
+    if (lastActivityEpochMs === null) {
       return null;
     }
-    return Math.floor(lastAssistantEpochMs / 1000);
+    return Math.floor(lastActivityEpochMs / 1000);
   };
 }

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

@@ -1,11 +1,14 @@
 import {
   NotifySilentLiveSessionsUseCase,
+  HubTaskStatusResolver,
+  parseHubTaskIssueUrlFromSessionName,
   DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_SILENT_THRESHOLD_SECONDS,
   DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
   DEFAULT_NOTIFICATION_COOLDOWN_SECONDS,
   DEFAULT_NOTIFICATION_STAGGER_SECONDS,
 } from './NotifySilentLiveSessionsUseCase';
+import { Issue } from '../entities/Issue';
 import { LiveSessionProcessSnapshotProvider } from './adapter-interfaces/LiveSessionProcessSnapshotProvider';
 import { InteractiveLiveSessionTranscriptResolver } from './adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
 import { SessionOutputActivityRepository } from './adapter-interfaces/SessionOutputActivityRepository';
@@ -33,15 +36,19 @@ describe('NotifySilentLiveSessionsUseCase', () => {
   let mockNotificationRepository: Mocked<SilentSessionNotificationRepository>;
   let mockMessageComposer: Mocked<SilentSessionMessageComposer>;
   let mockSleeper: Mocked<Sleeper>;
+  let mockHubTaskStatusResolver: Mocked<HubTaskStatusResolver>;
   const now = new Date('2026-06-26T00:00:00Z');
   const nowEpochSeconds = Math.floor(now.getTime() / 1000);
 
-  const runParams = (): {
+  const runParams = (
+    overrides?: Partial<{ activeHubTaskStatus: string | null }>,
+  ): {
     mainSilentThresholdSeconds: number;
     subAgentSilentThresholdSeconds: number;
     subAgentRunningThresholdSeconds: number;
     cooldownSeconds: number;
     staggerSeconds: number;
+    activeHubTaskStatus: string | null;
     now: Date;
   } => ({
     mainSilentThresholdSeconds: DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
@@ -49,7 +56,9 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     subAgentRunningThresholdSeconds: DEFAULT_SUBAGENT_RUNNING_THRESHOLD_SECONDS,
     cooldownSeconds: DEFAULT_NOTIFICATION_COOLDOWN_SECONDS,
     staggerSeconds: DEFAULT_NOTIFICATION_STAGGER_SECONDS,
+    activeHubTaskStatus: null,
     now,
+    ...overrides,
   });
 
   const emptySnapshot: LiveSessionProcessSnapshot = {
@@ -131,6 +140,9 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     mockSleeper = {
       sleep: jest.fn().mockResolvedValue(undefined),
     };
+    mockHubTaskStatusResolver = {
+      getIssueByUrl: jest.fn().mockResolvedValue(null),
+    };
     useCase = new NotifySilentLiveSessionsUseCase(
       mockSnapshotProvider,
       mockTranscriptResolver,
@@ -140,9 +152,51 @@ describe('NotifySilentLiveSessionsUseCase', () => {
       mockNotificationRepository,
       mockMessageComposer,
       mockSleeper,
+      mockHubTaskStatusResolver,
     );
   });
 
+  const issueFor = (overrides: Partial<Issue>): Issue => ({
+    nameWithOwner: 'HiromiShikata/repo',
+    number: 42,
+    title: 'Hub task',
+    state: 'OPEN',
+    status: 'In tmux',
+    story: null,
+    nextActionDate: null,
+    nextActionHour: null,
+    estimationMinutes: null,
+    dependedIssueUrls: [],
+    completionDate50PercentConfidence: null,
+    url: 'https://github.com/HiromiShikata/repo/issues/42',
+    assignees: [],
+    labels: [],
+    org: 'HiromiShikata',
+    repo: 'repo',
+    body: '',
+    itemId: 'item-id',
+    isPr: false,
+    isInProgress: false,
+    isClosed: false,
+    createdAt: now,
+    author: 'HiromiShikata',
+    closingIssueReferenceUrls: [],
+    ...overrides,
+  });
+
+  const setupSilentMainSession = (sessionName: string): void => {
+    setupLiveInteractiveSession(sessionName);
+    mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
+      [
+        {
+          sessionName,
+          lastOutputEpochSeconds:
+            nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
+        },
+      ],
+    );
+  };
+
   const setupLiveInteractiveSession = (sessionName: string): void => {
     mockSnapshotProvider.getSnapshot.mockResolvedValue(
       snapshotWithSessions([sessionName]),
@@ -406,6 +460,139 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     await expect(useCase.run(runParams())).rejects.toThrow('send-keys failed');
   });
 
+  describe('hub-task active-status pre-send gate', () => {
+    const HUB_TASK_SESSION = 'https://github.com/HiromiShikata/repo/issues/42';
+    const ACTIVE_STATUS = 'In tmux';
+
+    it('sends when the hub task is open and in the active status', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(
+        issueFor({
+          url: HUB_TASK_SESSION,
+          state: 'OPEN',
+          status: ACTIVE_STATUS,
+        }),
+      );
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(mockHubTaskStatusResolver.getIssueByUrl).toHaveBeenCalledWith(
+        HUB_TASK_SESSION,
+      );
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
+    });
+
+    it('skips when the hub task status differs from the active status', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(
+        issueFor({ url: HUB_TASK_SESSION, state: 'OPEN', status: 'Todo' }),
+      );
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('skips when the hub task issue is closed', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(
+        issueFor({
+          url: HUB_TASK_SESSION,
+          state: 'CLOSED',
+          status: ACTIVE_STATUS,
+          isClosed: true,
+        }),
+      );
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('leaves a non-URL session name unchecked and sends as before', async () => {
+      setupSilentMainSession('workbench');
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(mockHubTaskStatusResolver.getIssueByUrl).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith('workbench', MAIN_STALLED_SECTION);
+    });
+
+    it('does not call the resolver at all when the active status is unconfigured', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+
+      await useCase.run(runParams({ activeHubTaskStatus: null }));
+
+      expect(mockHubTaskStatusResolver.getIssueByUrl).not.toHaveBeenCalled();
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
+    });
+
+    it('fails open and logs a warning when status resolution throws', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      const warnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => undefined);
+      mockHubTaskStatusResolver.getIssueByUrl.mockRejectedValue(
+        new Error('GitHub API timeout'),
+      );
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('fail-open'),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('fails open and logs a warning when the hub task cannot be resolved', async () => {
+      setupSilentMainSession(HUB_TASK_SESSION);
+      const warnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => undefined);
+      mockHubTaskStatusResolver.getIssueByUrl.mockResolvedValue(null);
+
+      await useCase.run(runParams({ activeHubTaskStatus: ACTIVE_STATUS }));
+
+      expect(
+        mockNotificationRepository.sendSelfCheckNotification,
+      ).toHaveBeenCalledWith(HUB_TASK_SESSION, MAIN_STALLED_SECTION);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('fail-open'),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it('parses a github.com issue URL session name and rejects other names', () => {
+      expect(parseHubTaskIssueUrlFromSessionName(HUB_TASK_SESSION)).toBe(
+        HUB_TASK_SESSION,
+      );
+      expect(parseHubTaskIssueUrlFromSessionName('workbench')).toBeNull();
+      expect(
+        parseHubTaskIssueUrlFromSessionName(
+          'https://github.com/HiromiShikata/repo/pull/42',
+        ),
+      ).toBeNull();
+      expect(
+        parseHubTaskIssueUrlFromSessionName(
+          'https://example.com/HiromiShikata/repo/issues/42',
+        ),
+      ).toBeNull();
+    });
+  });
+
   it('uses the session entity helper for type completeness', () => {
     expect(sessionFor('workbench')).toEqual({
       sessionName: 'workbench',