@starci/hfs 4.7.47 → 4.9.0

package/runtime/scripts/api/git/rev-list.mjs

@@ -1,5 +0,0 @@
-// rev-list.mjs — `git rev-list <args>`: the commits reachable from one set of refs and not another.
-import { runGit } from './lib.mjs';
-
-/** The spawn result {status, stdout, stderr, error} of `git rev-list ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
-export const revList = (args = [], options = {}) => runGit(['rev-list', ...args], options);

package/runtime/scripts/api/git/rev-parse.mjs

@@ -1,13 +0,0 @@
-// rev-parse.mjs — the commit-resolution read used by runtime Git consumers.
-import { gitRunner } from './lib.mjs';
-
-/**
- * Resolve a Git revision to a commit in `cwd`, peeling tags with `^{commit}`.
- * Returns the trimmed commit ID only when Git succeeds with output; unresolved
- * or non-commit revisions, failed reads and empty output return null.
- * `git` may supply a caller-owned runner instead of the native read.
- */
-export const revParse = (cwd, ref, { git = null } = {}) => {
-  const r = gitRunner(git)(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], { cwd });
-  return r.ok && r.stdout ? r.stdout : null;
-};

package/runtime/scripts/api/git/status-query.mjs

@@ -1,5 +0,0 @@
-// status-query.mjs — `git status <args>`: what a checkout changed (--porcelain, untracked-files mode, pathspecs).
-import { runGit } from './lib.mjs';
-
-/** The spawn result {status, stdout, stderr, error} of `git status ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
-export const statusQuery = (args = [], options = {}) => runGit(['status', ...args], options);

package/runtime/scripts/api/git/worktree-list-query.mjs

@@ -1,5 +0,0 @@
-// worktree-list-query.mjs — `git worktree list <args>`: the registered worktrees of a repository (--porcelain for records).
-import { runGit } from './lib.mjs';
-
-/** The spawn result {status, stdout, stderr, error} of `git worktree list ...args`; options are runGit's (cwd or dir, config, timeout, maxBuffer, input, encoding, env, git). */
-export const worktreeListQuery = (args = [], options = {}) => runGit(['worktree', 'list', ...args], options);

package/runtime/scripts/api/node/spawn-node.mjs

@@ -1,6 +0,0 @@
-// spawn-node.mjs — `node <args>` with this process's node binary, started and not waited for: a long-running runtime
-// process (a server, an engine, a detached helper). Returns the ChildProcess.
-import { nodeStart } from './lib.mjs';
-
-/** Starts `node <args>`; options (cwd, env, stdio, detached) pass through. */
-export const spawnNode = (args, options = {}) => nodeStart(args, options);

package/runtime/scripts/api/npm/dist-tag.mjs

@@ -1,8 +0,0 @@
-// The release owner's npm dist-tag mutation edge; reads remain owned by view.mjs.
-import { npmSpawn } from './lib.mjs';
-
-/** Set one declared tag on an already confirmed package version; report incomplete effects as failure. */
-export function distTag(name, version, tag, { cwd, run = npmSpawn } = {}) {
-  const result = run(['dist-tag', 'add', `${name}@${version}`, tag], { cwd, timeout: 120_000 });
-  return { ok: !result.error && !result.signal && result.status === 0, status: result.status ?? null };
-}

package/runtime/scripts/api/npm/lib.mjs

@@ -1,32 +0,0 @@
-// scripts/api/npm/lib.mjs — the runner of npm and npx: the npm-cli.js / npx-cli.js that ship with this node install, run by
-// that node, or the npm / npx executable beside the node binary (no .cmd shim, no shell, no PATH lookup). Utf8 text, a hidden window. The call
-// files beside it (ci.mjs, pack-dry-run.mjs, run-npm.mjs, run-npx.mjs) each name one use; nothing outside scripts/api/npm
-// imports this runner.
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { withTempEnv } from '../../../engine/temp-root.mjs';
-import { withoutTestRunner } from '../../lib/env.mjs';
-
-/** The `<tool>-cli.js` (npm or npx) of this node install (Windows: beside node; elsewhere: <prefix>/lib/node_modules) run by node, else the `<tool>` executable beside the node binary: an absolute spawn target fixed by the node install, never a PATH lookup; null when the node has neither. */
-const bundledCli = (tool = 'npm', platform = process.platform, execPath = process.execPath, exists = fs.existsSync) => {
-  const dir = path.dirname(execPath);
-  const cli = path.join(dir, ...(platform === 'win32' ? [] : ['..', 'lib']), 'node_modules', 'npm', 'bin', `${tool}-cli.js`);
-  if (exists(cli)) return { file: execPath, args: [cli] };
-  const sibling = path.join(dir, tool);
-  return platform !== 'win32' && exists(sibling) ? { file: sibling, args: [] } : null;
-};
-
-const toolSpawn = (tool, args, options) => {
-  // npm runs a package's test script, which is node --test: the child never carries an enclosing spec run's mark (scripts/lib/env.mjs withoutTestRunner).
-  const spawn = withTempEnv({ encoding: 'utf8', windowsHide: true, maxBuffer: 64 * 1024 * 1024, ...options, env: withoutTestRunner(options.env ?? process.env) });
-  const run = bundledCli(tool);
-  return run ? spawnSync(run.file, [...run.args, ...args], spawn)
-    : { status: null, stdout: '', stderr: '', signal: null, error: Object.assign(new Error(`${tool} was not found beside this node binary`), { code: 'ENOENT' }) };
-};
-
-/** `npm <args>`; options pass through last (cwd, timeout, env, maxBuffer, stdio). */
-export const npmSpawn = (args, options = {}) => toolSpawn('npm', args, options);
-
-/** `npx <args>`; options pass through last (cwd, timeout, env, maxBuffer, stdio). */
-export const npxSpawn = (args, options = {}) => toolSpawn('npx', args, options);

