@saifymatteo/pi-extensions 0.1.4 → 0.1.6

package/packages/pi-bg-bash/test/process-control.test.mjs

@@ -0,0 +1,300 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { loadExtension } from '../../../test/load-extension.mjs';
+
+const file = new URL('../src/lib/process-control.ts', import.meta.url);
+const birth = 'Mon Jan 5 12:00:00 2026 UTC';
+const later = 'Mon Jan 5 12:00:01 2026 UTC';
+const winBirth = '2026-01-05T12:00:00.0000000Z';
+const winLater = '2026-01-05T12:00:01.0000000Z';
+
+function fixture({ windows = false, onRead, onSignal, onWait, output, commandError, consoleError } = {}) {
+  const started = windows ? winBirth : birth;
+  const rows = new Map([
+    [900, { pid: 900, ppid: 1, started }], // fake harness
+    [100, { pid: 100, ppid: 1, started }],
+    [101, { pid: 101, ppid: 100, started }],
+    [102, { pid: 102, ppid: 101, started }],
+    [500, { pid: 500, ppid: 1, started }], // unrelated
+  ]);
+  const calls = [], signals = [], waits = [];
+  let reads = 0;
+  const emitSignal = (pid, signal) => {
+    signals.push([pid, signal]);
+    if (onSignal) onSignal({ pid, signal, force: signal === 'SIGKILL', rows });
+    else if (signal === 'SIGKILL') rows.delete(pid);
+  };
+  const fakeProcess = {
+    platform: windows ? 'win32' : 'linux', pid: 900, env: {},
+    kill(pid, signal) {
+      assert.equal(windows, false, 'Windows must not emulate graceful signals with process.kill');
+      assert.ok(pid > 1 && pid !== 900);
+      emitSignal(pid, signal);
+    },
+  };
+  const api = loadExtension(file, {
+    'node:process': fakeProcess,
+    './windows-console': { windowsConsoleInterruptScript: (root, targets, ownerPid) =>
+      '# PI_BG_CONSOLE\n' + JSON.stringify({ root, targets, ownerPid }) },
+    'node:child_process': {
+      execFile(command, args, options, callback) {
+        calls.push({ command, args, options });
+        try {
+          if (commandError) throw commandError;
+          const script = args.at(-1);
+          if (windows && script.includes('# PI_BG_CONSOLE')) {
+            if (consoleError) throw consoleError;
+            const { targets, ownerPid } = JSON.parse(script.split('# PI_BG_CONSOLE\n')[1]);
+            assert.equal(ownerPid, 900);
+            for (const target of targets.reverse()) {
+              if (rows.get(target.pid)?.started === target.started) emitSignal(target.pid, 'SIGINT');
+            }
+            callback(null, '', '');
+            return;
+          }
+          if (windows && script.includes('-ceq')) {
+            for (const match of script.matchAll(/GetProcessById\((\d+)\)[\s\S]*?-ceq '([^']+)'/g)) {
+              const pid = Number(match[1]);
+              if (rows.get(pid)?.started.replace(/(\.\d{6})\dZ$/, '$1Z') === match[2]) emitSignal(pid, 'SIGKILL');
+            }
+            callback(null, '', '');
+            return;
+          }
+          reads++;
+          onRead?.({ reads, rows });
+          const text = output ?? (windows ? JSON.stringify([...rows.values()]) : [...rows.values()].map(row =>
+            `${row.pid} ${row.ppid} ${row.started.replace(/ UTC$/, '')} ${row.dead ? 'Z' : 'S'}`).join('\n'));
+          callback(null, text, '');
+        } catch (error) { callback(error, '', ''); }
+      },
+    },
+  }, {
+    process: fakeProcess,
+    setTimeout(callback, ms) {
+      waits.push(ms);
+      onWait?.({ ms, rows });
+      queueMicrotask(callback);
+      return waits.length;
+    },
+  });
+  return { ...api, rows, calls, signals, waits, identity: { pid: 100, started } };
+}
+
+for (const windows of [false, true]) {
+  const platform = windows ? 'Windows' : 'Unix';
+  test(`${platform}: captures birth identity; validates PID, identity and mode before OS calls`, async () => {
+    const f = fixture({ windows });
+    for (const pid of [0, 1, -10, 900, 1.5, NaN, Infinity, '100']) {
+      await assert.rejects(f.captureProcess(pid), /Unsafe/);
+      await assert.rejects(f.stopProcessTree({ pid, started: birth }), /Unsafe/);
+    }
+    await assert.rejects(f.stopProcessTree({ pid: 100, started: '' }), /identity/);
+    await assert.rejects(f.stopProcessTree(f.identity, 'auto'), /mode/);
+    assert.equal(f.calls.length, 0);
+    const controller = new AbortController();
+    assert.deepEqual({ ...await f.captureProcess(100, controller.signal) }, f.identity);
+    assert.equal(f.calls[0].options.signal, controller.signal);
+    await assert.rejects(f.captureProcess(333), /gone/);
+    assert.equal(f.signals.length, 0);
+  });
+
+  test(`${platform}: distinct force action skips grace and kills only the captured tree`, async () => {
+    const f = fixture({ windows });
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stopped');
+    assert.deepEqual(f.signals, [[102, 'SIGKILL'], [101, 'SIGKILL'], [100, 'SIGKILL']]);
+    assert.deepEqual(f.waits, [100]);
+    assert.equal(f.rows.has(500), true);
+    for (const call of f.calls) {
+      assert.ok(Array.isArray(call.args));
+      assert.equal(call.options.timeout, 15000);
+      assert.equal(call.options.env.LC_ALL, 'C');
+      assert.equal(call.options.shell, undefined);
+    }
+    if (windows) {
+      const scripts = f.calls.map(call => call.args.at(-1));
+      assert.equal(scripts.filter(script => script.includes('GetProcessById')).length, 1);
+      assert.equal(scripts.filter(script => script.includes('CreationDate')).length, 2, 'discovery and final verification only');
+      assert.ok(scripts.some(script => script.includes('$p.Kill()') && script.includes('$p.Handle')));
+      assert.ok(scripts.every(script => !/CloseMainWindow|taskkill|Stop-Process|\/T|node\.exe/.test(script)));
+    } else {
+      assert.deepEqual(Array.from(f.calls[0].args), ['-A', '-o', 'pid=', '-o', 'ppid=', '-o', 'lstart=', '-o', 'stat=']);
+      assert.equal(f.calls[0].command, 'ps');
+    }
+  });
+
+  test(`${platform}: distinct graceful action interrupts but never escalates survivors`, async () => {
+    const f = fixture({ windows });
+    assert.equal(await f.stopProcessTree(f.identity, 'graceful'), 'stuck');
+    assert.deepEqual(f.signals, [[102, 'SIGINT'], [101, 'SIGINT'], [100, 'SIGINT']]);
+    assert.deepEqual(f.waits, [3000]);
+    assert.equal(f.rows.has(100), true);
+    assert.equal(f.rows.has(500), true);
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stopped');
+    assert.equal(f.rows.has(102), false);
+  });
+
+  test(`${platform}: retry reports already gone when all previously retained processes exited naturally`, async () => {
+    const f = fixture({ windows });
+    assert.equal(await f.stopProcessTree(f.identity, 'graceful'), 'stuck');
+    for (const pid of [100, 101, 102]) f.rows.delete(pid);
+    f.signals.length = 0;
+    f.waits.length = 0;
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'gone');
+    assert.deepEqual(f.signals, []);
+    assert.deepEqual(f.waits, []);
+  });
+
+  test(`${platform}: cooperative graceful exit is verified without force`, async () => {
+    const f = fixture({ windows, onSignal({ pid, signal, rows }) {
+      assert.equal(signal, 'SIGINT');
+      rows.delete(pid);
+    } });
+    assert.equal(await f.stopProcessTree(f.identity, 'graceful'), 'stopped');
+    assert.equal(f.signals.length, 3);
+  });
+
+  test(`${platform}: absent/reused root receives no signal`, async () => {
+    for (const reused of [false, true]) {
+      const f = fixture({ windows });
+      if (reused) f.rows.get(100).started = windows ? winLater : later;
+      else f.rows.delete(100);
+      assert.equal(await f.stopProcessTree(f.identity), 'gone');
+      assert.deepEqual(f.signals, []);
+    }
+  });
+
+  test(`${platform}: launch capture retains known children even if the launcher exits before any stop`, async () => {
+    const f = fixture({ windows });
+    const captured = await f.captureProcess(100);
+    f.rows.delete(100);
+    f.rows.get(101).ppid = 1;
+    assert.equal(await f.stopProcessTree(captured, 'force'), 'stopped');
+    assert.deepEqual(f.signals, [[102, 'SIGKILL'], [101, 'SIGKILL']]);
+    assert.equal(f.rows.has(500), true);
+  });
+
+  test(`${platform}: retains reparented children after graceful launcher exit for force retry`, async () => {
+    const f = fixture({ windows, onSignal({ pid, force, rows }) {
+      if (force || pid === 100) rows.delete(pid);
+      if (pid === 100 && !force) rows.get(101).ppid = 1;
+    } });
+    assert.equal(await f.stopProcessTree(f.identity, 'graceful'), 'stuck');
+    assert.equal(f.rows.has(100), false);
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stopped');
+    assert.deepEqual(f.signals.filter(([, signal]) => signal === 'SIGKILL'), [[102, 'SIGKILL'], [101, 'SIGKILL']]);
+  });
+
+  test(`${platform}: records late verified descendants for retry even after reparenting`, async () => {
+    const f = fixture({ windows, onWait({ ms, rows }) {
+      if (ms === 3000) rows.set(103, { pid: 103, ppid: 102, started: windows ? winLater : later });
+    } });
+    assert.equal(await f.stopProcessTree(f.identity, 'graceful'), 'stuck');
+    f.rows.delete(100);
+    f.rows.get(101).ppid = 1;
+    f.rows.get(103).ppid = 1;
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stopped');
+    assert.ok(f.signals.some(([pid, signal]) => pid === 103 && signal === 'SIGKILL'));
+  });
+
+  test(`${platform}: never adopts a reused descendant or its new children`, async () => {
+    const f = fixture({ windows });
+    assert.equal(await f.stopProcessTree(f.identity, 'graceful'), 'stuck');
+    f.rows.get(101).started = windows ? winLater : later;
+    f.rows.get(101).ppid = 1;
+    f.rows.set(103, { pid: 103, ppid: 101, started: windows ? winLater : later });
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stuck');
+    assert.ok(!f.signals.some(([pid, signal]) => [101, 103].includes(pid) && signal === 'SIGKILL'));
+  });
+
+  test(`${platform}: unverified descendants after force remain untouched and report incomplete cleanup`, async () => {
+    const f = fixture({ windows, onWait({ rows }) {
+      rows.set(103, { pid: 103, ppid: 100, started: windows ? winLater : later });
+    } });
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stuck');
+    assert.ok(!f.signals.some(([pid]) => pid === 103));
+  });
+
+  test(`${platform}: unsafe descendants and incomplete inventories fail before signaling`, async () => {
+    const f = fixture({ windows });
+    f.rows.get(900).ppid = 101;
+    await assert.rejects(f.stopProcessTree(f.identity), /Unsafe/);
+    assert.deepEqual(f.signals, []);
+    f.rows.delete(900);
+    await assert.rejects(f.stopProcessTree(f.identity), /Incomplete/);
+  });
+
+  test(`${platform}: enumeration failures are errors, not absence`, async () => {
+    const f = fixture({ windows, commandError: Object.assign(new Error('permission denied'), { code: 'EPERM' }) });
+    await assert.rejects(f.captureProcess(100), /permission denied/);
+    await assert.rejects(f.stopProcessTree(f.identity), /permission denied/);
+    assert.deepEqual(f.signals, []);
+  });
+
+  test(`${platform}: failed force retains authenticated children when only launcher exits`, async () => {
+    let allowChildren = false;
+    const f = fixture({ windows, onSignal({ pid, rows }) {
+      if (pid === 100 || allowChildren) rows.delete(pid);
+      if (pid === 100) rows.get(101).ppid = 1;
+    } });
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stuck');
+    allowChildren = true;
+    assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stopped');
+    assert.equal(f.rows.has(500), true);
+  });
+}
+
+test('Unix: revalidates each identity immediately before killing', async () => {
+  const f = fixture({ onRead({ reads, rows }) {
+    if (reads === 2) { rows.get(102).started = later; rows.get(102).ppid = 1; }
+  } });
+  assert.equal(await f.stopProcessTree(f.identity), 'stopped');
+  assert.ok(!f.signals.some(([pid]) => pid === 102));
+});
+
+test('Unix: EPERM rejects; ESRCH races are verified with the final inventory', async () => {
+  for (const code of ['EPERM', 'ESRCH']) {
+    const f = fixture({ onSignal({ pid, rows }) {
+      if (code === 'ESRCH') rows.delete(pid);
+      throw Object.assign(new Error(code), { code });
+    } });
+    if (code === 'EPERM') await assert.rejects(f.stopProcessTree(f.identity), /EPERM/);
+    else assert.equal(await f.stopProcessTree(f.identity), 'stopped');
+  }
+});
+
+test('Unix: zombies are gone; malformed inventory fails closed', async () => {
+  const f = fixture();
+  f.rows.get(100).dead = true;
+  assert.equal(await f.stopProcessTree(f.identity), 'gone');
+  await assert.rejects(f.captureProcess(100), /gone/);
+  const malformed = fixture({ output: '100 1 invalid birth' });
+  await assert.rejects(malformed.stopProcessTree(malformed.identity), /Invalid ps/);
+});
+
+test('Windows: stale ParentProcessId cannot attach an older process to a reused root PID', async () => {
+  const f = fixture({ windows: true });
+  f.identity.started = winLater;
+  f.rows.get(100).started = winLater;
+  assert.equal(await f.stopProcessTree(f.identity), 'stopped');
+  assert.deepEqual(f.signals, [[100, 'SIGKILL']]);
+  assert.equal(f.rows.has(101), true);
+});
+
+test('Windows: unavailable console never silently falls back to force', async () => {
+  const f = fixture({ windows: true, consoleError: new Error('Graceful stop unavailable: shared console') });
+  await assert.rejects(f.stopProcessTree(f.identity, 'graceful'), /unavailable/);
+  assert.deepEqual(f.signals, []);
+  assert.equal(await f.stopProcessTree(f.identity, 'force'), 'stopped');
+});
+
+test('Windows: missing selected birth identity fails closed', async () => {
+  const f = fixture({ windows: true });
+  f.rows.get(101).started = '';
+  await assert.rejects(f.stopProcessTree(f.identity), /identity/);
+});
+
+test('post-signal enumeration failure cannot claim successful cleanup', async () => {
+  const f = fixture({ onWait({ rows }) { rows.delete(900); } });
+  await assert.rejects(f.stopProcessTree(f.identity, 'graceful'), /Incomplete/);
+  assert.ok(f.signals.every(([, signal]) => signal === 'SIGINT'));
+});

