@hncode/hncode 0.6.6 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hncode/hncode",
-  "version": "0.6.6",
+  "version": "0.7.0",
   "description": "hncode — A cyan-blue TUI AI coding agent with zero runtime dependencies.",
   "type": "module",
   "main": "src/index.js",

package/src/ptc-worker.js

@@ -0,0 +1,120 @@
+// The PTC executor's WORKER SIDE — what actually runs the model's code.
+//
+// This file is loaded as a `worker_threads` entry, never imported by the main process. Everything it can reach is
+// what `parentPort` hands it and the globals below: no `require`, no `process` access beyond what is passed in,
+// and no filesystem. The model's code is compiled inside a `vm` context whose only interesting binding is
+// `callTool`, which messages the main thread and waits.
+//
+// WHY A WORKER AND NOT vm ALONE: `vm` is not a security boundary — code in a context can still reach the host
+// through a prototype it was handed. The thread is what makes a runaway loop killable: `worker.terminate()` stops
+// it without the main process ever yielding, which a `while(true)` in `vm.runInContext` would not.
+//
+// The code runs as an ASYNC body, so `await callTool(...)` works exactly as it reads.
+import { parentPort, workerData } from 'node:worker_threads';
+import vm from 'node:vm';
+
+const TOOL_NAMES = Array.isArray(workerData && workerData.toolNames) ? workerData.toolNames : [];
+const TIMEOUT_MS = Number(workerData && workerData.timeoutMs) > 0 ? workerData.timeoutMs : 120000;
+
+let seq = 0;
+const pending = new Map();
+
+/** Ask the main thread to run a tool, and wait for its answer. */
+function callTool(name, args) {
+  const id = ++seq;
+  parentPort.postMessage({ type: 'tool', id, name, args: args == null ? {} : args });
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+  });
+}
+
+parentPort.on('message', (m) => {
+  if (!m || m.type !== 'tool_result') return;
+  const p = pending.get(m.id);
+  if (!p) return;
+  pending.delete(m.id);
+  if (m.ok) p.resolve(m.result);
+  else p.reject(new Error(String(m.error || 'tool failed')));
+});
+
+// ---- the sandbox ---------------------------------------------------------------------------------------------
+
+/** Collect printed lines. `print` is what the model reaches for. */
+const out = [];
+const write = (...parts) => {
+  const line = parts.map((p) => {
+    if (typeof p === 'string') return p;
+    try { return JSON.stringify(p); } catch { return String(p); }
+  }).join(' ');
+  // A single line cap keeps a runaway from filling memory before the byte cap is checked.
+  out.push(line.length > 8000 ? line.slice(0, 8000) + '…' : line);
+};
+
+const sandbox = {
+  callTool,
+  print: write,
+  console: { log: write, error: write, warn: write, info: write },
+  JSON,
+  Math,
+  Date,
+  Promise,
+  Array,
+  Object,
+  String,
+  Number,
+  Boolean,
+  Map,
+  Set,
+  RegExp,
+  Error,
+  TypeError,
+  RangeError,
+  isNaN,
+  isFinite,
+  parseInt,
+  parseFloat,
+  // `sleep` is the one timer worth exposing: pacing between calls is a real need, and `setTimeout` would let the
+  // code keep the thread alive past the point where the caller wants an answer.
+  sleep: (ms) => new Promise((r) => setTimeout(r, Math.max(0, Math.min(Number(ms) || 0, 10000)))),
+};
+
+const context = vm.createContext(sandbox, {
+  // No `codeGeneration` from strings inside the sandbox: a `new Function` there would be a second, unreviewed way
+  // in — and the body the model writes is already compiled below.
+  codeGeneration: { strings: false, wasm: false },
+});
+
+async function run(code) {
+  let script;
+  try {
+    script = new vm.Script(`(async () => {\n${code}\n})()`, { filename: 'ptc-sandbox.js' });
+  } catch (e) {
+    return { ok: false, error: `Syntax error: ${e.message}`, output: '' };
+  }
+
+  const timer = setTimeout(() => {
+    parentPort.postMessage({ type: 'timeout', ms: TIMEOUT_MS });
+    process.exit(0);
+  }, TIMEOUT_MS);
+  if (timer.unref) timer.unref();
+
+  try {
+    const value = await script.runInContext(context, { timeout: TIMEOUT_MS });
+    clearTimeout(timer);
+    // The returned value is what `return` produced, if anything; `print` already captured stdout.
+    let returned;
+    if (value !== undefined) {
+      try { returned = typeof value === 'string' ? value : JSON.stringify(value); } catch { returned = String(value); }
+    }
+    return { ok: true, output: out.join('\n'), returned };
+  } catch (e) {
+    clearTimeout(timer);
+    return { ok: false, error: `${e && e.name ? e.name + ': ' : ''}${e && e.message || e}`, output: out.join('\n') };
+  }
+}
+
+parentPort.on('message', async (m) => {
+  if (!m || m.type !== 'run') return;
+  const result = await run(String(m.code || ''));
+  parentPort.postMessage({ type: 'done', result });
+});