package/runtime/scripts/api/npm/pack-dry-run.mjs

@@ -1,9 +0,0 @@
-// pack-dry-run.mjs — `npm pack --dry-run --json --ignore-scripts` in a package directory: the file list npm would
-// publish (scripts/gates/canon-digest.mjs packedFiles shapes it).
-import { npmSpawn } from './lib.mjs';
-
-/** {status, stdout, stderr, error} of the dry run. npm runs through the runner's absolute node + npm-cli.js target: no shell, no PATH lookup. */
-export function packDryRun(directory, { spawn = npmSpawn } = {}) {
-  const r = spawn(['pack', '--dry-run', '--json', '--ignore-scripts'], { cwd: directory });
-  return { status: r.status, stdout: r.stdout, stderr: r.stderr, error: r.error ?? null };
-}

package/runtime/scripts/api/npm/run-npm.mjs

@@ -1,6 +0,0 @@
-// run-npm.mjs — `npm <args>` waited for: a package script (`run <script>`, `test`) or an install (`ci`, `install`) whose
-// status and output the caller reads. Returns the spawnSync result {status, stdout, stderr, error, signal} (utf8 text).
-import { npmSpawn } from './lib.mjs';
-
-/** Runs `npm <args>`; options (cwd, env, timeout, maxBuffer, stdio) pass through. */
-export const runNpm = (args, options = {}) => npmSpawn(args, options);

package/runtime/scripts/api/npm/view.mjs

@@ -1,30 +0,0 @@
-// view.mjs - `npm view`: what the npm registry says about one package version. The release gate reads it to know whether a
-// version is published and which integrity the registry holds; it never writes.
-import { npmSpawn } from './lib.mjs';
-
-/** The JSON `npm view <spec> <field> --json` printed, or null when it printed none. */
-const parsed = (text) => { try { return JSON.parse(String(text ?? '').trim() || 'null'); } catch { return null; } };
-
-/**
- * {state: 'present' | 'absent' | 'unreachable', integrity?, latest?, versions?, distTags?, detail?} of `name@version`. A package the registry does not
- * know (E404) or a version it does not list is `absent` (with the registry's latest when it has one); any other failure
- * (network, auth, a broken npm) is `unreachable`, never a guess. `run` is the spawn seam of a spec.
- */
-export function view(name, version, { cwd, run = npmSpawn } = {}) {
-  const listed = run(['view', name, 'versions', 'dist-tags', '--json'], { cwd, timeout: 120_000 });
-  const err = `${listed.stderr ?? ''}${listed.error?.message ?? ''}`;
-  if (listed.error || listed.signal || listed.status === null) return { state: 'unreachable', detail: err.trim().slice(0, 200) || 'npm did not run' };
-  if (listed.status !== 0) {
-    return /\bE404\b|404 Not Found|code E404/.test(err) ? { state: 'absent', latest: '-', versions: [], distTags: {} } : { state: 'unreachable', detail: err.trim().split(/\r?\n/)[0].slice(0, 200) };
-  }
-  const doc = parsed(listed.stdout);
-  const versions = [doc?.versions].flat();
-  const distTags = doc?.['dist-tags'];
-  if (!versions.length || versions.some((entry) => typeof entry !== 'string') || !distTags || Array.isArray(distTags) || typeof distTags !== 'object' || Object.values(distTags).some((entry) => typeof entry !== 'string'))
-    return { state: 'unreachable', detail: 'the registry returned an unreadable version or dist-tag inventory' };
-  const inventory = { versions, distTags, latest: distTags.latest ?? '-' };
-  if (!versions.includes(version)) return { state: 'absent', ...inventory };
-  const dist = run(['view', `${name}@${version}`, 'dist.integrity', '--json'], { cwd, timeout: 120_000 });
-  const integrity = !dist.error && !dist.signal && dist.status === 0 ? parsed(dist.stdout) : null;
-  return typeof integrity === 'string' ? { state: 'present', integrity, ...inventory } : { state: 'unreachable', detail: 'the registry lists the version but gave no integrity' };
-}