package/packages/pi-bg-bash/test/windows-console.test.mjs

@@ -0,0 +1,221 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdtemp, writeFile, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadExtension } from '../../../test/load-extension.mjs';
+
+const { windowsConsoleInterruptScript, windowsConsoleInputPrelude, windowsBashLaunchScript } = loadExtension(new URL('../src/lib/windows-console.ts', import.meta.url));
+const root = { pid: 100, started: '2026-01-05T12:00:00.1234560Z' };
+const child = { pid: 101, started: '2026-01-05T12:00:01.6543210Z' };
+const script = () => windowsConsoleInterruptScript(root, [root, child], 900);
+const exec = promisify(execFile);
+const windows = process.platform === 'win32';
+async function ps(source) {
+  return exec('powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand',
+    Buffer.from(source, 'utf16le').toString('base64')], { timeout: 25_000, maxBuffer: 2 * 1024 * 1024, windowsHide: true });
+}
+
+test('serializes only authenticated numeric PIDs and CIM UTC birth identities', () => {
+  assert.match(script(), /100 = '2026-01-05T12:00:00\.123456Z'/);
+  for (const bad of [0, 1, -1, NaN, Infinity, 1.5, '100', 900]) {
+    assert.throws(() => windowsConsoleInterruptScript({ ...root, pid: bad }, [], 900), /identity/);
+  }
+  for (const started of ['', "'; Stop-Process -Id 900; '", '2026-01-05T12:00:00.1234567Z', '2026-01-05T12:00:00Z']) {
+    assert.throws(() => windowsConsoleInterruptScript({ ...root, started }, [], 900), /identity/);
+  }
+  assert.throws(() => windowsConsoleInterruptScript(root, [{ ...root, started: child.started }], 900), /Conflicting/);
+  assert.throws(() => windowsConsoleInterruptScript(root, [], 0), /owner/);
+  assert.doesNotMatch(script(), /CloseMainWindow|\.Kill\(|Stop-Process|process\.kill/);
+  assert.match(script(), /GenerateConsoleCtrlEvent\(0, 0\)/);
+  assert.ok(script().indexOf('::AttachConsole(100)') < script().indexOf('::SetConsoleCtrlHandler([IntPtr]::Zero'));
+});
+
+test('Bash bootstrap authenticates its solo console, inherits CONIN$, and avoids native stdin piping', () => {
+  const source = windowsBashLaunchScript("C:/fixture/O'Brien preview.sh");
+  assert.match(source, /\$start.Arguments = '-- "C:\/fixture\/O''Brien preview.sh"'/);
+  assert.ok(source.indexOf('GetConsoleProcessList') < source.indexOf('::CreateFile('));
+  assert.ok(source.indexOf('::SetHandleInformation($inputHandle, 1, 1)') < source.indexOf('[System.Diagnostics.Process]::Start'));
+  assert.match(source, /finally \{ \[void\]\[PiBgConsoleInput\]::CloseHandle\(\$inputHandle\) \}/);
+});
+
+for (const [name, count, member] of [['shared', 2, '(uint)System.Diagnostics.Process.GetCurrentProcess().Id'],
+  ['missing', 0, '0'], ['foreign', 1, '1']]) {
+  test(`Bash bootstrap refuses ${name} console before touching input`, { skip: !windows }, async () => {
+    const fake = `Add-Type -TypeDefinition @'
+using System;
+public static class PiBgConsoleInput {
+ public static bool SetConsoleCtrlHandler(IntPtr handler, bool add) { return true; }
+ public static uint GetConsoleProcessList(uint[] buffer, uint size) { buffer[0] = ${member}; return ${count}; }
+}
+'@`;
+    const source = windowsBashLaunchScript('unused.sh').replace(/Add-Type -TypeDefinition @'[\s\S]*?\r?\n'@/, fake);
+    await assert.rejects(ps(source), error => /Job console is not isolated/.test(error.stderr));
+  });
+}
+
+test('bootstrap clears inherited Ctrl+C suppression before commands; all scripts parse in PowerShell 5.1', { skip: !windows }, async () => {
+  assert.match(windowsConsoleInputPrelude, /SetConsoleCtrlHandler\(\[IntPtr\]::Zero, \$false\)/);
+  const encoded = Buffer.from(windowsBashLaunchScript("C:/fixture/O'Brien preview.sh") + '\n' + script(), 'utf8').toString('base64');
+  const { stdout } = await ps(`$source = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}'))
+$tokens = $null; $errors = $null
+$null = [System.Management.Automation.Language.Parser]::ParseInput($source, [ref]$tokens, [ref]$errors)
+if ($errors.Count) { throw ($errors | Out-String) }
+'parsed ' + $PSVersionTable.PSVersion.ToString()`);
+  assert.match(stdout, /parsed 5\.1\./);
+});
+
+// Exercise the actual PowerShell control flow, substituting only OS boundaries.
+// No fixture ever attaches to a console or delivers a real control event.
+async function fixture({ lists = ['100,101,SELF'], fail = '', changed = 0, missing = 0, changeOnRefresh = 0 } = {}) {
+  const arrays = lists.map(list => `new uint[] { ${list.replaceAll('SELF', '(uint)System.Diagnostics.Process.GetCurrentProcess().Id')} }`).join(', ');
+  const native = `Add-Type -TypeDefinition @'
+using System;
+using System.Collections.Generic;
+public static class PiBgConsole {
+ public static List<string> Calls = new List<string>();
+ public static int reads;
+ public static uint[][] lists = new uint[][] { ${arrays} };
+ public static bool FreeConsole() { Calls.Add("free"); return true; }
+ public static bool AttachConsole(uint p) { Calls.Add("attach"); return ${fail === 'attach' ? 'false' : 'true'}; }
+ public static bool SetConsoleCtrlHandler(IntPtr h, bool add) { Calls.Add("handler"); return ${fail === 'handler' ? 'false' : 'true'}; }
+ public static uint GetConsoleProcessList(uint[] buffer, uint size) {
+  Calls.Add("list");
+  ${fail === 'list' ? 'return 0;' : fail === 'oversize' ? 'return 65537;' : fail === 'unstable' ? 'return size + 1;' : `var list = lists[Math.Min(reads++, lists.Length - 1)]; Array.Copy(list, buffer, Math.Min(list.Length, buffer.Length)); return (uint)list.Length;`}
+ }
+ public static bool GenerateConsoleCtrlEvent(uint e, uint g) { Calls.Add("signal:" + e + ":" + g); return ${fail === 'signal' ? 'false' : 'true'}; }
+}
+'@`;
+  const source = script().replace(/Add-Type -TypeDefinition @'[\s\S]*?\r?\n'@/, native)
+    .replace('[System.Diagnostics.Process]::GetProcessById($targetPid)', '(Get-FixtureProcess $targetPid)');
+  const { stdout } = await ps(`$ErrorActionPreference = 'Stop'
+$script:opened = @(); $script:disposed = @(); $script:refreshes = @{}
+function Get-FixtureProcess([int]$id) {
+ if ($id -eq ${missing}) { throw 'process access denied or missing' }
+ $script:opened += $id
+ $birth = if ($id -eq 100) { '${root.started}' } else { '${child.started}' }
+ if ($id -eq ${changed}) { $birth = '2026-01-05T12:00:02.0000000Z' }
+ $p = [pscustomobject]@{ Id=$id; Handle=123; HasExited=$false; StartTime=[DateTime]::Parse($birth).ToUniversalTime() }
+ $p | Add-Member ScriptMethod Refresh {
+  $script:refreshes[$this.Id]++
+  if ($this.Id -eq ${changeOnRefresh} -and $script:refreshes[$this.Id] -ge 3) { $this.HasExited=$true }
+ }
+ $p | Add-Member ScriptMethod Dispose { $script:disposed += $this.Id }
+ return $p
+}
+$message = ''
+try { & {
+${source}
+} } catch { $message = $_.Exception.Message }
+$calls = @(); try { $calls = @([PiBgConsole]::Calls) } catch {}
+[pscustomobject]@{message=$message; calls=$calls; opened=@($script:opened); disposed=@($script:disposed)} | ConvertTo-Json -Compress`);
+  return JSON.parse(stdout.trim());
+}
+
+test('isolated authenticated console: one real Ctrl+C API call, held handles, cleanup', { skip: !windows }, async () => {
+  const result = await fixture();
+  assert.equal(result.message, '');
+  assert.deepEqual(result.calls, ['free', 'attach', 'handler', 'list', 'list', 'list', 'signal:0:0', 'free']);
+  assert.deepEqual(result.opened, [100, 101]);
+  assert.deepEqual(result.disposed.sort(), [100, 101]);
+});
+
+for (const [name, options, error] of [
+  ['Pi shared console', { lists: ['100,900,SELF'] }, /owner/],
+  ['unrelated sentinel', { lists: ['100,500,SELF'] }, /Unauthenticated/],
+  ['root absent', { lists: ['101,SELF'] }, /Root absent/],
+  ['helper absent', { lists: ['100,101'] }, /Helper absent/],
+  ['reused root', { changed: 100 }, /birth identity/],
+  ['reused child', { changed: 101 }, /birth identity/],
+  ['process access error', { missing: 101 }, /access denied/],
+  ['late process exit', { changeOnRefresh: 101 }, /process exited/],
+  ['late unrelated member', { lists: ['100,101,SELF', '100,101,SELF', '100,101,500,SELF'] }, /membership changed/],
+  ['membership shrink', { lists: ['100,101,SELF', '100,SELF'] }, /membership changed/],
+  ['duplicate membership', { lists: ['100,100,SELF'] }, /Invalid console membership/],
+  ['missing console', { fail: 'attach' }, /AttachConsole/],
+  ['handler error', { fail: 'handler' }, /SetConsoleCtrlHandler/],
+  ['enumeration error', { fail: 'list' }, /GetConsoleProcessList/],
+]) {
+  test(`fails closed: ${name}`, { skip: !windows }, async () => {
+    const result = await fixture(options);
+    assert.match(result.message, /Graceful stop unsupported\/error:/);
+    assert.match(result.message, error);
+    assert.ok(!result.calls.some(call => call.startsWith('signal:')));
+    assert.deepEqual(result.disposed.sort(), result.opened.sort());
+    if (result.calls.includes('handler')) assert.equal(result.calls.at(-1), 'free');
+  });
+}
+
+test('bounded console enumeration resizing rejects unstable oversized snapshots', { skip: !windows }, async () => {
+  const large = Array.from({ length: 17 }, (_, i) => i + 100).join(',') + ',SELF';
+  const result = await fixture({ lists: [large, '100,101,SELF'] });
+  assert.equal(result.message, '');
+  assert.equal(result.calls.filter(c => c === 'list').length, 4);
+  const tooLarge = await fixture({ fail: 'oversize' });
+  assert.match(tooLarge.message, /safety bound/);
+  assert.ok(!tooLarge.calls.some(c => c.startsWith('signal:')));
+  const unstable = await fixture({ fail: 'unstable' });
+  assert.match(unstable.message, /did not stabilize/);
+  assert.equal(unstable.calls.filter(c => c === 'list').length, 4);
+  assert.ok(!unstable.calls.some(c => c.startsWith('signal:')));
+});
+
+test('signal API failure is reported and still releases the console and handles', { skip: !windows }, async () => {
+  const result = await fixture({ fail: 'signal' });
+  assert.match(result.message, /GenerateConsoleCtrlEvent/);
+  assert.equal(result.calls.at(-1), 'free');
+  assert.deepEqual(result.disposed.sort(), [100, 101]);
+});
+
+// Opt in: only two test-owned hidden consoles. Both Node fixtures self-expire;
+// no kill calls, no attachment to the test runner/Pi console, even on failure.
+test('native isolated-console Ctrl+C runs a Node SIGINT handler and preserves sentinel', {
+  skip: !windows || process.env.PI_BG_CONSOLE_NATIVE_TEST !== '1', timeout: 65_000,
+}, async () => {
+  const folder = await mkdtemp(join(tmpdir(), 'pi-bg-console-'));
+  const quote = value => "'" + value.replaceAll("'", "''") + "'";
+  try {
+    const nodeFile = join(folder, 'fixture.cjs');
+    await writeFile(nodeFile, `const fs = require('node:fs');
+const path = require('node:path');
+const mode = process.argv[2];
+const dir = __dirname;
+process.on('SIGINT', () => { fs.writeFileSync(path.join(dir, mode + '.interrupt'), 'SIGINT'); if (mode === 'root') process.exit(0); });
+fs.writeFileSync(path.join(dir, mode + '.ready'), String(process.pid));
+setTimeout(() => { fs.writeFileSync(path.join(dir, mode + '.expired'), 'expired'); }, 30000);
+`);
+    const jobFile = join(folder, 'job.ps1');
+    await writeFile(jobFile, windowsConsoleInputPrelude + `\n& ${quote(process.execPath)} ${quote(nodeFile)} root\n`);
+    const launcher = join(folder, 'launch.ps1');
+    await writeFile(launcher, `$ErrorActionPreference='Stop'
+$root = Start-Process -FilePath powershell.exe -ArgumentList @('-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', '"${jobFile}"') -WindowStyle Hidden -RedirectStandardOutput ${quote(join(folder, 'root.out'))} -RedirectStandardError ${quote(join(folder, 'root.err'))} -PassThru
+$sentinel = Start-Process -FilePath ${quote(process.execPath)} -ArgumentList @('"${nodeFile}"', 'sentinel') -WindowStyle Hidden -RedirectStandardOutput ${quote(join(folder, 'sentinel.out'))} -RedirectStandardError ${quote(join(folder, 'sentinel.err'))} -PassThru
+$deadline = [DateTime]::UtcNow.AddSeconds(5)
+while (-not ((Test-Path ${quote(join(folder, 'root.ready'))}) -and (Test-Path ${quote(join(folder, 'sentinel.ready'))}))) {
+ if ([DateTime]::UtcNow -gt $deadline) { throw 'Fixture readiness timeout' }
+ Start-Sleep -Milliseconds 20
+}
+$nodePid = [int](Get-Content ${quote(join(folder, 'root.ready'))})
+$rows = @(Get-CimInstance Win32_Process -Filter ('ProcessId = ' + $root.Id + ' OR ProcessId = ' + $nodePid))
+$row = $rows | Where-Object ProcessId -eq $root.Id
+$nodeRow = $rows | Where-Object ProcessId -eq $nodePid
+@{pid=$root.Id; started=$row.CreationDate.ToUniversalTime().ToString('o'); sentinel=$sentinel.Id;
+ targets=@(@{pid=$root.Id; started=$row.CreationDate.ToUniversalTime().ToString('o')},
+ @{pid=$nodePid; started=$nodeRow.CreationDate.ToUniversalTime().ToString('o')})} | ConvertTo-Json -Compress -Depth 3
+`);
+    const launch = await exec('powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', launcher], { timeout: 25_000, windowsHide: true });
+    const identity = JSON.parse(launch.stdout.trim());
+    const delivered = await ps(windowsConsoleInterruptScript(identity, identity.targets, process.pid));
+    assert.equal(delivered.stderr, '');
+    // API acceptance is insufficient: require evidence from the application's handler.
+    assert.equal(await readFile(join(folder, 'root.interrupt'), 'utf8'), 'SIGINT');
+    await assert.rejects(readFile(join(folder, 'sentinel.interrupt')), { code: 'ENOENT' });
+    console.log(`native Ctrl+C handler confirmed: launcher ${identity.pid}, Node ${identity.targets[1].pid}; unrelated sentinel ${identity.sentinel} untouched`);
+  } finally {
+    // Every fixture naturally expires after 30s. Keep its files available until then.
+    await exec('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', 'Start-Sleep -Seconds 31'], { timeout: 35_000, windowsHide: true });
+    await rm(folder, { recursive: true, force: true });
+  }
+});