package/src/ptc.js

@@ -0,0 +1,141 @@
+// The PTC executor's MAIN side.
+//
+// Owns a worker, forwards the tool calls it makes to the real tool layer, and enforces the limits the sandbox
+// cannot enforce about itself: output size, tool count, and a wall-clock deadline that survives a wedged await.
+//
+// WHY THE TOOL CALLS COME BACK HERE AT ALL: the tools need `ctx` — the workspace, the approval hook, the session
+// — none of which may exist inside the sandbox. The worker sends `{type:'tool', name, args}`, this side runs the
+// real tool through `getTool`, and the result crosses back as data. The model's code never holds a function that
+// can reach the filesystem; it holds a promise that the host fulfils.
+import { Worker } from 'node:worker_threads';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+/** Tools whose results are safe and useful to hand to code, and whose invocation needs no UI. */
+const CALLABLE = new Set([
+  'Read', 'FileLines', 'Glob', 'Grep', 'Git', 'FetchURL', 'WebSearch',
+  'TodoList', 'TaskList', 'TaskOutput', 'Memory', 'ListTeammates', 'TeamTaskList',
+  'ActivateSkill', 'Goal', 'Diagnostics',
+]);
+
+export const DEFAULT_LIMITS = {
+  // A code body that orchestrates twenty calls is already unusual; five hundred is a loop that has gone wrong.
+  maxToolCalls: 500,
+  // What comes back is the whole point of PTC — a cap keeps a runaway `print` from eating the context it saved.
+  maxOutputBytes: 32000,
+  timeoutMs: 120000,
+};
+
+export const CALLABLE_TOOLS = [...CALLABLE];
+
+/**
+ * Run `code` in a sandbox, letting it call the tools in `CALLABLE`.
+ *
+ * @param {string} code An async function BODY. `await callTool(name, args)` is available.
+ * @param {object} ctx The tool context, passed straight through to each tool.
+ * @param {object} [limits] Overrides for `DEFAULT_LIMITS`.
+ * @returns {Promise<{ok: boolean, output: string, returned?: string, error?: string, calls: string[], truncated?: boolean}>}
+ */
+export function runProgrammatic(code, ctx, limits = {}) {
+  const lim = { ...DEFAULT_LIMITS, ...limits };
+  return new Promise((resolve) => {
+    let settled = false;
+    const calls = [];
+    const lines = [];
+    let bytes = 0;
+    let truncated = false;
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(wall);
+      try { worker.terminate(); } catch { /* already gone */ }
+      resolve(result);
+    };
+
+    const worker = new Worker(path.join(here, 'ptc-worker.js'), {
+      workerData: { toolNames: [...CALLABLE], timeoutMs: lim.timeoutMs },
+      // The sandbox needs no stdio and no shared memory.
+      stdout: true,
+      stderr: true,
+    });
+
+    // The wall clock is the OUTER guarantee: if the worker is stuck in a `while(true)` the inner vm timeout can
+    // still fire, but if the main thread is waiting on a tool that never answers, only this one saves us.
+    const wall = setTimeout(() => {
+      finish({ ok: false, error: `timed out after ${lim.timeoutMs}ms`, output: lines.join('\n'), calls });
+    }, lim.timeoutMs + 5000);
+
+    worker.on('message', async (m) => {
+      if (!m) return;
+
+      if (m.type === 'tool') {
+        if (calls.length >= lim.maxToolCalls) {
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: false, error: `tool-call limit reached (${lim.maxToolCalls})` });
+          return;
+        }
+        const name = String(m.name || '');
+        if (!CALLABLE.has(name)) {
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: false, error: `${name} is not callable from code` });
+          return;
+        }
+        // Imported here, not at the top: tools/index.js imports the PTC TOOL, which imports this module — a static
+        // import would close that cycle and read `spec` before it exists.
+        const { getTool } = await import('./tools/index.js');
+        const tool = getTool(name);
+        if (!tool || typeof tool.execute !== 'function') {
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: false, error: `no such tool: ${name}` });
+          return;
+        }
+        calls.push(name);
+        try {
+          const raw = await tool.execute(m.args || {}, ctx);
+          // A media result is structured blocks, not text; code cannot do anything useful with it.
+          const value = (raw && typeof raw === 'object' && Array.isArray(raw.media))
+            ? '[media result omitted]'
+            : (typeof raw === 'string' ? raw : JSON.stringify(raw));
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: true, result: value });
+        } catch (e) {
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: false, error: String((e && e.message) || e) });
+        }
+        return;
+      }
+
+      if (m.type === 'timeout') {
+        finish({ ok: false, error: `timed out after ${lim.timeoutMs}ms`, output: lines.join('\n'), calls });
+        return;
+      }
+
+      if (m.type === 'done') {
+        const r = m.result || {};
+        let output = String(r.output == null ? '' : r.output);
+        // Cap by BYTES, not characters: the model pays for tokens, and a megabyte of ASCII is the worst case.
+        if (Buffer.byteLength(output, 'utf8') > lim.maxOutputBytes) {
+          output = output.slice(0, lim.maxOutputBytes);
+          truncated = true;
+        }
+        finish({
+          ok: !!r.ok,
+          output,
+          returned: r.returned,
+          error: r.error,
+          calls,
+          truncated: truncated || undefined,
+        });
+      }
+    });
+
+    worker.on('error', (e) => {
+      finish({ ok: false, error: String((e && e.message) || e), output: lines.join('\n'), calls });
+    });
+    worker.on('exit', (code) => {
+      // An exit without a `done` is the worker dying: report it rather than hanging the caller for ever.
+      if (!settled) finish({ ok: false, error: `sandbox exited with code ${code}`, output: lines.join('\n'), calls });
+    });
+
+    worker.postMessage({ type: 'run', code: String(code || '') });
+    void bytes;
+  });
+}