package/runtime/scripts/api/npm/whoami.mjs

@@ -1,8 +0,0 @@
-// whoami.mjs - `npm whoami`: the npm account logged in on this host (release-publish.mjs refuses a publish from another one).
-import { npmSpawn } from './lib.mjs';
-
-/** The npm account logged in on this host, or null. `run` is the spawn seam of a spec. */
-export function whoami({ cwd, run = npmSpawn } = {}) {
-  const r = run(['whoami'], { cwd, timeout: 60_000 });
-  return !r.error && !r.signal && r.status === 0 ? String(r.stdout ?? '').trim() || null : null;
-}

package/runtime/scripts/api/process/hide-child-windows.mjs

@@ -1,31 +0,0 @@
-// hide-child-windows.mjs — the child-process defaults for background Windows entry points.
-import cp from 'node:child_process';
-import { syncBuiltinESMExports } from 'node:module';
-import { withWindowsHide } from './lib.mjs';
-
-const MARK = Symbol.for('starci.hideChildWindows');
-
-/**
- * Install process-wide hidden-window defaults for Windows child-process calls.
- * Explicit `windowsHide` options survive, and builtin ESM exports are synced
- * so their named imports use the wrappers. Importing this module installs the
- * patch; detached entry points load it before spawning to avoid visible consoles.
- * Returns true on the first Windows installation, false elsewhere or once patched.
- */
-export function hideChildWindows({ platform = process.platform } = {}) {
-  if (platform !== 'win32' || cp[MARK]) return false;
-  for (const [name, hasArgv] of [['spawn', true], ['spawnSync', true], ['execFile', true], ['execFileSync', true], ['exec', false], ['execSync', false]]) {
-    const original = cp[name];
-    const wrapped = function (...list) { return original.apply(this, withWindowsHide(list, hasArgv)); };
-    for (const key of Reflect.ownKeys(original)) {
-      if (key === 'length' || key === 'name' || key === 'prototype') continue;
-      try { Object.defineProperty(wrapped, key, Object.getOwnPropertyDescriptor(original, key)); } catch { /* non-configurable */ }
-    }
-    cp[name] = wrapped;
-  }
-  cp[MARK] = true;
-  syncBuiltinESMExports();
-  return true;
-}
-
-hideChildWindows();

package/runtime/scripts/api/process/kill-tree.mjs

@@ -1,22 +0,0 @@
-// kill-tree.mjs — the host API for a forced Windows process-tree stop.
-import { spawnSync } from 'node:child_process';
-
-const KILL_TREE_COMMAND = 'taskkill.exe';
-const killTreeArgs = (pid) => ['/F', '/T', '/PID', String(pid)];
-
-/**
- * Force-stop a caller-owned PID and its descendants with Windows taskkill.
- * The caller proves ownership and validates the PID; this API checks neither.
- * Non-Windows calls stop nothing and return `{ok:false,status:null,output}`.
- * Returns `{ok,status,output}` with bounded diagnostic text; spawn failures become
- * failure results. `ok` reflects taskkill's exit status without rechecking liveness.
- */
-export function killTree(pid, { timeoutMs = 60_000, run = spawnSync, platform = process.platform } = {}) {
-  if (platform !== 'win32') return { ok: false, status: null, output: 'not windows' };
-  try {
-    const r = run(KILL_TREE_COMMAND, killTreeArgs(pid), { encoding: 'utf8', windowsHide: true, timeout: timeoutMs });
-    return { ok: r?.status === 0, status: r?.status ?? null, output: String(r?.stdout || r?.stderr || r?.error?.message || '').trim().slice(0, 300) };
-  } catch (error) {
-    return { ok: false, status: null, output: String(error?.message ?? error).slice(0, 300) };
-  }
-}

package/runtime/scripts/api/process/lib.mjs

