@miller-tech/uap 2.21.2 → 2.36.1

package/dist/benchmarks/paired/types.d.ts

@@ -124,18 +124,18 @@ export declare const MetricVectorSchema: z.ZodObject<{
     error: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     error: string | null;
+    turns: number | null;
     tokens: number | null;
     latencyMs: number;
-    turns: number | null;
     toolCalls: number | null;
     correct: boolean;
     costUsd: number | null;
     wellFormed: boolean | null;
 }, {
     error: string | null;
+    turns: number | null;
     tokens: number | null;
     latencyMs: number;
-    turns: number | null;
     toolCalls: number | null;
     correct: boolean;
     costUsd: number | null;

package/dist/bin/cli.js

@@ -3,7 +3,7 @@ import { Command, Option } from 'commander';
 import chalk from 'chalk';
 import { registerConfigCommands } from '../cli/config-command.js';
 import { existsSync, readFileSync } from 'fs';
-import { execSync, execFileSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 // Lazy import helpers - commands are loaded on-demand to reduce startup time (~10x faster --help)
@@ -25,6 +25,7 @@ const lazy = {
     model: () => import('../cli/model.js').then((m) => m.registerModelCommands),
     mcpRouter: () => import('../cli/mcp-router.js').then((m) => m.mcpRouterCommand),
     dashboard: () => import('../cli/dashboard.js').then((m) => m.dashboardCommand),
+    clients: () => import('../cli/clients.js').then((m) => m.clientsCommand),
     hooks: () => import('../cli/hooks.js'),
     patterns: () => import('../cli/patterns.js').then((m) => m.patternsCommand),
     skill: () => import('../cli/skill.js').then((m) => m.skillCommand),
@@ -44,8 +45,11 @@ const lazy = {
     interaction: () => import('../cli/interaction.js').then((m) => m.interactionCommand),
     orchestratorToggle: () => import('../cli/orchestrator-toggle.js').then((m) => m.orchestratorToggleCommand),
     handsfree: () => import('../cli/handsfree.js').then((m) => m.handsfreeCommand),
+    eta: () => import('../cli/eta.js').then((m) => m.etaCommand),
+    diff: () => import('../cli/diff.js').then((m) => m.diffCommand),
     proxy: () => import('../cli/proxy.js').then((m) => m.proxyCommand),
     benchPaired: () => import('../cli/bench.js').then((m) => m.benchPairedCommand),
+    benchReport: () => import('../cli/bench-report.js').then((m) => m.benchReportCommand),
     tune: () => import('../cli/self-tuning.js').then((m) => m.tuneCommand),
     sandbox: () => import('../cli/sandbox.js').then((m) => m.sandboxCommand),
     design: () => import('../cli/design.js').then((m) => m.designCommand),
@@ -57,11 +61,14 @@ const lazy = {
     doctor: () => import('../cli/doctor.js').then((m) => m.doctorCommand),
     loops: () => import('../cli/loops.js').then((m) => m.loopsCommand),
     inference: () => import('../cli/inference.js').then((m) => m.inferenceHealthCommand),
+    models: () => import('../cli/models.js').then((m) => m.modelsCommand),
     review: () => import('../cli/review.js').then((m) => m.reviewCommand),
     principles: () => import('../cli/principles.js').then((m) => m.principlesCommand),
     challenge: () => import('../cli/challenge.js').then((m) => m.challengeCommand),
     fidelity: () => import('../cli/fidelity.js').then((m) => m.fidelityCommand),
     plan: () => import('../cli/plan.js').then((m) => m.planCommand),
+    self: () => import('../cli/self.js').then((m) => m.selfCommand),
+    attention: () => import('../cli/attention.js').then((m) => m.attentionCommand),
 };
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
@@ -109,10 +116,13 @@ program
 });
 program
     .command('proxy [subcommand] [value]')
-    .description('Reference-counted, session-scoped proxy + dashboard lifecycle: ensure | release | status | start | stop | restart | enable | disable | dashboard [on|off]')
+    .description('Reference-counted, session-scoped proxy + dashboard lifecycle: ensure | release | status | start | stop | restart | enable | disable | dashboard [on|off] | connect --socket <path>')
     .option('--client <id>', 'Client/session id (defaults to session env or parent pid)')
     .option('--client-pid <n>', 'Long-lived agent pid for liveness (hooks pass $PPID)')
     .option('--port <n>', 'Proxy port (default 4000 / $PROXY_PORT)')
+    .option('--socket <path>', 'connect: proxy AF_UNIX socket (default $UAP_PROXY_SOCKET)')
+    .option('--ready-file <path>', 'connect: touch this file once the relay is listening (readiness handshake)')
+    .option('--allow-anyone', 'connect: accept that the relay re-serves the 0600 socket on TCP — while it runs, EVERY local user can reach the model path')
     .option('--quiet', 'Suppress output (used by hooks)')
     .option('--if-enabled', 'No-op unless .uap.json proxy.autostart is true (hook-safe)')
     .option('--json', 'Machine-readable status output')
@@ -132,11 +142,20 @@ program
     .command('sandbox')
     .description('Run a command with a kernel-enforced workdir boundary (bubblewrap): only the ' +
     'current dir + scratch are writable, so writes outside fail at the kernel — the ' +
-    'boundary --dangerously-skip-permissions cannot bypass. Usage: uap sandbox -- <command> [args...]')
+    'boundary --dangerously-skip-permissions cannot bypass. Optional P4 authorities: ' +
+    '`--net off` cuts the network namespace entirely (kernel egress boundary), ' +
+    'and per-session writable holes come from the consent ledger ' +
+    '(uap sandbox grant <path> --session <id> --reason "..." | grants | revoke <id>). ' +
+    'Usage: uap sandbox [--session <id>] [--net shared|off] -- <command> [args...]')
     .argument('[command...]', 'Command to run sandboxed (prefix with -- to pass its flags through)')
+    .option('--session <id>', 'Session id the grant ledger is scoped to (default $UAP_SESSION_ID)')
+    .option('--net <mode>', 'Network mode: shared (default) or off (kernel egress boundary — no network at all)')
+    .option('--ttl <secs>', 'grant: seconds before the grant expires (default 8h, cap 7d)')
+    .option('--reason <why>', 'grant: WHY this authority is consented (required)')
+    .option('--json', 'grants: machine-readable list')
     .allowUnknownOption(true)
-    .action(async (command) => {
-    await (await lazy.sandbox())(command || []);
+    .action(async (command, options) => {
+    await (await lazy.sandbox())(command || [], options);
 });
 program
     .command('generate')
@@ -468,6 +487,7 @@ program
     .argument('[id]', 'list index or fingerprint prefix — show one incident with its escalation handoff')
     .option('--limit <n>', 'how many recent incidents to list', '10')
     .option('--json', 'Emit machine-readable JSON')
+    .option('--steer', 'Emit the recurring-hazard digest for session context (silent when no class repeats)')
     .option('--file <path>', 'Ledger path (default: $UAP_LOOP_INCIDENTS or ~/.config/uap/loop-incidents.jsonl)')
     .action(async (id, options) => {
     const cmd = await lazy.loops();
@@ -498,6 +518,142 @@ program
     const cmd = await lazy.inference();
     await cmd(options);
 });
+// Model placement registry (spec: docs/specs/operator-model-placement.md) —
+// `models` (plural) is placement: where a model lives and what it costs.
+// The existing `uap model` (singular) is multi-model routing: which model
+// answers. Both surfaces cross-reference each other in help text.
+program
+    .command('models')
+    .description('Model placement registry: validate footprints, measure the live backend')
+    .addCommand(new Command('validate')
+    .description('Cross-check the registry (repo + ~/.uap/model-registry.json) against the capacity policy')
+    .option('--repo-path <path>', 'explicit repo registry path (default: <project>/config/model-registry.json)')
+    .option('--local-path <path>', 'explicit machine-local registry path (default: ~/.uap/model-registry.json)')
+    .action(async (options) => {
+    const code = await (await lazy.models())('validate', options);
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(new Command('measure')
+    .description('Record the live backend\'s measured footprint into the machine-local registry')
+    .option('--model <key>', 'registry model key to attribute the measurement to')
+    .option('--config <key>', 'registry config key to attribute the measurement to')
+    .option('--endpoint <url>', 'inference base URL (default: http://127.0.0.1:8080)')
+    .option('--device <key>', 'device key the measurement is valid on (default: first gpu in the registry)')
+    .option('--dry-run', 'Print what would be written; write nothing')
+    .action(async (options) => {
+    const code = await (await lazy.models())('measure', { ...options, dryRun: options.dryRun === true });
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(new Command('status')
+    .description('Sync and print the placement ledger: devices (probe fact), residents, headroom')
+    .option('--repo-path <path>', 'explicit repo registry path')
+    .option('--local-path <path>', 'explicit machine-local registry path')
+    .option('--ledger-path <path>', 'explicit placement ledger path (default: ~/.uap/placement.json)')
+    .action(async (options) => {
+    const code = await (await lazy.models())('status', options);
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(new Command('pending')
+    .description('List parked placement requests awaiting the operator, with ranked options')
+    .option('--repo-path <path>', 'explicit repo registry path')
+    .option('--local-path <path>', 'explicit machine-local registry path')
+    .option('--ledger-path <path>', 'explicit placement ledger path (default: ~/.uap/placement.json)')
+    .action(async (options) => {
+    const code = await (await lazy.models())('pending', options);
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(
+// Args as .argument(), NOT in the name: commander matches the invoked
+// subcommand by NAME, and a name like 'apply <id> <option>' never
+// matches 'apply' (verified live: help listed it, invocation didn't).
+new Command('apply')
+    .argument('<placementId>', 'pending placement id (from `uap models pending`)')
+    .argument('<option>', '1-based option index (as printed by `uap models pending`)')
+    .description('The explicit operator yes: print the impact list, then enforce the placement (rollback on failure)')
+    .option('--yes', 'Actually enforce; without it, prints the impact list and the confirm command')
+    .option('--repo-path <path>', 'explicit repo registry path')
+    .option('--local-path <path>', 'explicit machine-local registry path')
+    .option('--ledger-path <path>', 'explicit placement ledger path (default: ~/.uap/placement.json)')
+    .action(async (placementId, option, options) => {
+    const code = await (await lazy.models())('apply', {
+        ...options,
+        placementId,
+        option: Number(option),
+        yes: options.yes === true,
+    });
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(new Command('dismiss')
+    .argument('<placementId>', 'pending placement id')
+    .description('Refuse a parked placement request; the client falls back on expiry')
+    .option('--ledger-path <path>', 'explicit placement ledger path (default: ~/.uap/placement.json)')
+    .action(async (placementId, options) => {
+    const code = await (await lazy.models())('dismiss', { ...options, placementId });
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(new Command('load')
+    .argument('<model>', 'registry model key (e.g. qwen3.8-27b)')
+    .description('Operator-initiated load: reuse/load-alongside only (displacement needs a pending request)')
+    .option('--ledger-path <path>', 'explicit placement ledger path (default: ~/.uap/placement.json)')
+    .action(async (model, options) => {
+    const code = await (await lazy.models())('load', { ...options, model });
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(new Command('unload')
+    .argument('<model>', 'registry model key whose live residents should be drained and stopped')
+    .description('Drain, stop, verify-free, and refresh for a model\'s live residents')
+    .option('--ledger-path <path>', 'explicit placement ledger path (default: ~/.uap/placement.json)')
+    .action(async (model, options) => {
+    const code = await (await lazy.models())('unload', { ...options, model });
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(new Command('units')
+    .description('Write Conflicts= drop-ins for same-device registry units (systemd then refuses two residents per device)')
+    .option('--repo-path <path>', 'explicit repo registry path')
+    .option('--local-path <path>', 'explicit machine-local registry path')
+    .action(async (options) => {
+    const code = await (await lazy.models())('units', options);
+    if (code)
+        process.exitCode = code;
+}))
+    .addCommand(new Command('auto')
+    .description('Auto-load policy: load-alongside always; displacement only for allowlisted models (request-driven, no manual apply). Off until --enable.')
+    .option('--enable', 'enable auto-load')
+    .option('--disable', 'disable auto-load; every park needs a manual apply again')
+    .option('--allow-displace <models>', 'comma-separated registry model keys whose displacement may auto-enforce')
+    .option('--disallow-displace <models>', 'comma-separated registry model keys to remove from the displacement allowlist')
+    .option('--allow-unload <models>', 'comma-separated registry model keys that may be auto-unloaded once idle (standing consent; needs --yes)')
+    .option('--disallow-unload <models>', 'comma-separated registry model keys to remove from the idle-unload allowlist')
+    .option('--unload-idle-after-secs <secs>', 'arm idle-unload: no gated use for this many seconds and a listed resident is swept (min 60)')
+    .option('--unload-idle-off', 'disarm the idle-unload timer (allowlist is kept)')
+    .option('--yes', 'required with --allow-displace / --allow-unload: the standing consent being recorded')
+    .option('--policy-path <path>', 'explicit policy file path (testing only: the controller reads ~/.uap/placement-auto.json or UAP_PLACEMENT_AUTO)')
+    .action(async (options) => {
+    const code = await (await lazy.models())('auto', {
+        enable: options.enable === true,
+        disable: options.disable === true,
+        allowDisplace: options.allowDisplace,
+        disallowDisplace: options.disallowDisplace,
+        allowUnload: options.allowUnload,
+        disallowUnload: options.disallowUnload,
+        unloadIdleAfterSecs: options.unloadIdleAfterSecs === undefined
+            ? undefined
+            : Number(options.unloadIdleAfterSecs),
+        unloadIdleAfterSecsOff: options.unloadIdleOff === true,
+        yes: options.yes === true,
+        policyPath: options.policyPath,
+    });
+    if (code)
+        process.exitCode = code;
+}));
 // Quality-metrics gate — complexity/coverage/mutation policing with a ratchet
 program
     .command('quality')
@@ -895,6 +1051,39 @@ program
     const cmd = await lazy.plan();
     await cmd(action, { json: Boolean(options.json), file, review: options.review, force: Boolean(options.force) });
 });
+// S2 self-knowledge card — UAP's own manual, built offline from shipped docs
+program
+    .command('self')
+    .description('Self-knowledge card: the version-pinned digest of UAP\'s own commands/features, and offline search over it')
+    .argument('[action]', 'card | query <question> (default: card)')
+    .argument('[question]', 'query: the question to answer from the card')
+    .option('--json', 'Emit JSON')
+    .option('--refresh', 'card: rebuild even when the version pin still matches')
+    .option('--limit <n>', 'query: max results (default 5)')
+    .action(async (action, question, options) => {
+    const cmd = await lazy.self();
+    await cmd(action, question, {
+        json: Boolean(options.json),
+        refresh: Boolean(options.refresh),
+        limit: options.limit !== undefined ? Number(options.limit) : undefined,
+    });
+});
+// Attention queue — the ask-instead-of-stop rail
+program
+    .command('attention')
+    .description('Operator attention queue: items needing your decision, with AFK safe-default adoption')
+    .argument('[action]', 'list | ack <id> | decide <id> <decision> | sweep (default: list)')
+    .argument('[id]', 'ack/decide: the item id')
+    .argument('[decision]', 'decide: your decision text')
+    .option('--status <s>', 'list: pending | acknowledged | decided | auto-decided | escalated (default: pending)')
+    .option('--json', 'Emit JSON')
+    .action(async (action, id, decision, options) => {
+    const cmd = await lazy.attention();
+    await cmd(action, id, decision, {
+        json: Boolean(options.json),
+        status: typeof options.status === 'string' ? options.status : undefined,
+    });
+});
 // Paired UAP benchmark — controlled UAP-on vs UAP-off A/B
 const bench = program
     .command('bench')
@@ -920,6 +1109,44 @@ bench
     const cmd = await lazy.benchPaired();
     await cmd(options);
 });
+bench
+    .command('report')
+    .description('Read the latest paired report (or --dir); --compare shows run-to-run delta drift. Deltas always carry their discrimination status')
+    .option('--dir <dir>', 'A specific paired-run dir (default: newest under benchmark-results)')
+    .option('--compare', 'Compare the two newest runs: which deltas held, flipped, narrowed')
+    .option('--full', 'Print the stored report.md instead of the compact delta summary')
+    .option('--json', 'Emit the raw report JSON')
+    .action(async (options) => {
+    const cmd = await lazy.benchReport();
+    await cmd(options);
+});
+// Measured pace — the agent's own EWMA ETA over its recorded attempts (P5: S1b)
+program
+    .command('eta')
+    .description('Measured pace: the EWMA ETA for a (model, taskType, complexity) key, from this project\'s own recorded attempts')
+    .option('-m, --model <id>', 'Model id (default: the active/executor model)')
+    .option('--task-type <t>', "Sample key: task type (default 'orchestrated')")
+    .option('--complexity <c>', 'Sample key: complexity tier (default medium)')
+    .option('--all', 'List every key with history (estimates + too-thin keys)')
+    .option('--limit <n>', 'Sample window size (default 50)')
+    .option('--half-life <n>', 'EWMA half-life in samples (default 10)')
+    .option('--db <path>', 'Pin the analytics DB path (tests, odd layouts)')
+    .option('--json', 'Emit JSON')
+    .action(async (options) => {
+    const cmd = await lazy.eta();
+    await cmd(options);
+});
+// Local diff view — what the agent changed around here (P5: S3)
+program
+    .command('diff')
+    .description('Local diff view: uncommitted + unpushed changes at a glance, with per-file deltas and inspection commands')
+    .option('--base <ref>', 'Base ref for the unpushed view (default: master)')
+    .option('--max <n>', 'Per-section file cap (default 40)')
+    .option('--json', 'Emit the raw facts as JSON')
+    .action(async (options) => {
+    const cmd = await lazy.diff();
+    await cmd(options);
+});
 // HALO harness-optimization commands
 const harness = program
     .command('harness')
@@ -1675,6 +1902,40 @@ program
     .action(async (options) => {
     (await lazy.dashboard())('history', options);
 }));
+// Client folder fleet — registry CLI behind the dashboard's Clients tab
+program
+    .command('clients')
+    .description('Client folder fleet: list, add, remove, scan (feeds the dashboard Clients tab)')
+    .addCommand(new Command('list')
+    .description('Fleet summary for every discovered client (live reads)')
+    .action(async () => {
+    (await lazy.clients())('list', undefined, {});
+}))
+    .addCommand(new Command('add')
+    .description('Pin a client folder manually')
+    .argument('<path>', 'Path to the client project root')
+    .option('--name <name>', 'Display name (defaults to the folder name)')
+    .option('--port <port>', 'Dashboard port for spawn-on-demand (default: 3861+)')
+    .action(async (path, options) => {
+    (await lazy.clients())('add', path, options);
+}))
+    .addCommand(new Command('remove')
+    .description('Unpin a manually added client')
+    .argument('<path>', 'Path that was pinned with `add`')
+    .action(async (path) => {
+    (await lazy.clients())('remove', path, {});
+}))
+    .addCommand(new Command('scan')
+    .description('Show what auto-scan discovers')
+    .action(async () => {
+    (await lazy.clients())('scan', undefined, {});
+}))
+    .addCommand(new Command('stop')
+    .description("Stop a client's spawned dashboard (pid ownership-verified)")
+    .argument('<path>', 'Path to the client project root')
+    .action(async (path) => {
+    (await lazy.clients())('stop', path, {});
+}));
 // Multi-Model Architecture commands - visible in --help, loaded on demand
 {
     const modelCmd = program
@@ -1850,7 +2111,10 @@ uapOmpCmd.addCommand(new Command('dashboard')
         const uapOmpDir = process.env.HOME + '/.uap/omp';
         const dashboardScript = `${uapOmpDir}/commands/uap-dashboard.sh`;
         if (existsSync(dashboardScript)) {
-            execSync(`bash "${dashboardScript}"`, { stdio: 'inherit' });
+            // Argv array, never a shell: the path interpolates into a command
+            // string at the old call site (prepass debt) and a hostile HOME
+            // must not become a shell metacharacter.
+            execFileSync('bash', [dashboardScript], { stdio: 'inherit' });
         }
         else {
             console.error('UAP dashboard not installed. Run: uap-omp install');
@@ -1864,14 +2128,26 @@ uapOmpCmd.addCommand(new Command('dashboard')
 // Memory command
 uapOmpCmd.addCommand(new Command('memory')
     .description('Manage UAP memory for oh-my-pi')
-    .addCommand(new Command('status').description('Show memory status').action(() => {
+    .addCommand(new Command('status').description('Show memory status').action(async () => {
     try {
         const uapOmpDir = process.env.HOME + '/.uap/omp';
         const dbPath = `${uapOmpDir}/memory/short_term.db`;
         if (existsSync(dbPath)) {
-            execSync(`sqlite3 "${dbPath}" "SELECT COUNT(*) as total, COUNT(DISTINCT type) as types FROM memories;"`, {
-                stdio: 'inherit',
-            });
+            // The omp memory DB is better-sqlite3's own format: read it with
+            // the library (lazy — keeps `uap --help` fast), never the sqlite3
+            // CLI through a shell. The old call interpolated the path into
+            // `execSync` (prepass debt).
+            const { default: Database } = await import('better-sqlite3');
+            const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+            try {
+                const row = db
+                    .prepare('SELECT COUNT(*) as total, COUNT(DISTINCT type) as types FROM memories')
+                    .get();
+                console.log(`total: ${row.total}\ntypes: ${row.types}`);
+            }
+            finally {
+                db.close();
+            }
         }
         else {
             console.log('No memory database found. Run: uap-omp install');
@@ -1886,17 +2162,32 @@ uapOmpCmd.addCommand(new Command('memory')
     .description('Query memory for relevant context')
     .argument('<search>', 'Search term')
     .option('-n, --limit <number>', 'Max results', '5')
-    .action((search, options) => {
+    .action(async (search, options) => {
     try {
         const uapOmpDir = process.env.HOME + '/.uap/omp';
         const dbPath = `${uapOmpDir}/memory/short_term.db`;
         if (existsSync(dbPath)) {
-            // Sanitize search term to prevent SQL injection
-            const sanitizedSearch = search.replace(/'/g, "''");
-            const sanitizedLimit = parseInt(options.limit, 10) || 5;
-            execSync(`sqlite3 "${dbPath}" "SELECT content, type, importance FROM memories WHERE content LIKE '%${sanitizedSearch}%' ORDER BY importance DESC LIMIT ${sanitizedLimit};"`, {
-                stdio: 'inherit',
-            });
+            // Parameterized LIKE + bound LIMIT: the search term is
+            // user/LLM-controlled and must never reach a shell or be
+            // spliced into SQL text (the old `execSync` call was a real
+            // injection surface — `$()` inside its double quotes executed).
+            // LIKE wildcards in the TERM are escaped too: a literal `%`
+            // search is a literal-% search, not "dump the whole table".
+            const { default: Database } = await import('better-sqlite3');
+            const parsedLimit = parseInt(options.limit, 10);
+            const limit = Number.isFinite(parsedLimit) ? parsedLimit : 5;
+            const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+            try {
+                const rows = db
+                    .prepare("SELECT content, type, importance FROM memories WHERE content LIKE ? ESCAPE '\\' ORDER BY importance DESC LIMIT ?")
+                    .all(`%${String(search).replace(/[\\%_]/g, (m) => `\\${m}`)}%`, Math.max(1, limit));
+                for (const r of rows) {
+                    console.log(`[${r.type}] (i${r.importance}) ${r.content}`);
+                }
+            }
+            finally {
+                db.close();
+            }
         }
         else {
             console.log('No memory database found. Run: uap-omp install');
@@ -1915,7 +2206,9 @@ uapOmpCmd.addCommand(new Command('worktree')
         const uapOmpDir = process.env.HOME + '/.uap/omp';
         const worktreesFile = `${uapOmpDir}/worktrees.json`;
         if (existsSync(worktreesFile)) {
-            execSync(`cat "${worktreesFile}" | jq '.'`, { stdio: 'inherit' });
+            // Pretty-print it ourselves: no shell, no `cat | jq` dependency
+            // (the old pipe interpolated the path through execSync).
+            console.log(JSON.stringify(JSON.parse(readFileSync(worktreesFile, 'utf-8')), null, 2));
         }
         else {
             console.log('No worktrees tracked. Run: uap-omp install');
@@ -1948,7 +2241,9 @@ uapOmpCmd.addCommand(new Command('hooks')
     try {
         const scriptPath = join(__dirname, '../../scripts/omp/uap-omp.sh');
         if (existsSync(scriptPath)) {
-            execSync(`bash "${scriptPath}" install`, { stdio: 'inherit' });
+            // Argv array, never a shell (prepass debt: the path used to
+            // interpolate into an execSync command string).
+            execFileSync('bash', [scriptPath, 'install'], { stdio: 'inherit' });
         }
         else {
             console.error('UAP hooks script not found. Please rebuild with: npm run build');
@@ -1963,7 +2258,7 @@ uapOmpCmd.addCommand(new Command('hooks')
     try {
         const scriptPath = join(__dirname, '../../scripts/omp/uap-omp.sh');
         if (existsSync(scriptPath)) {
-            execSync(`bash "${scriptPath}" status`, { stdio: 'inherit' });
+            execFileSync('bash', [scriptPath, 'status'], { stdio: 'inherit' });
         }
         else {
             console.error('UAP hooks script not found. Please rebuild with: npm run build');