package/src/registry-browser.js

@@ -171,6 +171,23 @@ function statusColor(tone) {
   return C.blue;
 }
 
+/**
+ * The rows a tab SHOWS, after the search filter.
+ *
+ * The renderer and the action handler must agree on this or the list lies: with a query typed,
+ * `selectedIndex` counts entries in the FILTERED list, so looking it up in the unfiltered one acts on whatever
+ * happened to sit at that position instead of the row under the cursor.
+ *
+ * The tab COUNTS stay on the unfiltered list — a filter must never make a tab look empty.
+ */
+export function visibleRowsForTab(state, tabId) {
+  const rows = rowsForTab(state, tabId);
+  const query = String(state && state.filter || '').trim().toLowerCase();
+  if (!query) return rows;
+  return rows.filter((r) => [r.label, r.description, r.name]
+    .map((v) => String(v == null ? '' : v)).join(' ').toLowerCase().includes(query));
+}
+
 export function renderRegistryBrowser(state, cols, rows) {
   if (cols < MIN_WIDTH || rows < MIN_HEIGHT) {
     const lines = [fitExactly(C.red + 'Terminal too small (need >= ' + MIN_WIDTH + ' x ' + MIN_HEIGHT + ')' + C.reset, cols)];
@@ -181,7 +198,9 @@ export function renderRegistryBrowser(state, cols, rows) {
   const tabs = state.kind === 'skills' ? SKILL_TABS : PLUGIN_TABS;
   const tabIdx = Math.max(0, tabs.findIndex((t) => t.id === state.tab));
   const tab = tabs[tabIdx] || tabs[0];
-  const all = rowsForTab(state, tab.id);
+  // The header row and the empty-state message both need to know whether a filter is on.
+  const query = String(state.filter || '').trim().toLowerCase();
+  const all = visibleRowsForTab(state, tab.id);
   const sel = Math.max(0, Math.min(all.length - 1, state.selectedIndex || 0));
 
   const out = [];
@@ -197,9 +216,16 @@ export function renderRegistryBrowser(state, cols, rows) {
   // The key hints stay visible while the fetch runs: the panel is usable during it
   // (the local tabs are already loaded), so replacing the hints with a status message
   // would hide the keys exactly when the user is most likely to press them.
-  const hint = ' Tab switch \u00b7 \u2191\u2193 select \u00b7 Enter install/remove \u00b7 Esc close';
+  const hint = ' / search \u00b7 Tab switch \u00b7 \u2191\u2193 select \u00b7 Enter install/remove \u00b7 Esc close';
   out.push(fitExactly(C.gray + hint + (state.busy ? C.gray + `  ${state.busy}` : '') + C.reset, cols));
   out.push('');
+  // The search field, drawn whenever it is open or has text, so a filtered list always explains itself.
+  if (state.filtering || query) {
+    const shown = String(state.filter || '');
+    const caret = state.filtering ? '\u2588' : '';
+    out.push(C.gray + ' / ' + C.reset + C.white + shown + C.reset + C.cyan + caret + C.reset
+      + C.gray + (query ? `   ${all.length} match${all.length === 1 ? '' : 'es'}` : '   type to filter') + C.reset);
+  }
 
   // Tab strip, with the count of each tab's rows.
   {
@@ -240,22 +266,52 @@ export function renderRegistryBrowser(state, cols, rows) {
           : '  Nothing here.';
     out.push(C.gray + msg + C.reset);
   }
-  for (let i = 0; i < all.length; i++) {
+  // How many LINES each row occupies: its label plus its wrapped description.
+  const descW = Math.max(8, cols - 6);
+  const rowH = all.map((r) => 1 + wrapText(r.description, descW).length);
+  const visibleLines = Math.max(1, bodyRows);
+
+  // The first row to draw. `state.listTop` persists across frames — recomputing it from scratch each time would
+  // snap the window back to the top on every key, and the cursor would appear to leave the list.
+  let first = Math.max(0, Math.min(state.listTop || 0, Math.max(0, all.length - 1)));
+  // Scroll down while the selection does not fit; scroll up if it sits above the window.
+  if (sel < first) first = sel;
+  for (;;) {
+    let used = 0;
+    for (let i = first; i <= sel && i < all.length; i++) used += rowH[i];
+    if (used <= visibleLines || first >= sel) break;
+    first++;
+  }
+  state.listTop = first;
+
+  // Draw from `first`, stopping when the window is full. A row is never split: a label whose description fell
+  // off the bottom reads as a row that has none.
+  let drawn = 0;
+  for (let i = first; i < all.length; i++) {
+    if (drawn > 0 && drawn + rowH[i] > visibleLines) break;
+    drawn += rowH[i];
     const r = all[i];
     const isSel = i === sel;
     const ptr = isSel ? C.cyan + '\u276f ' + C.reset : '  ';
     const nameStyle = isSel ? (C.cyan + C.bold) : C.white;
     const badge = r.status ? '  ' + statusColor(r.statusTone) + r.status + C.reset : '';
     const dis = r.disabled ? C.gray : '';
-    const labelRow = out.length;   // the clickable row for this item
+    const labelRow = out.length;
     out.push(fitExactly(ptr + nameStyle + dis + r.label + C.reset + badge, cols));
-    // The whole label row is a click target: clicking selects the item (and a
-    // second click / the footer activates it), mirroring the tasks browser.
+    // The whole label row is a click target: clicking selects the item (and a second click / the footer
+    // activates it), mirroring the tasks browser.
     hits.push({ row: labelRow, col0: 0, col1: cols - 1, kind: 'regRow', index: i });
-    for (const line of wrapText(r.description, Math.max(8, cols - 6))) {
+    for (const line of wrapText(r.description, descW)) {
       out.push(C.gray + '    ' + line + C.reset);
     }
   }
+  // Say when the list continues: a clipped list that looks complete is how a skill goes missing.
+  let after = first;
+  let acc = 0;
+  while (after < all.length && acc < drawn) { acc += rowH[after]; after++; }
+  const hiddenBelow = all.length - after;
+  if (first > 0) out.push(C.gray + `  \u2191 \u2191 \u2191 ${first} above` + C.reset);
+  if (hiddenBelow > 0) out.push(C.gray + `  \u2193 \u2193 \u2193 ${hiddenBelow} below` + C.reset);
   // A fetch failure has to show even when the LOCAL half has rows, or the Available
   // tab silently looks empty and the user cannot tell why.
   if (all.length && state.data && state.data.remoteError && tab.id === 'available') {
@@ -291,9 +347,36 @@ export function renderRegistryBrowser(state, cols, rows) {
  * 'close' | 'switchTab' | 'select' | 'install' | 'remove' | 'reload' | null
  */
 export function handleRegistryBrowserKey(state, t) {
+
   const tabs = state.kind === 'skills' ? SKILL_TABS : PLUGIN_TABS;
   const all = rowsForTab(state, state.tab);
   const ch = t.ch;
+  // ---- filter input -------------------------------------------------------------------------
+  //
+  // While `state.filtering` is on, every printable key goes into the query instead of acting on the list. Esc
+  // leaves the field without clearing the filter, so a half-typed word is not lost by a stray key; a second Esc
+  // clears it. Enter accepts the filter and returns the keyboard to the list.
+  if (state.filtering) {
+    if (t.key === 'escape') { state.filtering = false; return 'select'; }
+    if (t.key === 'enter') { state.filtering = false; return 'select'; }
+    if (t.key === 'backspace') {
+      state.filter = String(state.filter || '').slice(0, -1);
+      state.selectedIndex = 0;
+      state.listTop = 0;
+      return 'select';
+    }
+    if (t.key === 'up' || t.key === 'down') { state.filtering = false; }   // hand the arrows back to the list
+    else if (ch && ch.length === 1 && ch >= ' ') {
+      state.filter = String(state.filter || '') + ch;
+      state.selectedIndex = 0;
+      state.listTop = 0;
+      return 'select';
+    } else { return null; }
+  }
+
+  // `/` opens the field; a set filter stays visible in the header and Esc clears it from the list too.
+  if (ch === '/') { state.filtering = true; return 'select'; }
+  if (t.key === 'escape' && state.filter) { state.filter = ''; state.selectedIndex = 0; state.listTop = 0; return 'select'; }
 
   if (t.key === 'escape' || ch === 'q' || ch === 'Q') return 'close';
   if (t.key === 'tab') {

package/src/tools/index.js

@@ -24,6 +24,7 @@ import { spec as diagnosticsSpec } from './diagnostics.js';
 import * as memoryMod from './memory.js';
 import * as goalMod from './goal.js';
 import * as activateSkillMod from './activate-skill.js';
+import * as ptcMod from './ptc.js';
 import { pluginTools, pluginToolGeneration } from '../plugin.js';
 
 
@@ -59,6 +60,7 @@ const builtinTools = [
   memoryMod.spec,
   goalMod.spec,
   activateSkillMod.spec,
+  ptcMod.spec,
   ...TEAM_TOOL_SPECS,
 ];
 

package/src/tools/ptc.js

@@ -0,0 +1,91 @@
+/**
+ * ProgrammaticToolCall — let the model orchestrate tools with code instead of one round trip each.
+ *
+ * THE PROBLEM IT SOLVES: a task like "which of these forty files reference the removed symbol" is forty calls,
+ * each with its own inference pass, and every one of those results then sits in the context whether or not it
+ * mattered. The reading is mechanical; only the conclusion is worth the tokens.
+ *
+ * With this tool the model writes the LOOP, and only what it prints comes back. The sandbox holds the forty
+ * results, the filtering and the joining; the conversation holds the six files that matched.
+ *
+ * WHY A SEPARATE TOOL AND NOT `Bash`: a shell would give the model the whole machine and no structure. Here every
+ * call goes back through the tool layer — the same approval rules, the same workspace guard, the same tools —
+ * and the code can only reach the ones on the allowlist. See src/ptc.js for that list, and ptc-worker.js for the
+ * sandbox itself.
+ */
+import { runProgrammatic, CALLABLE_TOOLS } from '../ptc.js';
+
+const DESCRIPTION = [
+  'Orchestrate tools with JavaScript instead of calling them one at a time.',
+  '',
+  'WHEN TO USE IT: work that is a LOOP over tool results, or that needs intermediate data the model should not',
+  'have to read. Reading twenty files to find the three that mention a symbol; checking every changed file for a',
+  'pattern; collecting values from many calls and printing only the ones that matter. The intermediate results',
+  'stay inside the sandbox and never enter the conversation — that is the point.',
+  '',
+  'WHEN NOT TO USE IT: one or two calls, or when you need to READ a result and decide what to do next. Then an',
+  'ordinary tool call is shorter and clearer.',
+  '',
+  'HOW TO WRITE IT: the body of an async function. `await callTool(name, args)` runs a tool and resolves to its',
+  'text result. `print(...)` writes a line to the output; `console.log` is the same. Whatever you `return` is',
+  'appended. Nothing reaches the conversation except what you print or return.',
+  '',
+  'Example:',
+  '```',
+  "const hits = [];",
+  "for (const f of (await callTool('Glob', { pattern: 'src/**/*.js' })).split('\\n').filter(Boolean)) {",
+  "  const text = await callTool('Grep', { pattern: 'oldSymbol', path: f });",
+  "  if (text && !/No matches/.test(text)) hits.push(f);",
+  '}',
+  'print(`${hits.length} files still reference it`);',
+  'print(hits.join(\'\\n\'));',
+  '```',
+  '',
+  `CALLABLE TOOLS: ${CALLABLE_TOOLS.join(', ')}.`,
+  'Anything else is refused — a shell or a write would escape the sandbox\'s purpose.',
+].join('\n');
+
+export const spec = {
+  name: 'ProgrammaticToolCall',
+  description: DESCRIPTION,
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description: [
+          'The body of an async function. `await callTool(name, args)` calls a tool; `print(x)` emits a line.',
+          'Only what is printed or returned reaches the conversation.',
+        ].join(' '),
+      },
+      purpose: {
+        type: 'string',
+        description: 'One line naming what the code is for, shown in the transcript.',
+      },
+    },
+    required: ['code'],
+  },
+  async execute(args, ctx) {
+    const code = String((args && args.code) || '');
+    if (!code.trim()) return 'Error: `code` is empty.';
+
+    const r = await runProgrammatic(code, ctx);
+    const parts = [];
+
+    if (r.output) parts.push(r.output);
+    if (r.returned != null && String(r.returned).trim()) parts.push(String(r.returned));
+    if (r.truncated) parts.push('[output truncated]');
+
+    if (!r.ok) {
+      // The error goes LAST, after whatever the code managed to print: a partial result plus the reason it
+      // stopped is more useful than the reason alone.
+      parts.push(`Error: ${r.error}`);
+    }
+
+    // How many tools ran is worth stating — it is the saving this feature exists for, and a model that sees 0 is
+    // being told its code never reached a tool.
+    if (r.calls.length) parts.push(`(${r.calls.length} tool call${r.calls.length === 1 ? '' : 's'})`);
+
+    return parts.join('\n') || '(no output)';
+  },
+};

package/src/tui.js

@@ -7125,7 +7125,8 @@ const queueH = takeover ? 0 : queuePanelHeight(state);
       const nameField = col(label, selected ? (C.cyan + C.bold) : C.gray);
       const hint = cmd.argumentHint ? col(' ' + cmd.argumentHint, C.gray) : '';
       const pad = Math.max(2, 18 - visualCol(label) - visualCol(hint));
-      const desc = col(cmd.desc, C.gray);
+      // `description` for a skill completion, `desc` for a command: both spellings exist, so accept either.
+      const desc = col(cmd.desc || cmd.description || '', C.gray);
       addHit(lines.length, 2, mInner, { kind: 'menuItem', index: off + j });
       lines.push(menuRow(mark + nameField + hint + ' '.repeat(pad) + desc));
     });
@@ -12779,7 +12780,15 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
       if (!url) { appErr('No git remote named "origin" — cannot build a PR URL.'); return; }
       const branch = gitmod.currentBranch(cwd);
       sayPanel(`Open a pull request for ${branch} → ${base}:\n  ${url}`);
-      app('PR link copied to the transcript (Ctrl+Shift+C to copy).');
+      // ACTUALLY COPY IT, and report what happened.
+      //
+      // The notice used to claim the link was copied while the clipboard was left alone, so the paste that followed
+      // produced whatever was copied last. `copyText` also signals failure by RETURNING false rather than throwing,
+      // so its result is what decides the message — a try/catch around it announced success either way.
+      let copied = false;
+      try { copied = copyText(url); } catch { copied = false; }
+      if (copied) app('PR link copied to your clipboard');
+      else app('Could not reach the clipboard \u2014 the link is on screen above.');
       return;
     }
     case 'cache': {
@@ -14131,7 +14140,7 @@ const agents = readAgentsMd(state.cwd || state.workspace || cfg.workspace, state
       // Tools that act ONLY inside the session: the roster, the mailbox, the task list, the memories.
       // `isInsideWorkspace` answers `false` for any tool it does not know, so without this they all asked for
       // approval in yolo — the one mode whose point is not asking.
-      const safeTools = ['Read', 'Grep', 'Glob', 'FetchURL', 'WebSearch', 'TaskOutput', 'TaskList', 'TaskStop', 'TaskWait', 'TodoList', 'Goal', 'FileLines', 'AgentList', 'AgentMessage', 'AgentInterrupt', 'AgentClose', 'TaskInput', 'SendMessage', 'TeamTaskCreate', 'TeamTaskUpdate', 'TeamTaskList', 'ListTeammates', 'Memory', 'AskUserQuestion'];
+      const safeTools = ['Read', 'Grep', 'Glob', 'FetchURL', 'WebSearch', 'TaskOutput', 'TaskList', 'TaskStop', 'TaskWait', 'TodoList', 'Goal', 'ActivateSkill', 'ProgrammaticToolCall', 'FileLines', 'AgentList', 'AgentMessage', 'AgentInterrupt', 'AgentClose', 'TaskInput', 'SendMessage', 'TeamTaskCreate', 'TeamTaskUpdate', 'TeamTaskList', 'ListTeammates', 'Memory', 'AskUserQuestion'];
       if (rule !== 'ask' && safeTools.includes(toolName)) return true;
       // A read-only SHELL COMMAND (ls/git status/rg/cat …) is as safe as a
       // read-only TOOL, so it runs without a prompt in Ask mode too — the user
@@ -16554,9 +16563,9 @@ export async function startTUI(opts) {
   async function registryAct() {
     const b = state.registryBrowser;
     if (!b || !b.data) return;
-    const { rowsForTab } = await import('./registry-browser.js');
+    const { visibleRowsForTab } = await import('./registry-browser.js');
     const remote = await import('./remote.js');
-    const rows = rowsForTab(b, b.tab);
+    const rows = visibleRowsForTab(b, b.tab);
     const row = rows[Math.min(b.selectedIndex || 0, Math.max(0, rows.length - 1))];
     if (!row || row.disabled || row.action === 'none') return;
     const name = row.name;