@@ -1,125 +0,0 @@
-// scripts/api/process/lib.mjs — what the process call files beside it share: the spawn options every child of the
-// runtime carries. The call files (process-list.mjs, kill-tree.mjs, run-shell.mjs, spawn-detached.mjs, set-priority.mjs,
-// hide-child-windows.mjs, ...) each name one use of the host's process table or a child process.
-
-/**
- * `list` with windowsHide: true added to its options argument. `hasArgv`:
- * the call's second argument may be an argv array (spawn, execFile) rather
- * than options (exec). An explicit windowsHide (true or false) is kept.
- */
-export function withWindowsHide(list, hasArgv) {
-  const out = [...list];
-  let slot = 1;
-  if (hasArgv && (Array.isArray(out[1]) || (out[1] == null && out.length > 2))) slot = 2;
-  const options = out[slot];
-  if (options == null) out.splice(slot, out.length > slot ? 1 : 0, { windowsHide: true });
-  else if (typeof options === 'function') out.splice(slot, 0, { windowsHide: true });
-  else if (typeof options === 'object' && !('windowsHide' in options)) out[slot] = { ...options, windowsHide: true };
-  return out;
-}
-
-// ---- the host process table (process-list.mjs, process-list-async.mjs) ------------------------------------------
-
-const psQuote = (s) => String(s).replaceAll("'", "''");
-
-/** The PowerShell script of one process-table read: Win32_Process rows (optionally filtered), with CPU when asked. */
-export function processListScript({ where = null, cmdMax = 4000, cpu = false } = {}) {
-  const filter = where ? ` -Filter '${psQuote(where)}'` : '';
-  return [
-    ...(cpu ? ['$perf = @{}', 'Get-CimInstance Win32_PerfFormattedData_PerfProc_Process | ForEach-Object { if ($_.IDProcess -gt 0) { $perf[[int]$_.IDProcess] = [double]$_.PercentProcessorTime } }'] : []),
-    `Get-CimInstance Win32_Process${filter} | ForEach-Object { $c = [string]$_.CommandLine; [pscustomobject]@{ pid = [int]$_.ProcessId; ppid = [int]$_.ParentProcessId; name = [string]$_.Name; exe = [string]$_.ExecutablePath;`,
-    `  cmd = $c.Substring(0, [Math]::Min(${Number(cmdMax) || 4000}, $c.Length)); ws = [int64]$_.WorkingSetSize;`,
-    `  created = $(if ($_.CreationDate) { ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() } else { 0 })${cpu ? '; cpu = $perf[[int]$_.ProcessId]' : ''} } } | ConvertTo-Json -Compress`,
-  ].join('\n');
-}
-
-/** The rows of the PowerShell read's JSON (one object or an array). */
-export const processRowsOfJson = (text) => {
-  const t = String(text ?? '').trim();
-  const v = t ? JSON.parse(t) : [];
-  return (Array.isArray(v) ? v : [v]).map((p) => ({ ...p, pid: Number(p.pid), ppid: Number(p.ppid), cmd: String(p.cmd ?? '') }));
-};
-
-/** The rows of `ps -eo pid=,ppid=,comm=,args=` (exe/created/ws are null there). */
-const PS_ROW_PARTS = [String.raw`^\s*`, String.raw`(\d+)`, String.raw`\s+`, String.raw`(\d+)`, String.raw`\s+`, String.raw`(\S+)`, String.raw`\s+`, '(.*)', '$'];
-const PS_ROW = new RegExp(PS_ROW_PARTS.join(''));
-export const processRowsOfPs = (text, cmdMax = 4000) => String(text ?? '').split(/\r?\n/).map((line) => PS_ROW.exec(line)).filter(Boolean)
-  .map((m) => ({ pid: Number(m[1]), ppid: Number(m[2]), name: m[3].split('/').pop(), exe: null, cmd: m[4].slice(0, cmdMax), created: null, ws: null }));
-
-// ---- the environment of other processes (process-env.mjs) -------------------------------------------------------
-
-// Windows keeps a process's environment block in its PEB: PEB.ProcessParameters (+0x20) -> Environment (+0x80) and
-// EnvironmentSize (+0x3F0), x64 only. A same-user process opens with PROCESS_QUERY_INFORMATION | PROCESS_VM_READ (0x0410).
-export const PROCESS_ENV_NATIVE = String.raw`
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Text;
-public static class StarciProcessEnv {
-  [StructLayout(LayoutKind.Sequential)] struct PBI { public IntPtr Reserved1; public IntPtr PebBaseAddress; public IntPtr Reserved2a; public IntPtr Reserved2b; public IntPtr UniqueProcessId; public IntPtr Reserved3; }
-  [DllImport("ntdll.dll")] static extern int NtQueryInformationProcess(IntPtr h, int cls, ref PBI pbi, int len, out int ret);
-  [DllImport("kernel32.dll")] static extern bool ReadProcessMemory(IntPtr h, IntPtr addr, byte[] buf, IntPtr size, out IntPtr read);
-  [DllImport("kernel32.dll")] static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr h);
-  [DllImport("kernel32.dll")] static extern bool IsWow64Process(IntPtr h, out bool wow);
-  static byte[] Read(IntPtr h, IntPtr addr, int size) {
-    var buf = new byte[size]; IntPtr n;
-    if (!ReadProcessMemory(h, addr, buf, (IntPtr)size, out n) || (int)n != size) return null;
-    return buf;
-  }
-  public static Dictionary<string, string> Env(int pid) {
-    var h = OpenProcess(0x0410, false, pid);
-    if (h == IntPtr.Zero) return null;
-    try { return EnvHandle(h); } finally { CloseHandle(h); }
-  }
-  public static Dictionary<string, string> EnvHandle(IntPtr h) {
-      bool wow; if (IsWow64Process(h, out wow) && wow) return null;
-      var pbi = new PBI(); int ret;
-      if (NtQueryInformationProcess(h, 0, ref pbi, Marshal.SizeOf(pbi), out ret) != 0) return null;
-      var peb = Read(h, pbi.PebBaseAddress + 0x20, 8); if (peb == null) return null;
-      var parameters = (IntPtr)BitConverter.ToInt64(peb, 0);
-      var envPtr = Read(h, parameters + 0x80, 8); if (envPtr == null) return null;
-      var sizeBuf = Read(h, parameters + 0x3F0, 8); if (sizeBuf == null) return null;
-      long size = BitConverter.ToInt64(sizeBuf, 0);
-      if (size <= 0 || size > 4 * 1024 * 1024) return null;
-      var block = Read(h, (IntPtr)BitConverter.ToInt64(envPtr, 0), (int)size); if (block == null) return null;
-      var d = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-      foreach (var entry in Encoding.Unicode.GetString(block).Split('\0')) {
-        if (entry.Length == 0) continue;
-        int i = entry.IndexOf('=', 1); if (i < 0) continue;
-        d[entry.Substring(0, i)] = entry.Substring(i + 1);
-      }
-      return d;
-  }
-}`;
-
-/** The PowerShell script reading `names` from the environment of `pids` (every process when null): JSON [{pid, readable, values}]. */
-export function processEnvScript({ names, pids = null }) {
-  const wanted = JSON.stringify([...names].map(String));
-  const ids = pids ? `@(${[...pids].map(Number).filter(Number.isInteger).join(',')})` : '(Get-Process).Id';
-  return [
-    `Add-Type -TypeDefinition @'${PROCESS_ENV_NATIVE}\n'@ -Language CSharp`,
-    `$names = '${psQuote(wanted)}' | ConvertFrom-Json`,
-    `$rows = foreach ($id in ${ids}) { $e = [StarciProcessEnv]::Env([int]$id); $v = [ordered]@{}; foreach ($n in $names) { $v[$n] = if ($null -ne $e -and $e.ContainsKey($n)) { $e[$n] } else { $null } }; [pscustomobject]@{ pid = [int]$id; readable = ($null -ne $e); values = $v } }`,
-    '@($rows) | ConvertTo-Json -Compress -Depth 4',
-  ].join('\n');
-}
-
-/** The rows of that script's JSON. */
-export const processEnvRowsOfJson = (text) => {
-  const t = String(text ?? '').trim();
-  const v = t ? JSON.parse(t) : [];
-  return (Array.isArray(v) ? v : [v]).map((r) => ({ pid: Number(r.pid), readable: r.readable === true, values: r.values ?? {} }));
-};
-
-/** The spawnSync-shaped result of a system tool the host does not carry (status null + error), for a caller that returns a spawn result. `refusal`: a systemTool refusal. */
-export const toolUnavailableResult = (refusal) => ({ status: null, stdout: '', stderr: '', error: Object.assign(new Error(`${refusal.tool} is not in its fixed system location on ${refusal.platform}`), { code: refusal.code }) });
-
-/** Promise<string | null>: stdout of one system tool run without blocking the calling thread (hidden window, 1 MiB), or null when the tool is absent, failed or timed out. `tool`: systemTool; `exec`: execFile. */
-export const execSystemTool = (name, args, timeout, { exec, tool }) => new Promise((resolve) => {
-  try {
-    const found = tool(name);
-    if (!found.ok) { resolve(null); return; }
-    exec(found.path, args, { timeout, windowsHide: true, maxBuffer: 1 << 20 }, (error, stdout) => resolve(error ? null : String(stdout)));
-  } catch { resolve(null); }
-});