package/packages/pi-claude-usage/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+Release notes are recorded from 0.1.3 onward.
+
+## [Unreleased]
+
+## [0.1.4]
+
+### Added
+
+- Include package release notes in Pi 1.5.0's Extension Updates.
+
+## [0.1.3]
+
+### Fixed
+
+- Classify the package as an extension in the Pi package gallery.
+- Show the package screenshot as its gallery preview.

package/packages/pi-claude-usage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saifymatteo/pi-claude-usage",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Displays Claude subscription rate-limit windows from provider message diagnostics.",
   "type": "module",
   "license": "AGPL-3.0-only",
@@ -11,6 +11,7 @@
   "files": [
     "src",
     "README.md",
+    "CHANGELOG.md",
     "NOTICE.md",
     "LICENSE"
   ],

package/packages/pi-clipboard-image/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+Release notes are recorded from 0.1.3 onward.
+
+## [Unreleased]
+
+## [0.1.4]
+
+### Added
+
+- Include package release notes in Pi 1.5.0's Extension Updates.
+
+## [0.1.3]
+
+### Fixed
+
+- Classify the package as an extension in the Pi package gallery.
+- Show the package screenshot as its gallery preview.

package/packages/pi-clipboard-image/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saifymatteo/pi-clipboard-image",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Attaches clipboard images to the draft, including copied image files on Windows.",
   "type": "module",
   "license": "AGPL-3.0-only",
