deepdebug-local-agent 1.0.21 → 1.0.23

package/test/adapters/as400/as400.test.js

@@ -0,0 +1,121 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { As400LogAdapter } from '../../../src/adapters/as400/index.js';
+import { AS400_MSGID_REGEX } from '../../../src/adapters/as400/as400-parser.js';
+
+// Stub ssh2.Client — supports .connect(), .exec(callback), .on('close'/'error'/'ready'), .end()
+class StubSshClient extends EventEmitter {
+  constructor() {
+    super();
+    this.connectCalls = [];
+    this.execCalls = [];
+    this._channels = [];
+    this._cannedOutput = '';
+  }
+  connect(opts) {
+    this.connectCalls.push(opts);
+    // emit 'ready' on next tick
+    process.nextTick(() => this.emit('ready'));
+  }
+  exec(cmd, cb) {
+    this.execCalls.push(cmd);
+    const stream = new EventEmitter();
+    stream.stderr = new EventEmitter();
+    process.nextTick(() => {
+      cb(null, stream);
+      // Push canned output then close.
+      stream.emit('data', Buffer.from(this._cannedOutput || ''));
+      stream.emit('close', 0);
+    });
+    this._channels.push(stream);
+  }
+  end() {
+    process.nextTick(() => this.emit('close'));
+  }
+  setCannedOutput(text) { this._cannedOutput = text; }
+}
+
+describe('As400LogAdapter', () => {
+  test('constructor sets keepalive defaults (T-2-02)', () => {
+    const adapter = new As400LogAdapter({ host: '1.2.3.4', username: 'u', password: 'p' });
+    assert.equal(adapter._sshOpts.keepaliveInterval, 30000);
+    assert.equal(adapter._sshOpts.keepaliveCountMax, 3);
+  });
+
+  test('emits 6-key event for CPF/MCH/SQL lines (AC-2)', async () => {
+    const stub = new StubSshClient();
+    stub.setCannedOutput([
+      'CPF1234 ERROR Job DAILY01 ended abnormally',
+      'INFO  This line should not match',
+      'MCH3601 Pointer not set for location *N',
+      ''
+    ].join('\n'));
+    const adapter = new As400LogAdapter({
+      host: '1.2.3.4', username: 'u', password: 'p',
+      pollInterval: 100, sshClientFactory: () => stub,
+    });
+    const events = [];
+    adapter.on('error', (e) => events.push(e));
+    await adapter.start();
+    await sleep(400);
+    await adapter.stop();
+    assert.ok(events.length >= 2, `expected 2 events, got ${events.length}`);
+    const e = events[0];
+    assert.equal(Object.keys(e).sort().join(','), 'adapter,errorCode,file,message,source,timestamp');
+    assert.equal(e.adapter, 'as400');
+    assert.match(e.errorCode, /^(CPF|MCH|SQL)\d{4}$/);
+  });
+
+  test('non-matching lines do not emit', async () => {
+    const stub = new StubSshClient();
+    stub.setCannedOutput('INFO Just an info line\nDEBUG diag\n');
+    const adapter = new As400LogAdapter({
+      host: '1.2.3.4', username: 'u', password: 'p',
+      pollInterval: 100, sshClientFactory: () => stub,
+    });
+    const events = [];
+    adapter.on('error', (e) => events.push(e));
+    await adapter.start();
+    await sleep(400);
+    await adapter.stop();
+    assert.equal(events.length, 0);
+  });
+
+  test('reconnect on close with exponential backoff (T-2-02)', async () => {
+    const factories = [];
+    const adapter = new As400LogAdapter({
+      host: '1.2.3.4', username: 'u', password: 'p',
+      pollInterval: 60000, // no poll churn
+      sshClientFactory: () => { const s = new StubSshClient(); factories.push(s); return s; },
+      backoffSchedule: [50, 100, 200], // shortened for test
+    });
+    await adapter.start();
+    await sleep(50);
+    // First client connected; force a close.
+    assert.ok(factories.length >= 1);
+    factories[0].emit('close');
+    await sleep(200); // wait for first backoff (50ms) to fire reconnect
+    assert.ok(factories.length >= 2, 'reconnect must spawn a second client after close');
+    await adapter.stop();
+  });
+
+  test('lifecycle idempotent (AC-1)', async () => {
+    const stub = new StubSshClient();
+    const adapter = new As400LogAdapter({
+      host: '1.2.3.4', username: 'u', password: 'p',
+      pollInterval: 60000, sshClientFactory: () => stub,
+    });
+    await adapter.start();
+    await adapter.start();
+    await adapter.stop();
+    await adapter.stop();
+  });
+
+  test('parser regex exported and isolated', () => {
+    assert.ok(AS400_MSGID_REGEX instanceof RegExp);
+    assert.ok('CPF1234 ...'.match(AS400_MSGID_REGEX));
+    assert.equal('INFO ...'.match(AS400_MSGID_REGEX), null);
+  });
+});