package/runtime/scripts/api/process/probe-guard-command.mjs

@@ -1,74 +0,0 @@
-// probe-guard-command.mjs — run a registered guard hook command the way an agent host runs it, and say whether it resolves.
-//
-// The host runs a hook command through a shell and treats a failure to start it as non-blocking, so an unresolvable
-// guard command leaves every guarded command unguarded without any error the seat acts on. The probe runs the exact
-// command text, with the empty request `{}` the guard allows, once through each shell the host family uses: bash (Git Bash
-// on Windows, the shell Claude Code runs hooks in) and cmd on Windows, sh on POSIX. The environment is the caller's without
-// the seat identity and without the per-user launcher directory on PATH, so only the command's own spelling can resolve.
-// A shell the machine does not carry is skipped with its reason; the probe is ok when every shell that ran exited 0.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { readEnv } from '../../lib/env.mjs';
-import { withoutSeatEnv } from '../../lib/seat-env.mjs';
-import { resolveRealTool } from './resolve-real-tool.mjs';
-import { runProgram } from './run-program.mjs';
-import { systemTool } from './system-tool.mjs';
-
-const PROBE_REQUEST = '{}';
-const PROBE_TIMEOUT_MS = 30_000;
-const DETAIL_CHARS = 200;
-
-/** `env` without the per-user launcher directory on its PATH entry. */
-function withoutLauncherDir(env, { home, platform }) {
-  const key = Object.keys(env).find((name) => name.toLowerCase() === 'path');
-  if (!key) return env;
-  const comparable = (entry) => (platform === 'win32' ? path.resolve(entry).toLowerCase() : path.resolve(entry));
-  const launcher = comparable(path.join(home, '.starci', 'bin'));
-  const kept = String(env[key]).split(platform === 'win32' ? ';' : ':').filter((entry) => entry && comparable(entry.replace(/^"(.*)"$/, '$1')) !== launcher);
-  return { ...env, [key]: kept.join(platform === 'win32' ? ';' : ':') };
-}
-
-/** The Git Bash a Windows seat runs hooks in: Claude Code's own override, else the `bin/bash.exe` of the Git installation `git` resolves to; null when none. */
-function gitBashOf({ env, home, platform, exists }) {
-  const named = readEnv('CLAUDE_CODE_GIT_BASH_PATH', env);
-  if (named) return exists(named) ? named : null;
-  const git = resolveRealTool('git', { env, home, platform });
-  if (!git) return null;
-  const root = path.dirname(path.dirname(git));
-  return [root, path.dirname(root)].map((dir) => path.join(dir, 'bin', 'bash.exe')).find((file) => exists(file)) ?? null;
-}
-
-/** The shells this host family runs hooks in: [{shell, file (null when absent), argv(command), verbatim}]. */
-function shellsOf({ env, home, platform, exists }) {
-  const toolPath = (name) => { const found = systemTool(name, { platform, env, exists }); return found.ok ? found.path : null; };
-  if (platform !== 'win32') return [{ shell: 'sh', file: toolPath('sh'), argv: (command) => ['-c', command], verbatim: false }];
-  return [
-    { shell: 'cmd', file: toolPath('cmd'), argv: (command) => ['/d', '/s', '/c', `"${command}"`], verbatim: true },
-    { shell: 'bash', file: gitBashOf({ env, home, platform, exists }), argv: (command) => ['-c', command], verbatim: false },
-  ];
-}
-
-const detailOf = (result) => {
-  const text = String(result.stderr || result.stdout || result.error?.message || '').trim().replace(/\s+/g, ' ');
-  return text.slice(0, DETAIL_CHARS);
-};
-
-/**
- * Run `command` through every shell of the platform. Returns {ok, reason, shells: [{shell, ok, skipped?, status?, detail?}]};
- * `reason` is null when ok, else one line naming each failing shell with its exit status and output.
- * Seams: `exists` (file probe), `run` (the spawn).
- */
-export function probeGuardCommand({ command, home = os.homedir(), platform = process.platform, env = process.env, exists = fs.existsSync, run = runProgram } = {}) {
-  const probeEnv = withoutLauncherDir(withoutSeatEnv(env), { home, platform });
-  const shells = shellsOf({ env, home, platform, exists }).map((spec) => {
-    if (!spec.file) return { shell: spec.shell, ok: true, skipped: `${spec.shell} is not installed on this machine` };
-    const result = run(spec.file, spec.argv(command), { input: PROBE_REQUEST, env: probeEnv, timeout: PROBE_TIMEOUT_MS, ...(spec.verbatim ? { windowsVerbatimArguments: true } : {}) });
-    return { shell: spec.shell, ok: result.status === 0, status: result.status, detail: detailOf(result) };
-  });
-  const ran = shells.filter((entry) => !entry.skipped);
-  const failed = ran.filter((entry) => !entry.ok);
-  const ok = ran.length > 0 && failed.length === 0;
-  const reason = ok ? null : (failed.map((entry) => `${entry.shell} exit ${entry.status}: ${entry.detail}`).join('; ') || 'no shell on this machine can run the guard command');
-  return { ok, reason, shells };
-}

