github-issue-tower-defence-management 1.139.1 → 1.140.1

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

@@ -124,7 +124,6 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T01:00:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -146,7 +145,6 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T09:55:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -168,7 +166,6 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -190,7 +187,6 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -214,7 +210,6 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T10:05:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -236,7 +231,6 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -260,7 +254,6 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T10:00:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: false,
       },
     ]);
   });
@@ -293,7 +286,7 @@ describe('FileSystemSessionOutputActivityRepository', () => {
     expect(result).toEqual([]);
   });
 
-  it('flags a session as waiting on a running tool when the last assistant tool_use has no matching tool_result', async () => {
+  it('reports the assistant tool_use timestamp as the last output even when no tool_result has arrived, without any in-progress flagging', async () => {
     const transcriptPath = writeTranscript('busy.jsonl', [
       assistantEntry('2026-06-27T09:00:00.000Z'),
       assistantEntryWithToolUse('2026-06-27T09:01:00.000Z', 'toolu_running'),
@@ -310,12 +303,11 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T09:01:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: true,
       },
     ]);
   });
 
-  it('does not flag a session once the matching tool_result for its last tool_use is appended', async () => {
+  it('reports the assistant tool_use timestamp as the last output when a later tool_result user entry follows it', async () => {
     const transcriptPath = writeTranscript('completed.jsonl', [
       assistantEntryWithToolUse('2026-06-27T09:01:00.000Z', 'toolu_done'),
       toolResultUserEntry('2026-06-27T09:05:00.000Z', 'toolu_done'),
@@ -332,7 +324,28 @@ describe('FileSystemSessionOutputActivityRepository', () => {
         lastOutputEpochSeconds: Math.floor(
           Date.parse('2026-06-27T09:01:00.000Z') / 1000,
         ),
-        hasInProgressToolCall: false,
+      },
+    ]);
+  });
+
+  it('reports the later assistant text timestamp when an orphaned tool_use is followed by a resumed assistant turn, carrying no in-progress state', async () => {
+    const transcriptPath = writeTranscript('orphaned.jsonl', [
+      assistantEntryWithToolUse('2026-06-27T09:00:00.000Z', 'toolu_orphaned'),
+      assistantEntry('2026-06-27T09:46:53.000Z'),
+      userEntry('2026-06-27T09:47:00.000Z'),
+    ]);
+    const repository = new FileSystemSessionOutputActivityRepository();
+
+    const result = await repository.listSessionOutputActivities(
+      new Map([['orphaned', transcriptPath]]),
+    );
+
+    expect(result).toEqual([
+      {
+        sessionName: 'orphaned',
+        lastOutputEpochSeconds: Math.floor(
+          Date.parse('2026-06-27T09:46:53.000Z') / 1000,
+        ),
       },
     ]);
   });

package/src/adapter/repositories/FileSystemSessionOutputActivityRepository.ts

@@ -21,54 +21,34 @@ const parseEpochMilliseconds = (timestamp: string | null): number | null => {
   return Number.isNaN(parsed) ? null : parsed;
 };
 
-const readContentBlocks = (
-  message: Record<string, unknown>,
-): Record<string, unknown>[] => {
-  const content = message.content;
-  if (!Array.isArray(content)) {
-    return [];
-  }
-  return content.filter(isRecord);
-};
-
-type TranscriptActivity = {
-  lastAssistantOutputEpochSeconds: number | null;
-  hasInProgressToolCall: boolean;
-};
-
 export class FileSystemSessionOutputActivityRepository implements SessionOutputActivityRepository {
   listSessionOutputActivities = async (
     transcriptPathBySessionName: Map<string, string>,
   ): Promise<LiveSessionOutputActivity[]> => {
     const activities: LiveSessionOutputActivity[] = [];
     for (const [sessionName, transcriptPath] of transcriptPathBySessionName) {
-      const { lastAssistantOutputEpochSeconds, hasInProgressToolCall } =
-        this.readTranscriptActivity(transcriptPath);
+      const lastAssistantOutputEpochSeconds =
+        this.readLastAssistantOutputEpochSeconds(transcriptPath);
       if (lastAssistantOutputEpochSeconds !== null) {
         activities.push({
           sessionName,
           lastOutputEpochSeconds: lastAssistantOutputEpochSeconds,
-          hasInProgressToolCall,
         });
       }
     }
     return activities;
   };
 
-  private readTranscriptActivity = (
+  private readLastAssistantOutputEpochSeconds = (
     transcriptPath: string,
-  ): TranscriptActivity => {
+  ): number | null => {
     let content: string;
     try {
       content = fs.readFileSync(transcriptPath, 'utf8');
     } catch {
-      return {
-        lastAssistantOutputEpochSeconds: null,
-        hasInProgressToolCall: false,
-      };
+      return null;
     }
     let lastAssistantOutputEpochMs: number | null = null;
-    const pendingToolUseIds = new Set<string>();
     for (const line of content.split('\n')) {
       const trimmed = line.trim();
       if (trimmed.length === 0) {
@@ -83,37 +63,15 @@ export class FileSystemSessionOutputActivityRepository implements SessionOutputA
       if (!isRecord(parsed)) {
         continue;
       }
-      const message = parsed.message;
       if (readString(parsed, 'type') === 'assistant') {
         const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
         if (epochMs !== null) {
           lastAssistantOutputEpochMs = epochMs;
         }
       }
-      if (!isRecord(message)) {
-        continue;
-      }
-      for (const block of readContentBlocks(message)) {
-        const blockType = readString(block, 'type');
-        if (blockType === 'tool_use') {
-          const toolUseId = readString(block, 'id');
-          if (toolUseId !== null) {
-            pendingToolUseIds.add(toolUseId);
-          }
-        } else if (blockType === 'tool_result') {
-          const toolUseId = readString(block, 'tool_use_id');
-          if (toolUseId !== null) {
-            pendingToolUseIds.delete(toolUseId);
-          }
-        }
-      }
     }
-    return {
-      lastAssistantOutputEpochSeconds:
-        lastAssistantOutputEpochMs === null
-          ? null
-          : Math.floor(lastAssistantOutputEpochMs / 1000),
-      hasInProgressToolCall: pendingToolUseIds.size > 0,
-    };
+    return lastAssistantOutputEpochMs === null
+      ? null
+      : Math.floor(lastAssistantOutputEpochMs / 1000);
   };
 }

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

@@ -0,0 +1,82 @@
+import { NodeProcessSignalRepository } from './NodeProcessSignalRepository';
+
+const errnoError = (message: string, code: string): NodeJS.ErrnoException => {
+  const error: NodeJS.ErrnoException = new Error(message);
+  error.code = code;
+  return error;
+};
+
+describe('NodeProcessSignalRepository', () => {
+  let repository: NodeProcessSignalRepository;
+  let killSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    repository = new NodeProcessSignalRepository();
+    jest.spyOn(console, 'error').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('isProcessAlive', () => {
+    it('returns true for the current process', () => {
+      expect(repository.isProcessAlive(process.pid)).toBe(true);
+    });
+
+    it('returns false for a pid that does not exist', () => {
+      killSpy = jest.spyOn(process, 'kill').mockImplementation(() => {
+        throw errnoError('no such process', 'ESRCH');
+      });
+
+      expect(repository.isProcessAlive(999999)).toBe(false);
+      expect(killSpy).toHaveBeenCalledWith(999999, 0);
+    });
+
+    it('returns true when signalling is not permitted', () => {
+      jest.spyOn(process, 'kill').mockImplementation(() => {
+        throw errnoError('operation not permitted', 'EPERM');
+      });
+
+      expect(repository.isProcessAlive(1)).toBe(true);
+    });
+  });
+
+  describe('terminateProcess', () => {
+    it('sends SIGTERM to the pid', () => {
+      killSpy = jest.spyOn(process, 'kill').mockReturnValue(true);
+
+      repository.terminateProcess(4242);
+
+      expect(killSpy).toHaveBeenCalledWith(4242, 'SIGTERM');
+    });
+
+    it('does not throw or log when the process already exited', () => {
+      jest.spyOn(process, 'kill').mockImplementation(() => {
+        throw errnoError('no such process', 'ESRCH');
+      });
+
+      expect(() => repository.terminateProcess(4242)).not.toThrow();
+      expect(console.error).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('killProcess', () => {
+    it('sends SIGKILL to the pid', () => {
+      killSpy = jest.spyOn(process, 'kill').mockReturnValue(true);
+
+      repository.killProcess(4242);
+
+      expect(killSpy).toHaveBeenCalledWith(4242, 'SIGKILL');
+    });
+
+    it('logs an unexpected signalling error without throwing', () => {
+      jest.spyOn(process, 'kill').mockImplementation(() => {
+        throw errnoError('operation not permitted', 'EPERM');
+      });
+
+      expect(() => repository.killProcess(4242)).not.toThrow();
+      expect(console.error).toHaveBeenCalled();
+    });
+  });
+});

package/src/adapter/repositories/NodeProcessSignalRepository.ts

@@ -0,0 +1,47 @@
+import { ProcessSignalRepository } from '../../domain/usecases/adapter-interfaces/ProcessSignalRepository';
+
+const errorCode = (error: unknown): string | null => {
+  if (
+    error !== null &&
+    typeof error === 'object' &&
+    'code' in error &&
+    typeof error.code === 'string'
+  ) {
+    return error.code;
+  }
+  return null;
+};
+
+export class NodeProcessSignalRepository implements ProcessSignalRepository {
+  isProcessAlive = (pid: number): boolean => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return errorCode(error) === 'EPERM';
+    }
+  };
+
+  terminateProcess = (pid: number): void => {
+    this.signal(pid, 'SIGTERM');
+  };
+
+  killProcess = (pid: number): void => {
+    this.signal(pid, 'SIGKILL');
+  };
+
+  private signal = (pid: number, signal: NodeJS.Signals): void => {
+    try {
+      process.kill(pid, signal);
+    } catch (error) {
+      if (errorCode(error) === 'ESRCH') {
+        return;
+      }
+      console.error(
+        `Failed to send ${signal} to pid ${pid}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  };
+}

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

@@ -294,4 +294,136 @@ describe('NodeTmuxSessionRepository', () => {
       ]);
     });
   });
+
+  describe('sendKeys', () => {
+    it('sends the literal text then Enter and stops when the composer is empty', async () => {
+      const runner = createMockRunner();
+      runner.runCommand
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({
+          stdout: 'idle pane content\n> ',
+          stderr: '',
+          exitCode: 0,
+        });
+      const repository = new NodeTmuxSessionRepository(runner, '/proc', 0);
+
+      await repository.sendKeys('session-a', 'checkpoint now');
+
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'send-keys',
+        '-t',
+        'session-a',
+        '-l',
+        'checkpoint now',
+      ]);
+      expect(runner.runCommand.mock.calls[1][1]).toEqual([
+        'send-keys',
+        '-t',
+        'session-a',
+        'Enter',
+      ]);
+      expect(runner.runCommand.mock.calls[2][1]).toEqual([
+        'capture-pane',
+        '-p',
+        '-t',
+        'session-a',
+      ]);
+      expect(runner.runCommand.mock.calls).toHaveLength(3);
+    });
+
+    it('re-sends Enter when the message is still visible in the composer', async () => {
+      const runner = createMockRunner();
+      runner.runCommand
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({
+          stdout: '> checkpoint now',
+          stderr: '',
+          exitCode: 0,
+        })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+      const repository = new NodeTmuxSessionRepository(runner, '/proc', 0);
+
+      await repository.sendKeys('session-a', 'checkpoint now');
+
+      expect(runner.runCommand.mock.calls).toHaveLength(4);
+      expect(runner.runCommand.mock.calls[3][1]).toEqual([
+        'send-keys',
+        '-t',
+        'session-a',
+        'Enter',
+      ]);
+    });
+
+    it('throws when sending the literal text fails', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: 'no session',
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner, '/proc', 0);
+
+      await expect(repository.sendKeys('session-a', 'text')).rejects.toThrow(
+        'Failed to send keys to tmux session "session-a"',
+      );
+    });
+  });
+
+  describe('launchBareNameLeaderSession', () => {
+    it('creates a detached tmux session running cl for the bare name', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.launchBareNameLeaderSession('app');
+
+      expect(runner.runCommand.mock.calls[0][0]).toBe('tmux');
+      expect(runner.runCommand.mock.calls[0][1]).toEqual([
+        'new-session',
+        '-d',
+        '-s',
+        'app',
+        'bash',
+        '-lc',
+        "cl 'app'; exec /bin/bash",
+      ]);
+    });
+
+    it('normalizes dots and colons in the session name', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await repository.launchBareNameLeaderSession('tdpm-cli.v2');
+
+      expect(runner.runCommand.mock.calls[0][1][3]).toBe('tdpm-cli_v2');
+      expect(runner.runCommand.mock.calls[0][1][6]).toBe(
+        "cl 'tdpm-cli.v2'; exec /bin/bash",
+      );
+    });
+
+    it('throws when tmux fails to create the session', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValue({
+        stdout: '',
+        stderr: 'duplicate session',
+        exitCode: 1,
+      });
+      const repository = new NodeTmuxSessionRepository(runner);
+
+      await expect(
+        repository.launchBareNameLeaderSession('app'),
+      ).rejects.toThrow('Failed to relaunch bare-name leader session "app"');
+    });
+  });
 });

package/src/adapter/repositories/NodeTmuxSessionRepository.ts

@@ -6,10 +6,18 @@ import { LiveTmuxSession } from '../../domain/entities/LiveTmuxSession';
 import { clSessionScopeUnitName } from './clSessionScopeUnitName';
 import { clSessionScopeUnitNameFromCgroupContent } from './clSessionScopeUnitNameFromCgroupContent';
 
+const DEFAULT_SEND_KEYS_SUBMIT_DELAY_MS = 1000;
+const SEND_KEYS_COMPOSER_PROBE_LENGTH = 40;
+const SEND_KEYS_COMPOSER_TAIL_LINES = 8;
+
+const shellSingleQuote = (value: string): string =>
+  `'${value.replace(/'/g, `'\\''`)}'`;
+
 export class NodeTmuxSessionRepository implements TmuxSessionRepository {
   constructor(
     private readonly localCommandRunner: LocalCommandRunner,
     private readonly procDirectory: string = '/proc',
+    private readonly submitDelayMilliseconds: number = DEFAULT_SEND_KEYS_SUBMIT_DELAY_MS,
   ) {}
 
   listLiveSessionNames = async (): Promise<string[]> => {
@@ -134,4 +142,96 @@ export class NodeTmuxSessionRepository implements TmuxSessionRepository {
       );
     }
   };
+
+  sendKeys = async (
+    sessionName: string,
+    literalText: string,
+  ): Promise<void> => {
+    const literalResult = await this.localCommandRunner.runCommand('tmux', [
+      'send-keys',
+      '-t',
+      sessionName,
+      '-l',
+      literalText,
+    ]);
+    if (literalResult.exitCode !== 0) {
+      throw new Error(
+        `Failed to send keys to tmux session "${sessionName}": exit code ${literalResult.exitCode}${
+          literalResult.stderr ? `: ${literalResult.stderr}` : ''
+        }`,
+      );
+    }
+    await this.delaySubmit();
+    await this.sendEnter(sessionName);
+    if (await this.messageStillInComposer(sessionName, literalText)) {
+      await this.delaySubmit();
+      await this.sendEnter(sessionName);
+    }
+  };
+
+  launchBareNameLeaderSession = async (name: string): Promise<void> => {
+    const sessionName = name.replace(/[.:]/g, '_');
+    const leaderCommand = `cl ${shellSingleQuote(name)}; exec /bin/bash`;
+    const { stderr, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['new-session', '-d', '-s', sessionName, 'bash', '-lc', leaderCommand],
+    );
+    if (exitCode !== 0) {
+      throw new Error(
+        `Failed to relaunch bare-name leader session "${sessionName}": exit code ${exitCode}${
+          stderr ? `: ${stderr}` : ''
+        }`,
+      );
+    }
+  };
+
+  private sendEnter = async (sessionName: string): Promise<void> => {
+    const enterResult = await this.localCommandRunner.runCommand('tmux', [
+      'send-keys',
+      '-t',
+      sessionName,
+      'Enter',
+    ]);
+    if (enterResult.exitCode !== 0) {
+      throw new Error(
+        `Failed to send Enter to tmux session "${sessionName}": exit code ${enterResult.exitCode}${
+          enterResult.stderr ? `: ${enterResult.stderr}` : ''
+        }`,
+      );
+    }
+  };
+
+  private messageStillInComposer = async (
+    sessionName: string,
+    literalText: string,
+  ): Promise<boolean> => {
+    const probe = literalText
+      .trim()
+      .split('\n', 1)[0]
+      .slice(0, SEND_KEYS_COMPOSER_PROBE_LENGTH);
+    if (probe.length === 0) {
+      return false;
+    }
+    const { stdout, exitCode } = await this.localCommandRunner.runCommand(
+      'tmux',
+      ['capture-pane', '-p', '-t', sessionName],
+    );
+    if (exitCode !== 0) {
+      return false;
+    }
+    const tail = stdout
+      .split('\n')
+      .slice(-SEND_KEYS_COMPOSER_TAIL_LINES)
+      .join('\n');
+    return tail.includes(probe);
+  };
+
+  private delaySubmit = async (): Promise<void> => {
+    if (this.submitDelayMilliseconds <= 0) {
+      return;
+    }
+    await new Promise((resolve) =>
+      setTimeout(resolve, this.submitDelayMilliseconds),
+    );
+  };
 }