package/test/adapters/cobol/cobol.test.js

@@ -0,0 +1,217 @@
+// test/adapters/cobol/cobol.test.js
+// Plan 02-11 contract tests for CobolLogAdapter.
+// 10 tests covering AC-1/2/3/9/10, AD-6 CRLF tolerance + 80-col fixed-width
+// preservation, multi-pattern parser (S0C7, SQLCODE, IEF, FILE STATUS),
+// and parser-isolation surface.
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  writeFileSync,
+  appendFileSync,
+  truncateSync,
+  mkdtempSync,
+  rmSync,
+  openSync,
+  writeSync,
+  closeSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { CobolLogAdapter } from '../../../src/adapters/cobol/index.js';
+import {
+  COBOL_COMPLETION_REGEX,
+  COBOL_SQLCODE_REGEX,
+  COBOL_IEF_REGEX,
+  COBOL_FILE_STATUS_REGEX,
+} from '../../../src/adapters/cobol/cobol-parser.js';
+
+function tempDir() {
+  return mkdtempSync(join(tmpdir(), 'cobol-test-'));
+}
+
+async function awaitEvents(adapter, n, timeoutMs = 12000) {
+  const events = [];
+  return new Promise((resolve) => {
+    const onErr = (e) => {
+      events.push(e);
+      if (events.length >= n) {
+        adapter.off('error', onErr);
+        resolve(events);
+      }
+    };
+    adapter.on('error', onErr);
+    const t = setTimeout(() => {
+      adapter.off('error', onErr);
+      resolve(events);
+    }, timeoutMs);
+    t.unref?.();
+  });
+}
+
+describe('CobolLogAdapter', () => {
+  test('TAIL default — pre-existing not emitted (AC-9)', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'spool1.txt'), 'SYSTEM COMPLETION CODE=0C7  pre-existing\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits S0C7 event with 6-key alphabetical-sorted shape (AC-2)', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(f, '  SYSTEM COMPLETION CODE=0C7  REASON CODE=00000007\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.equal(events.length, 1);
+    assert.equal(
+      Object.keys(events[0]).sort().join(','),
+      'adapter,errorCode,file,message,source,timestamp',
+    );
+    assert.equal(events[0].adapter, 'cobol');
+    assert.equal(events[0].errorCode, 'S0C7');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits SQLCODE -805 event', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(
+      f,
+      'DSNT408I SQLCODE = -805, ERROR: DBRM OR PACKAGE NAME PROD.CUSTUPD NOT FOUND IN PLAN\n',
+    );
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    assert.equal(events[0].errorCode, '-805');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits FILE STATUS 35 event', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(f, "IGZ0035S - FILE STATUS 35 - File 'CUSTIN' was not found.\n");
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    assert.match(events[0].errorCode, /^(FILE_STATUS_35|IGZ0035S)$/);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('CRLF line endings tolerated (AD-6 z/OS spool trap)', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\r\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    const fd = openSync(f, 'a');
+    const buf = Buffer.from(
+      '  SYSTEM COMPLETION CODE=0C7  REASON CODE=00000007\r\n',
+      'utf8',
+    );
+    writeSync(fd, buf, 0, buf.length);
+    closeSync(fd);
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    assert.equal(events[0].errorCode, 'S0C7');
+    // \r artifact must NOT appear in event.message
+    assert.equal(
+      events[0].message.includes('\r'),
+      false,
+      'event.message must not contain raw \\r artifact',
+    );
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('80-col padded ABEND header preserves column-1 control char (AD-6 fixed-width trap)', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'header\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    // Line begins with column-1 '0' (page-eject control char), padded to 80 cols
+    const line =
+      '0SYSTEM COMPLETION CODE=0C7  REASON CODE=00000007                               ';
+    assert.equal(line.length, 80);
+    appendFileSync(f, line + '\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    // message should retain the leading '0' control char
+    assert.equal(
+      events[0].message[0],
+      '0',
+      'column-1 control char must not be trimmed',
+    );
+    assert.equal(events[0].errorCode, 'S0C7');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('lifecycle idempotent — start/start/stop/stop (AC-1)', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'spool1.txt'), '');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await adapter.start();
+    await adapter.stop();
+    await adapter.stop();
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('rotation — truncate + append (AC-10)', async () => {
+    const root = tempDir();
+    const f = join(root, 'spool1.txt');
+    writeFileSync(f, 'old\n');
+    const adapter = new CobolLogAdapter({ spoolDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    truncateSync(f, 0);
+    await sleep(400);
+    appendFileSync(f, 'SYSTEM COMPLETION CODE=0C7\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('ENOENT silent — nonexistent spoolDir does not throw', async () => {
+    const adapter = new CobolLogAdapter({
+      spoolDir: '/nonexistent-' + Date.now(),
+      interval: 200,
+    });
+    await adapter.start();
+    await sleep(500);
+    await adapter.stop();
+  });
+
+  test('parser regexes isolated and exported as named consts', () => {
+    assert.ok(COBOL_COMPLETION_REGEX instanceof RegExp);
+    assert.ok(COBOL_SQLCODE_REGEX instanceof RegExp);
+    assert.ok(COBOL_IEF_REGEX instanceof RegExp);
+    assert.ok(COBOL_FILE_STATUS_REGEX instanceof RegExp);
+    assert.ok('SYSTEM COMPLETION CODE=0C7'.match(COBOL_COMPLETION_REGEX));
+    assert.ok('SQLCODE = -805'.match(COBOL_SQLCODE_REGEX));
+    assert.ok('IEF450I DAILY01 STEP01 - ABEND'.match(COBOL_IEF_REGEX));
+    assert.ok('FILE STATUS 35'.match(COBOL_FILE_STATUS_REGEX));
+  });
+});

package/test/adapters/ibmmq/ibmmq.test.js

@@ -0,0 +1,122 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { writeFileSync, appendFileSync, truncateSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { IbmMqLogAdapter } from '../../../src/adapters/ibmmq/index.js';
+import { IBMMQ_AMQ_REGEX } from '../../../src/adapters/ibmmq/ibmmq-parser.js';
+
+function tempErrorsDir() {
+  return mkdtempSync(join(tmpdir(), 'ibmmq-test-'));
+}
+
+async function awaitEvents(adapter, n, timeoutMs = 12000) {
+  const events = [];
+  return new Promise((resolve) => {
+    const onErr = (e) => {
+      events.push(e);
+      if (events.length >= n) {
+        adapter.off('error', onErr);
+        resolve(events);
+      }
+    };
+    adapter.on('error', onErr);
+    setTimeout(() => { adapter.off('error', onErr); resolve(events); }, timeoutMs);
+  });
+}
+
+describe('IbmMqLogAdapter', () => {
+  test('TAIL default — pre-existing not emitted (AC-9)', async () => {
+    const root = tempErrorsDir();
+    writeFileSync(join(root, 'AMQERR01.LOG'), 'AMQ7472W: pre-existing line\n');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0, 'no events should fire for pre-existing content');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits 6-key event on AMQERR line (AC-2)', async () => {
+    const root = tempErrorsDir();
+    const f = join(root, 'AMQERR01.LOG');
+    writeFileSync(f, '-- start --\n');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(f, 'AMQ7472W: Object Q.ORDER.IN, type queue, get returned 2033 (MQRC_NO_MSG_AVAILABLE).\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.equal(events.length, 1);
+    assert.equal(Object.keys(events[0]).sort().join(','), 'adapter,errorCode,file,message,source,timestamp');
+    assert.equal(events[0].adapter, 'ibmmq');
+    assert.equal(events[0].errorCode, 'AMQ7472W');
+    assert.equal(events[0].file, f);
+    assert.match(events[0].message, /AMQ7472W/);
+    assert.equal(events[0].source, root);
+    assert.match(events[0].timestamp, /^\d{4}-\d{2}-\d{2}T/);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('lifecycle idempotent (AC-1)', async () => {
+    const root = tempErrorsDir();
+    writeFileSync(join(root, 'AMQERR01.LOG'), '');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    await adapter.start(); // idempotent
+    await adapter.stop();
+    await adapter.stop(); // idempotent
+    await adapter.start();
+    await adapter.stop();
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('rotation: truncate + append (AC-10)', async () => {
+    const root = tempErrorsDir();
+    const f = join(root, 'AMQERR01.LOG');
+    writeFileSync(f, 'AMQ0000I: old\n');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    truncateSync(f, 0);
+    await sleep(400);
+    appendFileSync(f, 'AMQ9540E: queue manager name error.\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1, 'rotation should produce at least 1 event');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('ENOENT silent — no event, no throw', async () => {
+    const adapter = new IbmMqLogAdapter({ errorsDir: '/nonexistent-' + Date.now(), interval: 200 });
+    await adapter.start();
+    await sleep(500);
+    await adapter.stop();
+  });
+
+  test('parser regex exported and isolated', () => {
+    assert.ok(IBMMQ_AMQ_REGEX instanceof RegExp);
+    const m = 'AMQ7472W: Object ...'.match(IBMMQ_AMQ_REGEX);
+    assert.ok(m);
+    assert.equal(m[1], 'AMQ7472W');
+  });
+
+  test('glob anchored — AMQERR04.LOG not watched', async () => {
+    const root = tempErrorsDir();
+    // Create AMQERR04.LOG (NOT in 01..03 range) and a random file
+    const out = join(root, 'AMQERR04.LOG');
+    const random = join(root, 'random.log');
+    writeFileSync(out, '');
+    writeFileSync(random, '');
+    const adapter = new IbmMqLogAdapter({ errorsDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(out, 'AMQ9999E: should not be emitted\n');
+    appendFileSync(random, 'AMQ9999E: should not be emitted\n');
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0, 'adapter must not watch outside AMQERR0[1-3].LOG glob');
+    rmSync(root, { recursive: true, force: true });
+  });
+});

package/test/adapters/oracle-forms/oracle-forms.test.js

@@ -0,0 +1,180 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  writeFileSync,
+  appendFileSync,
+  truncateSync,
+  mkdtempSync,
+  rmSync,
+  openSync,
+  writeSync,
+  closeSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { OracleFormsLogAdapter } from '../../../src/adapters/oracle-forms/index.js';
+import { ORACLE_FORMS_REGEX } from '../../../src/adapters/oracle-forms/oracle-forms-parser.js';
+
+function tempDir() {
+  return mkdtempSync(join(tmpdir(), 'forms-test-'));
+}
+
+async function awaitEvents(adapter, n, timeoutMs = 12000) {
+  const events = [];
+  return new Promise((resolve) => {
+    const onErr = (e) => {
+      events.push(e);
+      if (events.length >= n) {
+        adapter.off('error', onErr);
+        resolve(events);
+      }
+    };
+    adapter.on('error', onErr);
+    const t = setTimeout(() => {
+      adapter.off('error', onErr);
+      resolve(events);
+    }, timeoutMs);
+    t.unref?.();
+  });
+}
+
+describe('OracleFormsLogAdapter', () => {
+  test('TAIL default — pre-existing not emitted (AC-9)', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'forms.trc'), 'Line 1: ORA-01403: no data found\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits 6-key event for ORA line (AC-2)', async () => {
+    const root = tempDir();
+    const f = join(root, 'forms.trc');
+    writeFileSync(f, 'header\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(f, 'Line 44: ORA-01403: no data found\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.equal(events.length, 1);
+    assert.equal(
+      Object.keys(events[0]).sort().join(','),
+      'adapter,errorCode,file,message,source,timestamp',
+    );
+    assert.equal(events[0].adapter, 'oracle-forms');
+    assert.equal(events[0].errorCode, 'ORA-01403');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('emits FRM event', async () => {
+    const root = tempDir();
+    const f = join(root, 'forms.trc');
+    writeFileSync(f, 'header\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(
+      f,
+      'Line 89: FRM-40735: ON-ERROR trigger raised unhandled exception ORA-20100.\n',
+    );
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.equal(events.length, 1);
+    assert.equal(events[0].errorCode, 'FRM-40735');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('Latin-1 bytes do not crash adapter (AD-6 mojibake trap)', async () => {
+    const root = tempDir();
+    const f = join(root, 'forms.trc');
+    writeFileSync(f, 'header\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    // Append Latin-1 bytes including 0xE9 ("é"): "Line 102: ORA-06502: Café\n"
+    const fd = openSync(f, 'a');
+    const latin1 = Buffer.from([
+      0x4c, 0x69, 0x6e, 0x65, 0x20, 0x31, 0x30, 0x32, 0x3a, 0x20, 0x4f, 0x52,
+      0x41, 0x2d, 0x30, 0x36, 0x35, 0x30, 0x32, 0x3a, 0x20, 0x43, 0x61, 0x66,
+      0xe9, 0x0a,
+    ]);
+    writeSync(fd, latin1, 0, latin1.length);
+    closeSync(fd);
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(
+      events.length >= 1,
+      'adapter should not crash on Latin-1 byte; should still emit ORA-06502',
+    );
+    assert.equal(events[0].errorCode, 'ORA-06502');
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('lifecycle idempotent (AC-1)', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'forms.trc'), '');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await adapter.start();
+    await adapter.stop();
+    await adapter.stop();
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('rotation: truncate + append (AC-10)', async () => {
+    const root = tempDir();
+    const f = join(root, 'forms.trc');
+    writeFileSync(f, 'Line 1: OLD ORA-99999: stale\n');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    truncateSync(f, 0);
+    await sleep(400);
+    appendFileSync(f, 'Line 1: ORA-01403: no data found\n');
+    const events = await awaitEvents(adapter, 1, 5000);
+    await adapter.stop();
+    assert.ok(events.length >= 1);
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test('ENOENT silent', async () => {
+    const adapter = new OracleFormsLogAdapter({
+      traceDir: '/nonexistent-' + Date.now(),
+      interval: 200,
+    });
+    await adapter.start();
+    await sleep(500);
+    await adapter.stop();
+  });
+
+  test('parser regex isolated', () => {
+    assert.ok(ORACLE_FORMS_REGEX instanceof RegExp);
+    const m1 = 'Line 44: ORA-01403: no data found'.match(ORACLE_FORMS_REGEX);
+    assert.ok(m1);
+    assert.equal(m1[1], 'ORA-01403');
+    const m2 = 'Line 89: FRM-40735: ON-ERROR ...'.match(ORACLE_FORMS_REGEX);
+    assert.ok(m2);
+    assert.equal(m2[1], 'FRM-40735');
+  });
+
+  test('glob anchored — *.log not watched', async () => {
+    const root = tempDir();
+    writeFileSync(join(root, 'other.log'), '');
+    const adapter = new OracleFormsLogAdapter({ traceDir: root, interval: 200 });
+    await adapter.start();
+    await sleep(400);
+    appendFileSync(
+      join(root, 'other.log'),
+      'Line 1: ORA-01403: should not be emitted\n',
+    );
+    const events = await awaitEvents(adapter, 1, 1500);
+    await adapter.stop();
+    assert.equal(events.length, 0);
+    rmSync(root, { recursive: true, force: true });
+  });
+});