package/runtime/scripts/api/process/process-list.mjs

@@ -1,28 +0,0 @@
-// process-list.mjs — the synchronous host process-table read.
-import { spawnSync } from 'node:child_process';
-import { processListScript, processRowsOfJson, processRowsOfPs } from './lib.mjs';
-
-/**
- * Synchronously read the host process table for caller-owned filtering.
- * `where` is a Windows WQL filter; `cpu` requests Windows per-core CPU values.
- * Other platforms use ps, with `exe`, `created` and `ws` left null. `cmdMax`
- * truncates command lines before the optional `match` RegExp filters rows.
- * Returns process rows, including an empty list, or null on query or parsing
- * failure. A caller must treat null as an unreadable table rather than no processes.
- */
-export function processList({ where = null, match = null, cmdMax = 4000, cpu = false, run = spawnSync, platform = process.platform, timeoutMs = 120_000 } = {}) {
-  try {
-    let rows;
-    if (platform === 'win32') {
-      const r = run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', processListScript({ where, cmdMax, cpu })],
-        { encoding: 'utf8', windowsHide: true, timeout: timeoutMs, maxBuffer: 256 * 1024 * 1024 });
-      if (!r || r.error || r.status !== 0) return null;
-      rows = processRowsOfJson(r.stdout);
-    } else {
-      const r = run('ps', ['-eo', 'pid=,ppid=,comm=,args='], { encoding: 'utf8', timeout: Math.min(timeoutMs, 30_000) });
-      if (!r || r.error || r.status !== 0) return null;
-      rows = processRowsOfPs(r.stdout, cmdMax);
-    }
-    return match ? rows.filter((p) => match.test(p.cmd)) : rows;
-  } catch { return null; }
-}