@@ -11,6 +11,7 @@
   "files": [
     "src",
     "README.md",
+    "CHANGELOG.md",
     "NOTICE.md",
     "LICENSE"
   ],

package/packages/pi-codeblock-borders/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+Release notes are recorded from 0.1.3 onward.
+
+## [Unreleased]
+
+## [0.1.4]
+
+### Added
+
+- Include package release notes in Pi 1.5.0's Extension Updates.
+
+## [0.1.3]
+
+### Fixed
+
+- Classify the package as an extension in the Pi package gallery.
+- Show the package screenshot as its gallery preview.

package/packages/pi-codeblock-borders/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saifymatteo/pi-codeblock-borders",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "license": "AGPL-3.0-only",
   "description": "Decorated code fences",
   "engines": {
@@ -15,6 +15,7 @@
   "files": [
     "src",
     "README.md",
+    "CHANGELOG.md",
     "NOTICE.md",
     "LICENSE"
   ],

package/packages/pi-codegraph/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+Release notes are recorded from 0.1.3 onward.
+
+## [Unreleased]
+
+## [0.1.5]
+
+### Added
+
+- Include package release notes in Pi 1.5.0's Extension Updates.
+
+## [0.1.4]
+
+### Fixed
+
+- Defer CLI checks, configuration, and index initialization until after session startup to avoid blocking Pi.
+- Cancel stale initialization when the active session changes.
+
+## [0.1.3]
+
+### Fixed
+
+- Classify the package as an extension in the Pi package gallery.
+- Show the package screenshot as its gallery preview.