reverseport 1.3.0 → 1.5.0

package/bin/reverseport.mjs

@@ -17,7 +17,7 @@ const VERSION = JSON.parse(readFileSync(path.join(REPO, 'package.json'), 'utf8')
 const PORT_COMMANDS = new Set([
   'scan', 'graph', 'symbols', 'scene', 'binary', 'bin', 'archive', 'pck', 'probe', 'extract', 'carve', 'diff',
   'compare-builds', 'report', 'lookup', 'recon', 'web', 'blueprint', 'rebuild', 'map', 'convert', 'plan', 'unit',
-  'write', 'port-scene', 'copy-assets', 'status', 'verify', 'case', 'proof', 'tools', 'serve', 'describe', 'feedback', 'connect',
+  'write', 'port-scene', 'copy-assets', 'status', 'verify', 'case', 'proof', 'tools', 'serve', 'describe', 'feedback', 'connect', 'skills',
 ]);
 const ALWAYS_ENGINE = ['setup', 'doctor', 'update', 'uninstall', 'mcp', 'capabilities', 'providers', 'help'];
 

package/dist/generatedPackageMetadata.js

@@ -1,7 +1,7 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "reverseport",
-    version: "1.3.0", // x-release-please-version
+    version: "1.5.0", // x-release-please-version
     serverSdkVersion: "2.3.1",
     clientSdkVersion: "2.3.1",
     coreSdkVersion: "2.3.1",

package/native/windows/build/manifest.json

@@ -1,5 +1,5 @@
 {
-  "packageVersion": "1.3.0",
+  "packageVersion": "1.5.0",
   "platform": "win32",
   "architecture": "x64",
   "abiVersion": 1,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reverseport",
   "mcpName": "io.github.laaielichter/reverseport",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Reverse engineer anything. Port it anywhere. One CLI and MCP server that lets coding agents take apart apps, games, binaries and websites — decompile, trace, compare builds, recon without files — and rebuild or port them to Godot, Unity, Unreal, three.js or any language.",
   "license": "MIT",
   "repository": {
@@ -301,8 +301,8 @@
   },
   "lint-staged": {
     "*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}": [
-      "oxfmt",
-      "oxlint --fix"
+      "oxfmt --no-error-on-unmatched-pattern",
+      "oxlint --fix --no-error-on-unmatched-pattern"
     ],
     "*.{json,md,yml,yaml}": "oxfmt --no-error-on-unmatched-pattern"
   },

package/port/cli.mjs

@@ -118,6 +118,8 @@ Proof (evidence ledger)
 Other
   tools [--all] [--format f] list the tools (--all adds the engine's when built); formats: ${FORMATS.join(', ')}
   describe <tool>            one tool's description and input schema (engine tools too, when built)
+  skills [list]              the skills bundled with this version
+  skills get <name>          one skill's full guide, matching this version (--json for JSON)
   feedback                   notes agents left with share_feedback (stays on this computer)
   connect [client]           config snippet for any agent: MCP clients, HTTP/OpenAPI, OpenAI, Anthropic, Gemini, shell
   serve                      HTTP API on http://127.0.0.1:32147 (REVERSEPORT_PORT)
@@ -153,6 +155,20 @@ export async function main(argv = process.argv.slice(2)) {
     print({ name: t.name, title: t.title, description: t.description, inputSchema: t.inputSchema, annotations: t.annotations, cli: `reverseport ${t.name} ${(POSITIONAL[t.name] ?? []).map(p => `<${p}>`).join(' ')} [--key value] [--args '{…}']`.replace(/\s+/g, ' ').trim() });
     return 0;
   }
+  if (cmd === 'skills') {
+    const { listSkills, getSkill } = await import('./src/skills.mjs');
+    const [sub, name] = rest.filter(x => !x.startsWith('--'));
+    try {
+      if (!sub || sub === 'list') { print({ version: VERSION, skills: await listSkills() }); return 0; }
+      if (sub === 'get') {
+        const s = await getSkill(name);
+        if (argv.includes('--json')) print({ version: VERSION, name: s.name, description: s.description, body: s.body });
+        else process.stdout.write(`<!-- ReversePort ${VERSION} · skill ${s.name} -->\n${s.text.endsWith('\n') ? s.text : `${s.text}\n`}`);
+        return 0;
+      }
+      return printError(new RPError('INVALID_ARGUMENT', `Unknown skills command "${sub}". Use: reverseport skills list | reverseport skills get <name>`));
+    } catch (e) { return printError(e); }
+  }
   if (cmd === 'feedback') { print(await readFeedback()); return 0; }
   if (cmd === 'connect') {
     const { connect } = await import('./src/connect.mjs');

package/port/src/budget.mjs

@@ -0,0 +1,135 @@
+// Output budget for agents: a tool result that would flood the agent's context is saved whole to a file in the
+// workspace, and the agent gets a shortened result plus where the full one is. Same idea as coding agents that save
+// long tool output to disk ("full output saved to …"). Files older than a week are removed on the next save.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { workspaceDir } from './workspace.mjs';
+
+export const DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;
+const KEEP_DAYS = 7;
+const LONG_STRING = 16 * 1024;
+
+/** Byte budget from REVERSEPORT_MAX_OUTPUT_BYTES: a number (at least 4096), or "off"/"0" for no budget. */
+export function outputLimit(env = process.env) {
+  const raw = String(env.REVERSEPORT_MAX_OUTPUT_BYTES ?? '').trim().toLowerCase();
+  if (raw === 'off' || raw === '0') return Infinity;
+  const n = Number(raw);
+  return raw && Number.isFinite(n) ? Math.max(4096, Math.floor(n)) : DEFAULT_MAX_OUTPUT_BYTES;
+}
+
+const size = v => Buffer.byteLength(JSON.stringify(v) ?? '', 'utf8');
+
+/** Every array and long string in a value, with its path and serialized size. */
+function parts(value, at = '', out = []) {
+  if (Array.isArray(value)) {
+    out.push({ at, kind: 'array', ref: value, bytes: size(value) });
+    value.forEach((v, i) => parts(v, `${at}[${i}]`, out));
+  } else if (value && typeof value === 'object') {
+    for (const [k, v] of Object.entries(value)) parts(v, at ? `${at}.${k}` : k, out);
+  } else if (typeof value === 'string' && value.length > LONG_STRING) out.push({ at, kind: 'string', bytes: value.length });
+  return out;
+}
+
+const isUnder = (at, parent) => at.length > parent.length && at.startsWith(parent) && (parent === '' || at[parent.length] === '.' || at[parent.length] === '[');
+
+function setAt(root, at, fn) {
+  const keys = [...at.matchAll(/\[(\d+)\]|([^.[\]]+)/g)].map(m => (m[1] !== undefined ? Number(m[1]) : m[2]));
+  if (!keys.length) return fn(root);
+  let o = root;
+  for (const k of keys.slice(0, -1)) o = o[k];
+  o[keys.at(-1)] = fn(o[keys.at(-1)]);
+  return root;
+}
+
+/**
+ * Shorten a JSON value until it fits `max` bytes: halve the biggest array (keeping its head) or cut the longest
+ * string, again and again. Returns { value, shortened: [{ path, kept, of }] }.
+ */
+export function shrink(value, max) {
+  let v = structuredClone(value);
+  const originals = new Map();
+  for (let round = 0; round < 200 && size(v) > max; round++) {
+    const cands = parts(v).filter(p => (p.kind === 'array' ? p.ref.length > 1 : true)).sort((a, b) => b.bytes - a.bytes);
+    // Start at the biggest part; when most of it sits in one child (a list inside a list item, a long string),
+    // shorten that child instead, so one huge entry does not empty the whole list.
+    let pick = cands[0];
+    if (!pick) break;
+    for (;;) {
+      const child = cands.find(p => p !== pick && isUnder(p.at, pick.at) && p.bytes >= pick.bytes * 0.6);
+      if (!child) break;
+      pick = child;
+    }
+    if (pick.kind === 'array') {
+      if (!originals.has(pick.at)) originals.set(pick.at, pick.ref.length);
+      v = setAt(v, pick.at, a => a.slice(0, Math.max(1, Math.floor(a.length / 2))));
+    } else {
+      if (!originals.has(pick.at)) originals.set(pick.at, pick.bytes);
+      v = setAt(v, pick.at, s => `${s.slice(0, Math.max(1024, Math.floor(s.length / 2)))}… [cut]`);
+    }
+  }
+  const shortened = [];
+  for (const [at, of] of originals) {
+    let now; try { now = at ? setAtRead(v, at) : v; } catch { continue; }
+    if (Array.isArray(now)) shortened.push({ path: at, kept: now.length, of });
+    else if (typeof now === 'string') shortened.push({ path: at, keptChars: now.length, ofChars: of });
+  }
+  return { value: v, shortened };
+}
+
+function setAtRead(root, at) {
+  const keys = [...at.matchAll(/\[(\d+)\]|([^.[\]]+)/g)].map(m => (m[1] !== undefined ? Number(m[1]) : m[2]));
+  let o = root;
+  for (const k of keys) o = o[k];
+  return o;
+}
+
+async function saveFull(tool, text, ext) {
+  const dir = await workspaceDir('tool-output');
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const file = path.join(dir, `${String(tool).replace(/[^\w-]+/g, '_')}-${stamp}-${crypto.randomBytes(3).toString('hex')}.${ext}`);
+  await fs.writeFile(file, text);
+  cleanOld(dir).catch(() => {});
+  return file;
+}
+
+async function cleanOld(dir, now = Date.now()) {
+  for (const name of await fs.readdir(dir)) {
+    const f = path.join(dir, name);
+    const st = await fs.stat(f).catch(() => null);
+    if (st?.isFile() && now - st.mtimeMs > KEEP_DAYS * 86400000) await fs.rm(f, { force: true });
+  }
+}
+
+const NEXT = 'The result was too big for one answer, so lists were shortened (see shortened). The full result is saved in fullOutput: read the part you need from that file, or call again with a narrower request (match, limit, a subfolder or byte range).';
+
+/** Budget for one of ReversePort's own results (a JSON value). */
+export async function budgetValue(tool, value, max = outputLimit()) {
+  if (value === null || typeof value !== 'object' || !Number.isFinite(max)) return value;
+  const full = JSON.stringify(value);
+  const bytes = Buffer.byteLength(full, 'utf8');
+  if (bytes <= max) return value;
+  const fullOutput = await saveFull(tool, full, 'json');
+  const room = Math.max(2048, Math.floor(max * 0.9) - 2048);
+  const { value: small, shortened } = shrink(value, room);
+  const note = { fullOutput, fullBytes: bytes, limitBytes: max, shortened: shortened.slice(0, 20), next: NEXT };
+  return Array.isArray(small) ? { result: small, outputTruncated: note } : { ...small, outputTruncated: note };
+}
+
+/** Budget for a raw MCP tool result from the deep-analysis engine ({ content, structuredContent?, isError? }). */
+export async function budgetMcpResult(tool, result, max = outputLimit()) {
+  if (!result || typeof result !== 'object' || !Number.isFinite(max) || result.isError) return result;
+  const texts = (result.content ?? []).filter(c => c?.type === 'text').map(c => c.text ?? '');
+  const bytes = Math.max(texts.reduce((n, t) => n + Buffer.byteLength(t, 'utf8'), 0), result.structuredContent ? size(result.structuredContent) : 0);
+  if (bytes <= max) return result;
+  if (result.structuredContent && typeof result.structuredContent === 'object') {
+    const small = await budgetValue(tool, result.structuredContent, max);
+    return { ...result, content: [...(result.content ?? []).filter(c => c?.type !== 'text'), { type: 'text', text: JSON.stringify(small) }], structuredContent: small };
+  }
+  const full = texts.join('\n');
+  const fullOutput = await saveFull(tool, full, 'txt');
+  const head = Buffer.from(full, 'utf8').subarray(0, Math.max(1024, max - 1024)).toString('utf8').replace(/�+$/, '');
+  const lines = full.split('\n').length, shown = head.split('\n').length;
+  const marker = `\n\n[showing lines 1-${shown} of ${lines} (${head.length} of ${full.length} characters); full output saved to ${fullOutput}. Read the rest from that file, or call again with a narrower request.]`;
+  return { ...result, content: [...(result.content ?? []).filter(c => c?.type !== 'text'), { type: 'text', text: head + marker }] };
+}

package/port/src/graph.mjs

@@ -7,6 +7,7 @@ import { requireDir, walk, isText } from './util.mjs';
 import { languageOf, fileSymbols, stripComments, identifiers, CODE_LANGUAGES } from './symbols.mjs';
 import { unityGuidMap } from './scene.mjs';
 import { detectEngines } from './scan.mjs';
+import { workspacePackages, packageCandidates, splitSpecifier, tsconfigAliases } from './jsworkspace.mjs';
 
 const JS_EXT = ['.ts', '.tsx', '.mts', '.js', '.mjs', '.cjs', '.jsx', '.vue', '.svelte', '.json'];
 const TYPE_INDEX_LANGS = new Set(['csharp', 'java', 'kotlin', 'gdscript', 'swift', 'haxe', 'dart', 'scala']);
@@ -61,13 +62,27 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
     if (spec.startsWith('res://')) { const r = godotRootOf(from); return exists(path.posix.normalize((r ? `${r}/` : '') + spec.slice(6))); }
     return exists(path.posix.normalize(path.posix.join(path.posix.dirname(from), spec)));
   };
-  const resolveJs = (from, spec) => {
-    if (!/^\.{1,2}\//.test(spec) && !spec.startsWith('/')) return null;
-    const base = spec.startsWith('/') ? spec.slice(1) : path.posix.normalize(path.posix.join(path.posix.dirname(from), spec));
+  // Monorepos: workspace packages by name and tsconfig "paths" aliases resolve to files in this folder.
+  const hasJs = files.some(f => /\.(m?[jt]sx?|cjs|cts)$/.test(f.rel));
+  const wsPackages = hasJs ? await workspacePackages(files) : new Map();
+  const aliasOf = hasJs ? await tsconfigAliases(files, byRel) : () => [];
+  const jsFile = (base, from) => {
     const stem = base.replace(/\.(m?js|cjs|jsx)$/, '');
+    for (const c of [base, ...JS_EXT.map(e => stem + e), ...JS_EXT.map(e => `${base}/index${e}`)]) { const hit = exists(c); if (hit && hit !== from && nodes.has(hit)) return hit; }
     for (const c of [base, ...JS_EXT.map(e => stem + e), ...JS_EXT.map(e => `${base}/index${e}`)]) { const hit = exists(c); if (hit && hit !== from) return hit; }
     return null;
   };
+  let workspaceEdges = 0, aliasEdges = 0;
+  const resolveJs = (from, spec) => {
+    if (/^\.{1,2}\//.test(spec) || spec.startsWith('/')) {
+      return jsFile(spec.startsWith('/') ? spec.slice(1) : path.posix.normalize(path.posix.join(path.posix.dirname(from), spec)), from);
+    }
+    for (const c of aliasOf(from, spec)) { const hit = jsFile(c, from); if (hit) { aliasEdges++; return hit; } }
+    const { name, sub } = splitSpecifier(spec);
+    const ws = wsPackages.get(name);
+    if (ws) for (const c of packageCandidates(ws, sub)) { const hit = jsFile(c, from); if (hit) { workspaceEdges++; return hit; } }
+    return null;
+  };
   const resolvePy = (from, spec) => {
     const dots = spec.match(/^\.*/)[0].length;
     const mod = spec.slice(dots).replace(/\./g, '/');
@@ -88,10 +103,27 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
     for (const b of ['', path.posix.dirname(from)]) for (const c of [`${p}.lua`, `${p}/init.lua`]) { const hit = exists(path.posix.normalize(b ? `${b}/${c}` : c)); if (hit) return hit; }
     return null;
   };
-  const resolveRustMod = (from, name) => {
-    const dir = path.posix.dirname(from), stem = path.posix.basename(from, '.rs');
-    const base = ['mod', 'main', 'lib'].includes(stem) ? dir : path.posix.join(dir, stem);
-    return exists(path.posix.normalize(`${base}/${name}.rs`)) ?? exists(path.posix.normalize(`${base}/${name}/mod.rs`));
+  // Rust: a file's child modules live in `<stem>/` (or next to mod.rs/lib.rs/main.rs); `crate::` starts at the
+  // crate's src/, and a workspace crate is reachable by its package name (`-` reads as `_`).
+  const rustModuleDir = from => { const dir = path.posix.dirname(from), stem = path.posix.basename(from, '.rs'); return ['mod', 'main', 'lib'].includes(stem) ? dir : path.posix.join(dir, stem); };
+  const rustModuleFile = dir => exists(`${dir}.rs`) ?? exists(`${dir}/mod.rs`) ?? exists(`${dir}/lib.rs`) ?? exists(`${dir}/main.rs`);
+  const resolveRustMod = (from, name) => { const base = rustModuleDir(from); return exists(path.posix.normalize(`${base}/${name}.rs`)) ?? exists(path.posix.normalize(`${base}/${name}/mod.rs`)); };
+  const rustCrates = new Map();
+  for (const f of files) if (/(^|\/)Cargo\.toml$/.test(f.rel)) {
+    const name = (await fs.readFile(f.abs, 'utf8').catch(() => '')).match(/^\[package\][^[]*?^\s*name\s*=\s*"([^"]+)"/ms)?.[1];
+    if (name) rustCrates.set(name.replace(/-/g, '_'), path.posix.join(path.posix.dirname(f.rel), 'src').replace(/^\.\//, ''));
+  }
+  const rustCrateSrc = from => { let dir = path.posix.dirname(from); while (dir && dir !== '.') { if (path.posix.basename(dir) === 'src' && exists(path.posix.join(path.posix.dirname(dir), 'Cargo.toml'))) return dir; dir = path.posix.dirname(dir); } return null; };
+  const resolveRustUse = (from, spec) => {
+    const segs = spec.split('::').filter(Boolean);
+    let base;
+    if (segs[0] === 'crate') { base = rustCrateSrc(from); segs.shift(); }
+    else if (segs[0] === 'self') { base = rustModuleDir(from); segs.shift(); }
+    else if (segs[0] === 'super') { base = rustModuleDir(from); while (segs[0] === 'super') { segs.shift(); base = path.posix.dirname(base); } }
+    else if (rustCrates.has(segs[0])) base = rustCrates.get(segs.shift());
+    if (!base || base === '.') return null;
+    for (let i = segs.length; i >= 1; i--) { const p = `${base}/${segs.slice(0, i).join('/')}`; const hit = exists(`${p}.rs`) ?? exists(`${p}/mod.rs`); if (hit) return hit; }
+    return rustModuleFile(base);
   };
 
   for (const n of nodes.values()) {
@@ -115,11 +147,11 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
       let hit = null;
       switch (n.language) {
         case 'gdscript': case 'shader': hit = resolveRes(n.file, d.spec); break;
-        case 'javascript': case 'typescript': hit = resolveJs(n.file, d.spec); if (!hit && !/^[./]/.test(d.spec)) external(d.spec.startsWith('@') ? d.spec.split('/').slice(0, 2).join('/') : d.spec.split('/')[0]); break;
+        case 'javascript': case 'typescript': hit = resolveJs(n.file, d.spec); if (!hit && !/^[./]/.test(d.spec) && !wsPackages.has(splitSpecifier(d.spec).name)) external(d.spec.startsWith('@') ? d.spec.split('/').slice(0, 2).join('/') : d.spec.split('/')[0]); break;
         case 'python': hit = resolvePy(n.file, d.spec); if (!hit && !d.spec.startsWith('.')) external(d.spec.split('.')[0]); break;
         case 'c': case 'c-header': case 'cpp': case 'objc': if (d.kind === 'system') external(`<${d.spec}>`); else { hit = resolveInclude(n.file, d.spec); if (!hit) external(`"${d.spec}"`); } break;
         case 'lua': hit = resolveLua(n.file, d.spec); if (!hit) external(d.spec); break;
-        case 'rust': if (d.kind === 'mod') hit = resolveRustMod(n.file, d.spec); else if (!/^(crate|self|super)::/.test(d.spec)) external(d.spec.split('::')[0]); break;
+        case 'rust': if (d.kind === 'mod') hit = resolveRustMod(n.file, d.spec); else { hit = resolveRustUse(n.file, d.spec); if (!hit && !/^(crate|self|super)(::|$)/.test(d.spec)) external(d.spec.split('::')[0]); } break;
         case 'go':
           if (goModule && d.spec.startsWith(`${goModule}/`)) {
             const pkgDir = d.spec.slice(goModule.length + 1);
@@ -166,7 +198,25 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
   const { sccs, order } = tarjanOrder([...nodes.keys()], out);
   const cycles = sccs.filter(c => c.length > 1).sort((a, b) => b.length - a.length);
   const orphans = [...nodes.keys()].filter(k => !inc.get(k) && !entry.has(k) && nodes.get(k).kind !== 'scene' && !(out.get(k).length));
-  return { root, truncated, unreadable, engines, nodes, edges: edges.filter(e => nodes.has(e.to)), externals, cycles, order, entryPoints: [...entry], orphans, inDegree: inc, outEdges: out };
+  let workspace = null;
+  if (wsPackages.size > 1 || aliasEdges) {
+    // Package-level view: which workspace package uses which (counts of file imports across packages).
+    const dirs = [...wsPackages.entries()].map(([name, w]) => ({ name, dir: w.dir })).sort((a, b) => b.dir.length - a.dir.length);
+    const pkgOf = rel => dirs.find(d => !d.dir || rel === d.dir || rel.startsWith(`${d.dir}/`))?.name ?? null;
+    const files = new Map(), links = new Map();
+    for (const k of nodes.keys()) { const p = pkgOf(k); if (p) files.set(p, (files.get(p) ?? 0) + 1); }
+    for (const e of edges) {
+      const a = pkgOf(e.from), b = pkgOf(e.to);
+      if (!a || !b || a === b) continue;
+      const key = `${a}\0${b}`; links.set(key, (links.get(key) ?? 0) + 1);
+    }
+    workspace = {
+      packages: wsPackages.size, workspaceEdges, aliasEdges,
+      packageList: dirs.map(d => ({ name: d.name, dir: d.dir || '.', files: files.get(d.name) ?? 0 })).sort((a, b) => b.files - a.files),
+      packageEdges: [...links.entries()].map(([k, uses]) => { const [from, to] = k.split('\0'); return { from, to, uses }; }).sort((a, b) => b.uses - a.uses),
+    };
+  }
+  return { root, truncated, unreadable, engines, workspace, nodes, edges: edges.filter(e => nodes.has(e.to)), externals, cycles, order, entryPoints: [...entry], orphans, inDegree: inc, outEdges: out };
 }
 
 function commonPrefix(a, b) { let i = 0; while (i < a.length && i < b.length && a[i] === b[i]) i++; return i; }
@@ -206,9 +256,14 @@ export function tarjanOrder(keys, out) {
   return { sccs, order: sccs.flat() };
 }
 
+/** Test files: under a test folder, or named *.test.*, *.spec.*, *_test.*, test_*. */
+export const isTestFile = rel => /(^|\/)(tests?|__tests__|specs?|testing)\//.test(rel) || /(\.(test|spec)\.\w+|_tests?\.\w+)$/.test(rel) || /(^|\/)test_[^/]+$/.test(rel);
+
 export function graphMermaid(graph, max = 60) {
   const score = k => (graph.inDegree.get(k) ?? 0) + (graph.outEdges.get(k)?.length ?? 0);
-  const keep = [...graph.nodes.keys()].sort((a, b) => score(b) - score(a)).slice(0, max);
+  // Tests depend on many files, so by degree alone they would crowd out the modules a reader wants to see.
+  const ranked = [...graph.nodes.keys()].sort((a, b) => score(b) - score(a));
+  const keep = [...ranked.filter(k => !isTestFile(k)), ...ranked.filter(isTestFile)].slice(0, max);
   const id = new Map(keep.map((k, i) => [k, `f${i}`]));
   const lines = ['graph LR'];
   for (const k of keep) lines.push(`  ${id.get(k)}["${path.posix.basename(k).replace(/"/g, "'")}"]`);
@@ -232,6 +287,7 @@ export async function graphTool({ path: dir, limit, format = 'json' } = {}) {
   return {
     root: g.root, truncated: g.truncated, ...(g.unreadable?.length ? { unreadable: g.unreadable, warnings: [`${g.unreadable.length} folder(s) could not be read; the graph does not cover them.`] } : {}), fileCount: g.nodes.size, edgeCount: g.edges.length,
     entryPoints: g.entryPoints, cycles: g.cycles.slice(0, 20).map(c => c.slice(0, 30)), orphans: g.orphans.slice(0, 100),
+    ...(g.workspace ? { workspace: { packages: g.workspace.packages, resolvedByPackageName: g.workspace.workspaceEdges, resolvedByTsconfigPaths: g.workspace.aliasEdges, packageList: g.workspace.packageList.slice(0, max), packageEdges: g.workspace.packageEdges.slice(0, edgeMax) } } : {}),
     mostUsed: files.slice(0, 25), externals: ext,
     portOrder: g.order.slice(0, max), portOrderTruncated: g.order.length > max,
     edges: g.edges.slice(0, edgeMax), edgesTruncated: g.edges.length > edgeMax,

package/port/src/jsworkspace.mjs

@@ -0,0 +1,155 @@
+// JavaScript/TypeScript monorepos: workspace packages (npm/yarn/pnpm/bun workspaces, turbo, nx, lerna)
+// and tsconfig "paths" aliases. Lets the graph follow `@scope/pkg/sub` and `@/foo` imports to real files
+// instead of counting them as outside libraries.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/** JSON with comments and trailing commas (tsconfig, turbo.json, jsconfig). Returns null when damaged. */
+export function parseJsonc(text) {
+  if (typeof text !== 'string') return null;
+  let out = '', i = 0, inStr = false;
+  while (i < text.length) {
+    const c = text[i], n = text[i + 1];
+    if (inStr) { out += c; if (c === '\\') { out += n ?? ''; i += 2; continue; } if (c === '"') inStr = false; i++; continue; }
+    if (c === '"') { inStr = true; out += c; i++; continue; }
+    if (c === '/' && n === '/') { while (i < text.length && text[i] !== '\n') i++; continue; }
+    if (c === '/' && n === '*') { i += 2; while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) i++; i += 2; continue; }
+    out += c; i++;
+  }
+  out = out.replace(/,(\s*[}\]])/g, '$1');
+  try { return JSON.parse(out); } catch { return null; }
+}
+
+const readMaybe = async abs => { try { return await fs.readFile(abs, 'utf8'); } catch { return null; } };
+
+/** Package manager and monorepo tool from lockfiles and config at the root. */
+export function workspaceTooling(rels, rootPkg = {}) {
+  const has = f => rels.includes(f);
+  const manager = rootPkg.packageManager?.split('@')[0]
+    ?? (has('bun.lock') || has('bun.lockb') ? 'bun' : has('pnpm-lock.yaml') ? 'pnpm' : has('yarn.lock') ? 'yarn' : has('package-lock.json') ? 'npm' : null);
+  const tools = [['turbo.json', 'Turborepo'], ['nx.json', 'Nx'], ['lerna.json', 'Lerna'], ['rush.json', 'Rush'], ['pnpm-workspace.yaml', 'pnpm workspaces']]
+    .filter(([f]) => has(f)).map(([, n]) => n);
+  return { manager, tools };
+}
+
+/**
+ * Workspace packages by name. `files` are walk() entries ({rel, abs}). Every package.json outside
+ * node_modules counts; that also covers repos that do not declare workspaces but import siblings by name.
+ */
+export async function workspacePackages(files) {
+  const packages = new Map();
+  for (const f of files) {
+    if (!/(^|\/)package\.json$/.test(f.rel) || f.rel.includes('node_modules/')) continue;
+    const pkg = parseJsonc(await readMaybe(f.abs));
+    if (!pkg?.name || typeof pkg.name !== 'string') continue;
+    const dir = path.posix.dirname(f.rel) === '.' ? '' : path.posix.dirname(f.rel);
+    if (!packages.has(pkg.name) || dir.length < packages.get(pkg.name).dir.length) packages.set(pkg.name, { dir, pkg });
+  }
+  return packages;
+}
+
+/** Split `@scope/name/sub/path` or `name/sub` into package name and subpath ('' when none). */
+export function splitSpecifier(spec) {
+  const parts = spec.split('/');
+  const n = spec.startsWith('@') ? 2 : 1;
+  return { name: parts.slice(0, n).join('/'), sub: parts.slice(n).join('/') };
+}
+
+// Pick a file-looking target out of an exports entry (string, conditions object, or array).
+function exportTarget(v) {
+  if (typeof v === 'string') return v;
+  if (Array.isArray(v)) { for (const x of v) { const t = exportTarget(x); if (t) return t; } return null; }
+  if (v && typeof v === 'object') {
+    for (const k of ['source', 'bun', 'development', 'import', 'types', 'module', 'node', 'require', 'browser', 'default']) if (k in v) { const t = exportTarget(v[k]); if (t) return t; }
+    for (const x of Object.values(v)) { const t = exportTarget(x); if (t) return t; }
+  }
+  return null;
+}
+
+/** Candidate relative paths inside the package for a subpath, most likely first. */
+export function packageCandidates({ dir, pkg }, sub) {
+  const base = dir ? `${dir}/` : '';
+  const out = [];
+  const key = sub ? `./${sub}` : '.';
+  const ex = pkg.exports;
+  if (ex && typeof ex === 'object' && !Array.isArray(ex) && Object.keys(ex).some(k => k.startsWith('.'))) {
+    if (key in ex) { const t = exportTarget(ex[key]); if (t) out.push(t); }
+    for (const [k, v] of Object.entries(ex)) {
+      const star = k.indexOf('*');
+      if (star < 0 || !sub) continue;
+      const pre = k.slice(0, star), post = k.slice(star + 1);
+      if (key.startsWith(pre) && key.endsWith(post) && key.length >= pre.length + post.length) {
+        const t = exportTarget(v);
+        if (t) out.push(t.replace('*', key.slice(pre.length, key.length - post.length)));
+      }
+    }
+  } else if (!sub && (typeof ex === 'string' || Array.isArray(ex))) { const t = exportTarget(ex); if (t) out.push(t); }
+  if (!sub) for (const k of ['source', 'module', 'main', 'types', 'typings']) if (typeof pkg[k] === 'string') out.push(pkg[k]);
+  if (sub) out.push(sub, `src/${sub}`);
+  else out.push('src/index', 'index', 'src/main', 'mod');
+  // Built output often points at dist/; the source usually sits at the same place under src/.
+  const extra = [];
+  for (const c of out) { const m = c.replace(/^\.\//, '').match(/^(dist|build|lib|out)\/(.*)$/); if (m) extra.push(`src/${m[2]}`); }
+  return [...out, ...extra].map(c => path.posix.normalize(base + c.replace(/^\.\//, '')));
+}
+
+/** tsconfig/jsconfig `paths` per folder, following `extends` to local files (a few levels). */
+export async function tsconfigAliases(files, byRel) {
+  const configs = new Map();
+  const load = async (rel, depth = 0) => {
+    if (configs.has(rel)) return configs.get(rel);
+    const f = byRel.get(rel);
+    const json = f ? parseJsonc(await readMaybe(f.abs)) : null;
+    let result = null;
+    if (json) {
+      const dir = path.posix.dirname(rel) === '.' ? '' : path.posix.dirname(rel);
+      let inherited = null;
+      for (const ext of [json.extends].flat().filter(e => typeof e === 'string' && e.startsWith('.'))) {
+        if (depth > 4) break;
+        let target = path.posix.normalize(path.posix.join(dir || '.', ext));
+        if (!target.endsWith('.json')) target += '.json';
+        const parent = await load(target, depth + 1);
+        if (parent) inherited = parent;
+      }
+      const co = json.compilerOptions ?? {};
+      if (co.paths && typeof co.paths === 'object') {
+        // Paths resolve against baseUrl when set, else against the tsconfig that declares them.
+        const baseDir = typeof co.baseUrl === 'string' ? path.posix.normalize(path.posix.join(dir || '.', co.baseUrl)) : (dir || '.');
+        result = { baseDir: baseDir === '.' ? '' : baseDir, paths: co.paths };
+      } else if (inherited) result = inherited;
+    }
+    configs.set(rel, result);
+    return result;
+  };
+  for (const f of files) if (/(^|\/)(tsconfig[\w.-]*|jsconfig)\.json$/.test(f.rel) && !f.rel.includes('node_modules/')) await load(f.rel);
+  const byDir = new Map();
+  for (const [rel, cfg] of configs) {
+    if (!cfg || !/(^|\/)(tsconfig|jsconfig)\.json$/.test(rel)) continue;
+    byDir.set(path.posix.dirname(rel) === '.' ? '' : path.posix.dirname(rel), cfg);
+  }
+  /** Candidate relative paths for `spec` imported from `from`; [] when no alias matches. */
+  return (from, spec) => {
+    let dir = path.posix.dirname(from);
+    for (;;) {
+      const key = dir === '.' ? '' : dir;
+      const cfg = byDir.get(key);
+      if (cfg) {
+        const out = [];
+        for (const [pattern, targets] of Object.entries(cfg.paths)) {
+          const star = pattern.indexOf('*');
+          let wild = null;
+          if (star < 0) { if (spec !== pattern) continue; wild = ''; }
+          else {
+            const pre = pattern.slice(0, star), post = pattern.slice(star + 1);
+            if (!spec.startsWith(pre) || !spec.endsWith(post) || spec.length < pre.length + post.length) continue;
+            wild = spec.slice(pre.length, spec.length - post.length);
+          }
+          for (const t of [targets].flat()) if (typeof t === 'string') out.push(path.posix.normalize(path.posix.join(cfg.baseDir || '.', t.replace('*', wild))));
+        }
+        return out;
+      }
+      if (key === '') return [];
+      dir = path.posix.dirname(dir);
+    }
+  };
+}

package/port/src/relay.mjs

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { tools as localToolDefs, callTool, coerceArgs, VERSION } from './tools.mjs';
 import { errorPayload, closest, portableSchema } from './agent.mjs';
 import { RPError } from './util.mjs';
+import { budgetValue, budgetMcpResult } from './budget.mjs';
 
 const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 export const SUPPORTED_PROTOCOLS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'];
@@ -366,12 +367,12 @@ export function createRelay(hooks = {}, options = {}) {
     const input = coerceArgs(schema, dropDisallowedNulls(schema, args ?? {}));
     const res = await engine.forward('tools/call', { name, arguments: input, ...(meta ? { _meta: meta } : {}) }, clientKey);
     if (!res.error && !res.result?.structuredContent?.error?.code?.startsWith?.('ENGINE_')) state.restarts = 0; // a working call resets the restart budget
-    return res.error ? toolError(Object.assign(new Error(res.error.message), { code: 'TOOL_FAILED', details: { rpc: res.error } })) : res.result;
+    return res.error ? toolError(Object.assign(new Error(res.error.message), { code: 'TOOL_FAILED', details: { rpc: res.error } })) : budgetMcpResult(name, res.result);
   }
 
   async function runLocal(name, args) {
     const def = localToolDefs.find(t => t.name === name);
-    const run = async () => { try { return toolResult(await callTool(name, args ?? {})); } catch (e) { return toolError(e); } };
+    const run = async () => { try { return toolResult(await budgetValue(name, await callTool(name, args ?? {}))); } catch (e) { return toolError(e); } };
     if (def?.annotations?.readOnlyHint) return run();
     const p = writerQueue.then(run);
     writerQueue = p.catch(() => {});

package/port/src/scan.mjs

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { RPError, requireDir, walk, readAt, countLines, isText, MiB } from './util.mjs';
 import { LANGUAGE_BY_EXT, CODE_LANGUAGES } from './symbols.mjs';
 import { parseGodotProject } from './scene.mjs';
+import { workspaceTooling } from './jsworkspace.mjs';
 
 const CATEGORY_BY_EXT = {};
 const cat = (name, exts) => exts.split(' ').forEach(e => { CATEGORY_BY_EXT[`.${e}`] = name; });
@@ -19,6 +20,36 @@ cat('config', 'json yaml yml toml ini cfg xml plist properties godot import meta
 cat('build-binary', 'exe dll so dylib pck pak ucas utoc bundle assets ress resource apk aab ipa jar class dex wasm pdb lib a o obj node');
 cat('docs', 'md txt rst pdf html htm');
 
+// npm dependency → framework name, for "what is this built with" in JS/TS projects.
+const JS_FRAMEWORKS = [['three', 'three.js'], ['phaser', 'Phaser'], ['@babylonjs/core', 'Babylon.js'], ['babylonjs', 'Babylon.js'], ['pixi.js', 'PixiJS'], ['playcanvas', 'PlayCanvas'], ['excalibur', 'Excalibur'], ['kaboom', 'Kaboom'], ['kaplay', 'KAPLAY'],
+  ['electron', 'Electron'], ['electron-vite', 'Electron'], ['electron-builder', 'Electron'], ['@tauri-apps/api', 'Tauri'], ['@capacitor/core', 'Capacitor'], ['react-native', 'React Native'], ['expo', 'Expo'],
+  ['react', 'React'], ['vue', 'Vue'], ['svelte', 'Svelte'], ['solid-js', 'SolidJS'], ['preact', 'Preact'], ['@angular/core', 'Angular'], ['lit', 'Lit'],
+  ['next', 'Next.js'], ['nuxt', 'Nuxt'], ['@sveltejs/kit', 'SvelteKit'], ['@solidjs/start', 'SolidStart'], ['astro', 'Astro'], ['@remix-run/react', 'Remix'], ['react-router', 'React Router'],
+  ['vite', 'Vite'], ['webpack', 'webpack'], ['esbuild', 'esbuild'],
+  ['express', 'Express'], ['fastify', 'Fastify'], ['hono', 'Hono'], ['koa', 'Koa'], ['@nestjs/core', 'NestJS'], ['elysia', 'Elysia'],
+  ['effect', 'Effect'], ['drizzle-orm', 'Drizzle ORM'], ['@prisma/client', 'Prisma'], ['@trpc/server', 'tRPC'],
+  ['@modelcontextprotocol/sdk', 'MCP SDK'], ['ai', 'Vercel AI SDK'], ['@opentui/core', 'OpenTUI'], ['ink', 'Ink (terminal UI)'], ['sst', 'SST']];
+
+/** The file a package script starts (`node x.js`, `tsx src/a.ts`, `bun run --cwd pkg src/index.ts`). A leading \0 marks a path relative to --cwd's target, already joined. */
+function scriptEntry(cmd) {
+  if (typeof cmd !== 'string') return null;
+  for (const part of cmd.split(/&&|\|\||;|\|/)) {
+    const t = part.trim().split(/\s+/);
+    const i = t.findIndex(x => /^(node|tsx|ts-node|bun|deno|esno|vite-node)$/.test(x));
+    if (i < 0) continue;
+    let cwd = null;
+    for (let j = i + 1; j < t.length; j++) {
+      const x = t[j];
+      if (x === 'run' || x === 'x') continue;
+      if (x === '--cwd' && t[j + 1]) { cwd = t[++j]; continue; }
+      if (x.startsWith('--cwd=')) { cwd = x.slice(6); continue; }
+      if (x.startsWith('-')) continue;
+      if (/\.[cm]?[jt]sx?$/.test(x)) return cwd ? `\0${path.posix.normalize(path.posix.join(cwd, x))}` : x;
+    }
+  }
+  return null;
+}
+
 function categoryOf(f) {
   const lang = LANGUAGE_BY_EXT[f.ext];
   if (lang && CODE_LANGUAGES.has(lang)) return 'code';
@@ -104,18 +135,37 @@ export async function detectEngines(root, files) {
     else if (/\bFNA\b/.test(t)) add({ id: 'fna', name: 'FNA', kind: 'project', evidence: [f.rel] });
     else if (/Godot\.NET\.Sdk/i.test(t)) { /* part of a Godot .NET project */ }
   }
-  for (const f of find(/(^|\/)package\.json$/).filter(f => !f.rel.includes('node_modules')).slice(0, 10)) {
+  const pkgFiles = find(/(^|\/)package\.json$/).filter(f => !f.rel.includes('node_modules')).sort((a, b) => a.rel.split('/').length - b.rel.split('/').length);
+  const PKG_MAX = 60;
+  for (const f of pkgFiles.slice(0, PKG_MAX)) {
     let pkg = {};
     try { pkg = JSON.parse(await readText(f.abs)); } catch { continue; }
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const known = [['three', 'three.js'], ['phaser', 'Phaser'], ['@babylonjs/core', 'Babylon.js'], ['babylonjs', 'Babylon.js'], ['pixi.js', 'PixiJS'], ['playcanvas', 'PlayCanvas'], ['excalibur', 'Excalibur'], ['kaboom', 'Kaboom'], ['electron', 'Electron'], ['react', 'React'], ['vue', 'Vue'], ['svelte', 'Svelte'], ['next', 'Next.js'], ['react-native', 'React Native']];
-    const found = known.filter(([d]) => deps[d]).map(([, n]) => n);
-    const starts = [...(typeof pkg.bin === 'string' ? [pkg.bin] : Object.values(pkg.bin ?? {})), ...['start', 'dev', 'serve'].map(k => String(pkg.scripts?.[k] ?? '').match(/\b(?:node|tsx|ts-node|bun|deno run)\s+(?:--?\S+\s+)*([^\s&|;]+\.[cm]?[jt]s)\b/)?.[1]).filter(Boolean)];
+    const found = JS_FRAMEWORKS.filter(([d]) => deps[d]).map(([, n]) => n);
+    const pkgDir = path.posix.dirname(f.rel) === '.' ? '' : path.posix.dirname(f.rel);
+    const starts = [...(typeof pkg.bin === 'string' ? [pkg.bin] : Object.values(pkg.bin ?? {})), ...['start', 'dev', 'serve'].map(k => scriptEntry(pkg.scripts?.[k])).filter(Boolean)];
+    // `bun run --cwd packages/cli src/index.ts` at the root starts a file in another package.
+    for (let i = 0; i < starts.length; i++) if (typeof starts[i] === 'string' && starts[i].startsWith('\0')) starts[i] = path.posix.relative(pkgDir || '.', starts[i].slice(1)) || starts[i].slice(1);
     add({ id: 'node', name: `Node.js package${found.length ? ` (${[...new Set(found)].join(', ')})` : ''}`, kind: 'project', root: path.posix.dirname(f.rel) === '.' ? '' : path.posix.dirname(f.rel), evidence: [f.rel], details: { name: pkg.name, main: pkg.main, bin: pkg.bin, starts: [...new Set(starts)], scripts: Object.keys(pkg.scripts ?? {}), frameworks: [...new Set(found)] } });
   }
+  if (pkgFiles.length > 1 || rels.some(r => /^(turbo|nx|lerna|rush)\.json$|^pnpm-workspace\.yaml$/.test(r))) {
+    let rootPkg = {};
+    if (has('package.json')) { try { rootPkg = JSON.parse(await readText(path.join(root, 'package.json'))); } catch { /* damaged */ } }
+    const { manager, tools } = workspaceTooling(rels, rootPkg);
+    const declared = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces?.packages ?? [];
+    if (declared.length || tools.length || pkgFiles.length > 2) {
+      add({ id: 'js-monorepo', name: `JavaScript/TypeScript monorepo (${[manager, ...tools].filter(Boolean).join(', ') || 'workspaces'})`, kind: 'project', evidence: ['package.json', ...rels.filter(r => /^(turbo|nx|lerna|rush)\.json$|^pnpm-workspace\.yaml$|^bun\.lockb?$/.test(r))].filter(r => rels.includes(r)), details: { packageManager: manager, tools, workspaces: declared, packages: pkgFiles.length, packagesListed: Math.min(pkgFiles.length, PKG_MAX) } });
+    }
+  }
   if (rels.some(r => /(^|\/)resources\/app\.asar$/i.test(r))) add({ id: 'electron-build', name: 'Electron app build', kind: 'build', evidence: rels.filter(r => /app\.asar$/i.test(r)).slice(0, 3) });
   if (find(/(^|\/)pubspec\.yaml$/).length) add({ id: 'flutter', name: 'Flutter / Dart', kind: 'project', evidence: find(/(^|\/)pubspec\.yaml$/).map(f => f.rel) });
-  if (find(/(^|\/)AndroidManifest\.xml$/).length) add({ id: 'android', name: 'Android app', kind: 'project', evidence: find(/(^|\/)AndroidManifest\.xml$/).slice(0, 3).map(f => f.rel) });
+  const depthOfRel = r => r.split('/').length;
+  const manifests = find(/(^|\/)AndroidManifest\.xml$/).map(f => f.rel).sort((a, b) => depthOfRel(a) - depthOfRel(b));
+  if (manifests.length) {
+    // The project root is the folder above src/main (and above app/ for a Gradle app module).
+    const root = path.posix.dirname(manifests[0]).replace(/(^|\/)src\/main$/, '').replace(/(^|\/)app$/, '');
+    add({ id: 'android', name: 'Android app', kind: 'project', root: root === '.' ? '' : root, evidence: manifests.slice(0, 3) });
+  }
   if (find(/\.xcodeproj\//).length) add({ id: 'xcode', name: 'Xcode project (Apple)', kind: 'project', evidence: [...new Set(find(/\.xcodeproj\//).map(f => f.rel.split('.xcodeproj/')[0] + '.xcodeproj'))].slice(0, 3) });
   if (find(/\.sln$/i).length && !engines.some(e => ['unity', 'godot'].includes(e.id))) add({ id: 'dotnet', name: '.NET solution', kind: 'project', evidence: find(/\.sln$/i).map(f => f.rel).slice(0, 3) });
   for (const [file, id, name] of [['go.mod', 'go', 'Go module'], ['CMakeLists.txt', 'cmake', 'CMake (C/C++)'], ['pyproject.toml', 'python', 'Python project'], ['setup.py', 'python', 'Python project'], ['requirements.txt', 'python', 'Python project'], ['pom.xml', 'maven', 'Maven (Java)'], ['build.gradle', 'gradle', 'Gradle (JVM)'], ['build.gradle.kts', 'gradle', 'Gradle (JVM)'], ['Makefile', 'make', 'Makefile build']]) {
@@ -148,7 +198,7 @@ export async function scanProject({ path: dir, maxFiles = 50000 } = {}) {
   }
   const engines = await detectEngines(abs, files);
   const depthOf = e => (e.root ? e.root.split('/').length : 0);
-  const primary = engines.filter(e => e.kind === 'project').sort((a, b) => depthOf(a) - depthOf(b))[0] ?? engines[0] ?? null;
+  const primary = engines.filter(e => e.kind === 'project').sort((a, b) => depthOf(a) - depthOf(b) || (b.id === 'js-monorepo') - (a.id === 'js-monorepo'))[0] ?? engines[0] ?? null;
   const entryPoints = [];
   for (const e of engines) {
     if (e.id === 'godot') {

package/port/src/skills.mjs

@@ -0,0 +1,41 @@
+// The skills that ship with this exact ReversePort version, served by the CLI.
+// An agent that runs `reverseport skills get <name>` always reads the guide that matches the binary it calls,
+// even when a copied SKILL.md in its own skills folder is older.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { RPError } from './util.mjs';
+
+const SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'skills');
+
+function frontmatter(text) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  const meta = {};
+  if (m) for (const line of m[1].split(/\r?\n/)) { const kv = line.match(/^([a-zA-Z_-]+):\s*(.*)$/); if (kv) meta[kv[1]] = kv[2].replace(/^["']|["']$/g, ''); }
+  return { meta, body: m ? text.slice(m[0].length) : text };
+}
+
+async function load(dir) {
+  let folders = [];
+  try { folders = (await fs.readdir(dir, { withFileTypes: true })).filter(d => d.isDirectory()).map(d => d.name).sort(); } catch { return []; }
+  const out = [];
+  for (const folder of folders) {
+    const file = path.join(dir, folder, 'SKILL.md');
+    let text;
+    try { text = await fs.readFile(file, 'utf8'); } catch { continue; } // a folder without SKILL.md is not a skill
+    const { meta, body } = frontmatter(text);
+    out.push({ name: meta.name || folder, description: meta.description ?? '', file, body: body.trim(), text });
+  }
+  return out;
+}
+
+export async function listSkills({ dir = SKILLS_DIR } = {}) {
+  return (await load(dir)).map(({ name, description }) => ({ name, description }));
+}
+
+export async function getSkill(name, { dir = SKILLS_DIR } = {}) {
+  const all = await load(dir);
+  const hit = all.find(s => s.name === name);
+  if (!hit) throw new RPError('INVALID_ARGUMENT', `${name ? `Unknown skill "${name}".` : 'Name a skill.'} Skills: ${all.map(s => s.name).join(', ') || '(none bundled)'}.`);
+  return hit;
+}

package/port/src/symbols.mjs

@@ -55,6 +55,25 @@ function lineIndex(text) {
 
 const all = (re, text) => [...text.matchAll(re)];
 
+/** `a::{b, c::{self, D}, *}` → `a::b`, `a::c`, `a::c::D`, `a`. Aliases (`as X`) and leading `::` are dropped. */
+export function expandRustUse(spec) {
+  const text = spec.replace(/\s+as\s+\w+/g, '').replace(/\s+/g, '').replace(/^::/, '');
+  const out = [];
+  const walk = (prefix, s) => {
+    const open = s.indexOf('{');
+    if (open < 0) { const p = `${prefix}${s}`.replace(/::(self|\*)$/, '').replace(/^(self|\*)$/, ''); if (p) out.push(p); return; }
+    let depth = 0, close = open;
+    for (; close < s.length; close++) { if (s[close] === '{') depth++; else if (s[close] === '}' && --depth === 0) break; }
+    const items = [];
+    let start = open + 1, level = 0;
+    for (let i = open + 1; i < close; i++) { if (s[i] === '{') level++; else if (s[i] === '}') level--; else if (s[i] === ',' && !level) { items.push(s.slice(start, i)); start = i + 1; } }
+    items.push(s.slice(start, close));
+    for (const item of items) if (item) walk(prefix + s.slice(0, open), item);
+  };
+  walk('', text);
+  return [...new Set(out)];
+}
+
 export function extractSymbols(text, language) {
   const code = stripComments(text, language);
   const line = lineIndex(code);
@@ -150,7 +169,9 @@ export function extractSymbols(text, language) {
       for (const m of all(/\bfn\s+(\w+)/g, code)) fn(m[1], m);
       for (const m of all(/\b(struct|enum|trait|union)\s+(\w+)/g, code)) cls(m[2], m, { kind: m[1] });
       for (const m of all(/^\s*(?:pub(?:\([^)]*\))?\s+)?mod\s+(\w+)\s*;/gm, code)) dep(m[1], 'mod');
-      for (const m of all(/^\s*(?:pub\s+)?use\s+([\w:]+)/gm, code)) dep(m[1], 'use');
+      // `use a::{b, c::{self, D}};` names every leaf; a `use super::…` that is indented sits in an inline
+      // `mod tests { … }`, whose parent is this file, so one `super` becomes `self`.
+      for (const m of all(/^([ \t]*)(?:pub(?:\([^)]*\))?\s+)?use\s+([^;]+);/gm, code)) for (const spec of expandRustUse(m[2])) dep(m[1] ? spec.replace(/^super(?=::|$)/, 'self') : spec, 'use');
       if (/\bfn\s+main\s*\(/.test(code)) out.entry = true;
       break;
     }

package/port/src/tools.mjs

@@ -35,7 +35,7 @@ export const tools = [
     description: 'Reconnaissance of a folder: detects the engine/framework (Godot, Unity, Unreal, GameMaker, RPG Maker, Ren\'Py, LÖVE, Defold, Bevy, MonoGame, three.js/Phaser/Electron, Flutter, .NET, Go, Rust, Python…) for source projects AND exported game builds, languages with line counts, file categories, entry points, biggest files and binaries. Start here.',
     inputSchema: obj({ path: str('Folder to scan.'), maxFiles: int('Stop after this many files (default 50000).', { minimum: 100, maximum: 500000 }) }, ['path']) },
   { name: 're_graph', brief: 'Dependency graph of a project: entry points, cycles, most-used files and the port order.', title: 'Dependency graph and port order',
-    description: 'Builds the dependency graph of a project: imports/includes/requires, Godot res:// loads and scene resources, Unity script/prefab GUIDs, and type references (C#, GDScript class_name/autoloads, Java…). Returns entry points, cycles, orphans, most-used files, external packages and the port order (dependencies first). format:"mermaid" adds a diagram.',
+    description: 'Builds the dependency graph of a project: imports/includes/requires, Godot res:// loads and scene resources, Unity script/prefab GUIDs, and type references (C#, GDScript class_name/autoloads, Java…). JS/TS monorepos: imports of workspace packages by name and tsconfig paths aliases resolve to their files, and a workspace section shows which package uses which. Returns entry points, cycles, orphans, most-used files, external packages and the port order (dependencies first). format:"mermaid" adds a diagram.',
     inputSchema: obj({ path: str('Project folder.'), limit: int('Files in portOrder (default 80; edges 40). Larger values return more.', { minimum: 10, maximum: 5000 }), format: str('json (default), mermaid or both.', { enum: ['json', 'mermaid', 'both'] }) }, ['path']) },
   { name: 're_symbols', brief: 'Classes, functions, signals and exported fields of a file or folder; match filters by name.', title: 'Classes, functions, signals',
     description: 'Code structure for one file or a whole folder (30+ languages: GDScript, C#, C/C++ incl. Unreal macros, Python, JS/TS, Lua, Java/Kotlin, Go, Rust, Swift, shaders, Ren\'Py…): classes with base classes, functions with lines, signals/events, exported/serialized fields, dependencies, node paths. match filters by name (substring or * wildcard).',
@@ -125,8 +125,8 @@ function validate(schema, args, where = 'arguments') {
       throw new RPError('INVALID_ARGUMENT', `Unknown argument ${hints.join(', ')}${where === 'arguments' ? '' : ` in ${where}`}. Allowed: ${allowed.join(', ')}.`);
     }
     for (const r of schema.required ?? []) if (args[r] === undefined || args[r] === null || args[r] === '') {
-      const d = schema.properties?.[r]?.description;
-      throw new RPError('INVALID_ARGUMENT', `Missing ${r}${d ? ` (${d.replace(/\.$/, '')})` : ''}.`);
+      const { description: d, enum: choices } = schema.properties?.[r] ?? {};
+      throw new RPError('INVALID_ARGUMENT', `Missing ${r}${d ? ` (${d.replace(/\.$/, '')})` : ''}.${choices ? ` One of: ${choices.join(', ')}.` : ''}`);
     }
     for (const [k, v] of Object.entries(args)) if (v !== undefined && v !== null && schema.properties?.[k]) validate(schema.properties[k], v, k);
     return;
@@ -181,7 +181,23 @@ function coerce(schema, value, adjusted = null, at = '') {
     }
   }
   if ((schema?.type === 'integer' && typeof value === 'string' && /^-?\d+$/.test(value.trim())) || (schema?.type === 'number' && typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)))) return Number(value);
-  if (schema?.type === 'boolean' && (value === 'true' || value === 'false')) return value === 'true';
+  if (schema?.type === 'boolean' && typeof value === 'string') {
+    const b = value.trim().toLowerCase();
+    if (b === 'true' || b === 'false') return b === 'true';
+    if (adjusted && ['yes', 'no', 'on', 'off', '1', '0'].includes(b)) { adjusted[at] = `read "${value}" as ${['yes', 'on', '1'].includes(b)}`; return ['yes', 'on', '1'].includes(b); }
+  }
+  if (schema?.type === 'boolean' && adjusted && (value === 1 || value === 0)) { adjusted[at] = `read ${value} as ${value === 1}`; return value === 1; }
+  // "Godot" for "godot", "Mermaid " for "mermaid": only when exactly one allowed value matches.
+  if (schema?.type === 'string' && Array.isArray(schema.enum) && typeof value === 'string' && !schema.enum.includes(value) && adjusted) {
+    const norm = x => String(x).trim().toLowerCase().replace(/[\s_-]+/g, '');
+    const hits = schema.enum.filter(e => norm(e) === norm(value));
+    if (hits.length === 1) { adjusted[at] = `read "${value}" as "${hits[0]}"`; return hits[0]; }
+  }
+  if (schema?.type === 'array' && typeof value === 'string' && adjusted) {
+    // A JSON list sent as text, or one value where a list is expected.
+    if (/^\s*\[/.test(value)) { try { const parsed = JSON.parse(value); if (Array.isArray(parsed)) { adjusted[at] = 'parsed the list from text'; return parsed.map((v, i) => coerce(schema.items, v, adjusted, `${at}[${i}]`)); } } catch { /* not JSON: validation explains */ } }
+    else if (schema.items?.type === 'string' && value.trim() !== '') { adjusted[at] = 'wrapped the single value in a list'; return [value]; }
+  }
   if (schema?.type === 'array' && Array.isArray(value)) return value.map((v, i) => coerce(schema.items, v, adjusted, `${at}[${i}]`));
   return value;
 }

package/port/src/util.mjs

@@ -15,8 +15,22 @@ export const IGNORED_DIRS = new Set([
   '.git', '.svn', '.hg', 'node_modules', '.godot', '.import', 'Library', 'Temp', 'Logs', 'UserSettings', 'obj',
   '__pycache__', '.venv', 'venv', '.gradle', '.idea', '.vs', '.vscode', 'DerivedDataCache', 'Intermediate', 'Saved',
   '.mono', '.reverseport', '.cache', '.next', '.nuxt', '.parcel-cache', '.turbo', 'Pods', '.dart_tool',
+  '.pytest_cache', '.mypy_cache', '.ruff_cache', '.tox', 'zig-cache', '.zig-cache', 'zig-out', 'DerivedData',
+  '.svelte-kit', '.angular', '.vite', '.expo', '.terraform', 'bower_components', 'jspm_packages',
 ]);
 
+/**
+ * Folders that are build output or a package store only next to a marker file: `target/` is Rust or Maven output
+ * beside Cargo.toml/pom.xml but may be real source elsewhere; `vendor/` holds copied dependencies beside go.mod,
+ * composer.json or a Gemfile.
+ */
+export const IGNORED_DIRS_BESIDE = {
+  target: ['Cargo.toml', 'pom.xml', 'build.sbt'],
+  vendor: ['go.mod', 'composer.json', 'Gemfile'],
+  '.build': ['Package.swift'],
+  '.gradle': [],
+};
+
 export async function statOrNull(file) { try { return await fs.stat(file); } catch { return null; } }
 
 export async function requireFile(file, what = 'file') {
@@ -88,7 +102,7 @@ export function isText(buf) {
 export const toPosix = p => p.split(path.sep).join('/');
 
 /** Walk a folder. Returns files with posix relative paths; skips IGNORED_DIRS and symlinks. */
-export async function walk(root, { maxFiles = 50000, ignore = IGNORED_DIRS, maxDepth = 40 } = {}) {
+export async function walk(root, { maxFiles = 50000, ignore = IGNORED_DIRS, ignoreBeside = ignore === IGNORED_DIRS ? IGNORED_DIRS_BESIDE : {}, maxDepth = 40 } = {}) {
   const files = [];
   const skipped = new Set();
   const unreadable = [];
@@ -98,12 +112,14 @@ export async function walk(root, { maxFiles = 50000, ignore = IGNORED_DIRS, maxD
     let entries;
     try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch (e) { if (unreadable.length < 50) unreadable.push({ path: toPosix(path.relative(root, dir)) || '.', code: e.code ?? 'ERROR' }); return; }
     entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const names = new Set(entries.map(e => e.name));
+    const buildOutput = name => ignoreBeside[name]?.some(marker => names.has(marker));
     for (const e of entries) {
       if (truncated) return;
       const abs = path.join(dir, e.name);
       if (e.isSymbolicLink()) continue;
       if (e.isDirectory()) {
-        if (ignore.has(e.name)) { skipped.add(toPosix(path.relative(root, abs))); continue; }
+        if (ignore.has(e.name) || buildOutput(e.name)) { skipped.add(toPosix(path.relative(root, abs))); continue; }
         await visit(abs, depth + 1);
       } else if (e.isFile()) {
         if (files.length >= maxFiles) { truncated = true; return; }

package/skills/reverse-engineer-anything/SKILL.md

@@ -34,7 +34,7 @@ original task after repair. Client approval, shell PATH, registration and engine
 availability have different remedies; avoid repeating setup for all of them.
 
 Prefer an existing `reverseport` CLI. When none is installed and ReversePort package acquisition
-is within the authorized scope, use `npx -y reverseport@1.3.0` in its place.
+is within the authorized scope, use `npx -y reverseport@1.5.0` in its place.
 Configuration repair starts with a read-only setup plan; show paths, backups and
 skill replacement before applying authorized changes. Preserve existing approval
 and target-execution boundaries. ReversePort setup never installs or upgrades unrelated