package/runtime/scripts/api/process/system-tool.mjs

@@ -1,37 +0,0 @@
-// system-tool.mjs — the absolute path of one OS system tool, taken from FIXED directories no ordinary user can write:
-// Windows <SystemRoot>\System32 (and the NVIDIA driver's own folders), POSIX /usr/bin, /bin, /usr/sbin, /sbin. A tool is
-// never looked up through PATH, so a writable directory early on PATH cannot stand in for it. The process call files
-// spawn the returned path; a tool the host does not carry is a typed refusal, which each caller turns into its own
-// degraded answer (null, "unknown"), never a crash.
-import fs from 'node:fs';
-import path from 'node:path';
-import { readEnv } from '../../lib/env.mjs';
-
-const DEFAULT_SYSTEM_ROOT = ['C:', 'Windows'].join(path.win32.sep);
-const POSIX_DIRS = ['/usr/bin', '/bin', '/usr/sbin', '/sbin'];
-// Windows: path segments under <SystemRoot>\System32 (nvidia-smi also under <drive>\Program Files\NVIDIA Corporation\NVSMI, its legacy home).
-const WINDOWS_TOOLS = {
-  cmd: [['cmd.exe']], powershell: [['WindowsPowerShell', 'v1.0', 'powershell.exe']], schtasks: [['schtasks.exe']], netstat: [['NETSTAT.EXE']], tasklist: [['tasklist.exe']],
-  'nvidia-smi': [['nvidia-smi.exe'], ['..', '..', 'Program Files', 'NVIDIA Corporation', 'NVSMI', 'nvidia-smi.exe']],
-};
-const POSIX_TOOLS = { sh: 'sh', lsof: 'lsof', ps: 'ps', 'nvidia-smi': 'nvidia-smi' };
-
-const refusal = (tool, platform) => ({ ok: false, code: 'SYSTEM_TOOL_UNAVAILABLE', tool, platform });
-
-/** {ok: true, path} (absolute, existing) or the typed refusal {ok: false, code: 'SYSTEM_TOOL_UNAVAILABLE', tool, platform}. `exists` is the file probe. */
-export function systemTool(tool, { platform = process.platform, env = process.env, exists = (file) => fs.existsSync(file) } = {}) {
-  if (platform === 'win32') {
-    const root = readEnv('SystemRoot', env) ?? readEnv('SYSTEMROOT', env) ?? readEnv('windir', env) ?? readEnv('WINDIR', env) ?? DEFAULT_SYSTEM_ROOT;
-    const system32 = path.win32.join(root, 'System32');
-    for (const rel of Object.hasOwn(WINDOWS_TOOLS, tool) ? WINDOWS_TOOLS[tool] : []) {
-      const file = path.win32.join(system32, ...rel);
-      if (exists(file)) return { ok: true, path: file };
-    }
-    return refusal(tool, platform);
-  }
-  for (const dir of Object.hasOwn(POSIX_TOOLS, tool) ? POSIX_DIRS : []) {
-    const file = path.posix.join(dir, POSIX_TOOLS[tool]);
-    if (exists(file)) return { ok: true, path: file };
-  }
-  return refusal(tool, platform);
-}

package/runtime/scripts/gates/canon-digest.mjs

@@ -1,81 +0,0 @@
-// canon-digest.mjs — the one content digest of a lint canon package (modules/models/code-patterns.yaml `canon.contentDigest`).
-// The policy names the algorithm, the include/exclude globs and the framing; the only framing is
-// `sorted-posix-relative-path-null-raw-bytes-null`: every selected file, sorted by its posix relative path (ICU 'en' collation),
-// contributes its path as UTF-8, one NUL byte, its raw bytes, one NUL byte. An unknown algorithm or framing, a malformed
-// policy and a symlink in the file set are refused with a typed code, never hashed around.
-//
-// The file set is either the canon's PUBLISHED set (`packedFiles`: the npm pack list of its source directory, what the
-// registry tarball carries) or an installed copy on disk (`installedFiles`: every regular file under the package root,
-// node_modules excluded). Both feed `canonContentDigest`, so the runtime check and the product gate hash one way.
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { packDryRun } from '../api/npm/pack-dry-run.mjs';
-import { braceVariants, globExpression } from '../lib/glob.mjs';
-import { posixPath } from '../lib/path-key.mjs';
-import { stringList } from '../lib/list.mjs';
-
-const CANON_DIGEST_ALGORITHMS = Object.freeze(['sha256']);
-const CANON_DIGEST_FRAMINGS = Object.freeze(['sorted-posix-relative-path-null-raw-bytes-null']);
-
-// The framing's order is the ICU collation of the 'en' locale (what String#localeCompare gives on a default Node host), fixed
-// here so the order never follows the host's locale; the bound profile values are computed in it.
-const ORDER = new Intl.Collator('en', { usage: 'sort', sensitivity: 'variant' });
-const fail = (code, message) => Object.assign(new Error(message), { code });
-const matchAny = (file, globs) => globs.flatMap(braceVariants).some((pattern) => globExpression(pattern).test(file));
-const globList = (value) => stringList(value, { blank: false });
-
-/** The policy itself, or a typed refusal: CANON_DIGEST_ALGORITHM_UNKNOWN, CANON_DIGEST_FRAMING_UNKNOWN, CANON_DIGEST_POLICY_INVALID. */
-function assertDigestPolicy(policy) {
-  if (!policy || typeof policy !== 'object' || Array.isArray(policy)) throw fail('CANON_DIGEST_POLICY_INVALID', 'The canon content digest policy is not an object.');
-  if (!CANON_DIGEST_ALGORITHMS.includes(policy.algorithm)) throw fail('CANON_DIGEST_ALGORITHM_UNKNOWN', `The canon digest algorithm ${JSON.stringify(policy.algorithm)} is not one of ${CANON_DIGEST_ALGORITHMS.join(', ')}.`);
-  if (!CANON_DIGEST_FRAMINGS.includes(policy.framing)) throw fail('CANON_DIGEST_FRAMING_UNKNOWN', `The canon digest framing ${JSON.stringify(policy.framing)} is not one of ${CANON_DIGEST_FRAMINGS.join(', ')}.`);
-  if (!globList(policy.include) || !policy.include.length || !globList(policy.exclude)) throw fail('CANON_DIGEST_POLICY_INVALID', 'The canon digest policy needs a non-empty include glob list and an exclude glob list.');
-  return policy;
-}
-
-/** Whether posix relative `file` is selected by the policy's include and exclude globs. */
-const selectedByPolicy = (file, policy) => matchAny(file, policy.include) && !matchAny(file, policy.exclude);
-
-/** The PUBLISHED file list of the package whose source is `directory`: `npm pack --dry-run --json --ignore-scripts`. */
-export function packedFiles(directory) {
-  const run = packDryRun(directory);
-  let listed;
-  try { listed = JSON.parse(run.stdout)?.[0]?.files; } catch { listed = null; }
-  if (run.status !== 0 || !Array.isArray(listed)) throw fail('CANON_PACK_UNAVAILABLE', `npm pack --dry-run could not list ${directory}: ${String(run.stderr ?? run.error?.message ?? '').trim().split(/\r?\n/).at(-1) ?? ''}`);
-  return listed.map((entry) => posixPath(entry.path));
-}
-
-/** Every regular file of an installed package at `root` (node_modules skipped); a symlink is refused (CANON_PACKAGE_SYMLINK). */
-export function installedFiles(root) {
-  const files = [];
-  const visit = (directory) => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      if (entry.name === 'node_modules') continue;
-      const absolute = path.join(directory, entry.name), relative = posixPath(path.relative(root, absolute)), stat = fs.lstatSync(absolute);
-      if (stat.isSymbolicLink()) throw fail('CANON_PACKAGE_SYMLINK', `The canon package holds the symlink ${relative}; a canon is hashed from regular files only.`);
-      if (stat.isDirectory()) visit(absolute);
-      else if (stat.isFile()) files.push(relative);
-    }
-  };
-  visit(root);
-  return files;
-}
-
-/** {value, files} of the files of `root` the policy selects out of `files` (posix paths relative to `root`). */
-export function canonContentDigest(root, policy, files) {
-  assertDigestPolicy(policy);
-  const selected = [...new Set(files.map(posixPath))].filter((file) => selectedByPolicy(file, policy)).sort(ORDER.compare);
-  const hash = crypto.createHash(policy.algorithm), nul = Buffer.from([0]);
-  for (const file of selected) {
-    const absolute = path.join(root, file), segments = file.split('/');
-    let stat;
-    for (let depth = 1; depth <= segments.length; depth += 1) {
-      try { stat = fs.lstatSync(path.join(root, ...segments.slice(0, depth))); } catch { throw fail('CANON_PACKAGE_UNREADABLE', `The canon file ${file} is missing.`); }
-      if (stat.isSymbolicLink()) throw fail('CANON_PACKAGE_SYMLINK', `The canon file ${file} is reached through the symlink ${segments.slice(0, depth).join('/')}; a canon is hashed from regular files only.`);
-    }
-    if (!stat.isFile()) throw fail('CANON_PACKAGE_UNREADABLE', `The canon file ${file} is not a regular file.`);
-    hash.update(Buffer.from(file, 'utf8')); hash.update(nul); hash.update(fs.readFileSync(absolute)); hash.update(nul);
-  }
-  return { value: hash.digest('hex'), files: selected.length };
-}