@nexrall/code-core 1.4.71 → 1.4.72

package/dist/tools/executor.js

@@ -206,9 +206,7 @@ function isCommandBlocked(command) {
 // even when the agent runs in a sub-context with a different cwd.
 function resolvePath(inputPath, workDir) {
     const base = workDir ?? process.cwd();
-    const resolved = path.isAbsolute(inputPath)
-        ? inputPath
-        : path.resolve(base, inputPath);
+    const resolved = path.isAbsolute(inputPath) ? inputPath : path.resolve(base, inputPath);
     // Path traversal guard: reject paths that escape the workspace root.
     // Absolute paths are allowed as-is (agent may legitimately reference /usr/bin etc.);
     // relative paths must stay within the resolved base.
@@ -253,7 +251,7 @@ function isBinaryFile(filePath) {
                 nonText++;
         }
         // >30% non-text ASCII control chars → binary  (was 10%, too aggressive)
-        return nonText / bytesRead > 0.30;
+        return nonText / bytesRead > 0.3;
     }
     catch {
         return false;
@@ -372,10 +370,12 @@ async function readFileWindowed(resolved, offset, requestedLimit) {
             sawEof = true;
             finish();
         });
-        stream.on('error', (err) => { if (!stopped) {
-            stopped = true;
-            resolve({ error: err.message });
-        } });
+        stream.on('error', (err) => {
+            if (!stopped) {
+                stopped = true;
+                resolve({ error: err.message });
+            }
+        });
     });
 }
 async function readFile(input, workDir) {
@@ -391,7 +391,9 @@ async function readFile(input, workDir) {
         // (isBinaryFile only samples the first 8KB, so this is cheap regardless of file size.)
         if (isBinaryFile(resolved)) {
             const ext = path.extname(resolved).toLowerCase();
-            return { error: `Cannot read binary file: ${resolved} (${ext || 'no extension'}). Use a text-based tool or convert it first.` };
+            return {
+                error: `Cannot read binary file: ${resolved} (${ext || 'no extension'}). Use a text-based tool or convert it first.`,
+            };
         }
         // No byte-size gate — a file of any size can be read; it's always streamed
         // line-by-line so memory is bounded regardless of file size (matches Claude
@@ -418,7 +420,9 @@ async function writeFile(input, workDir) {
         const isNew = !fs.existsSync(resolved);
         // Guard against accidentally overwriting an existing file with empty content
         if (!isNew && content === '') {
-            return { error: `Refusing to overwrite ${resolved} with empty content. Provide the full file content or use edit_file for targeted changes.` };
+            return {
+                error: `Refusing to overwrite ${resolved} with empty content. Provide the full file content or use edit_file for targeted changes.`,
+            };
         }
         // Edit-completeness guard: refuse writes that elide code with a placeholder
         // ("// ... rest of the code unchanged") — a silent, irreversible data loss —
@@ -428,9 +432,13 @@ async function writeFile(input, workDir) {
             const problem = (0, editCompleteness_1.checkEditCompleteness)(content, !isNew);
             if (problem) {
                 if (problem.kind === 'elision-placeholder') {
-                    return { error: `Refusing to write ${resolved}: ${problem.reason}.\nOffending line: ${problem.sample}\nwrite_file must contain the COMPLETE file — never a "rest unchanged" placeholder. Send the full content, or use edit_file/multi_edit for a targeted change so surrounding code is preserved.` };
+                    return {
+                        error: `Refusing to write ${resolved}: ${problem.reason}.\nOffending line: ${problem.sample}\nwrite_file must contain the COMPLETE file — never a "rest unchanged" placeholder. Send the full content, or use edit_file/multi_edit for a targeted change so surrounding code is preserved.`,
+                    };
                 }
-                return { error: `Refusing to write ${resolved}: ${problem.reason}.\nOffending line: ${problem.sample}\nResolve the conflict (remove <<<<<<< / ======= / >>>>>>> markers and keep the intended code) before writing.` };
+                return {
+                    error: `Refusing to write ${resolved}: ${problem.reason}.\nOffending line: ${problem.sample}\nResolve the conflict (remove <<<<<<< / ======= / >>>>>>> markers and keep the intended code) before writing.`,
+                };
             }
         }
         // Preserve file permissions (mode bits) when overwriting an existing file.
@@ -441,11 +449,15 @@ async function writeFile(input, workDir) {
             try {
                 existingMode = fs.statSync(resolved).mode;
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             try {
                 priorContent = fs.readFileSync(resolved, 'utf-8');
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }
         // Atomic (temp + rename), matching edit_file/multi_edit. A plain
         // writeFileSync on the target truncates it first and then streams the
@@ -465,7 +477,11 @@ async function writeFile(input, workDir) {
         const sec = (0, securityLint_1.securityNoteText)((0, securityLint_1.checkSecurity)(content));
         if (isNew) {
             // A brand-new file has no "removed" side — every line is an addition.
-            return { output: `Created ${resolved} (${lines} lines, ${bytes} bytes)${sec}`, linesAdded: lines, linesRemoved: 0 };
+            return {
+                output: `Created ${resolved} (${lines} lines, ${bytes} bytes)${sec}`,
+                linesAdded: lines,
+                linesRemoved: 0,
+            };
         }
         const xfile = await crossFileBreakageWarning(resolved, normalizeLF(priorContent), normalizeLF(content), workDir ?? process.cwd());
         // Reward-hacking guard: a write_file that OVERWRITES an existing test file can
@@ -520,7 +536,9 @@ async function writeDocx(input, workDir) {
     const title = typeof input.title === 'string' ? input.title : undefined;
     const paragraphsRaw = input.paragraphs;
     if (!Array.isArray(paragraphsRaw) || paragraphsRaw.length === 0) {
-        return { error: 'Missing or empty required parameter: paragraphs (array of { text, heading?, bold?, italic?, bullet?, align? })' };
+        return {
+            error: 'Missing or empty required parameter: paragraphs (array of { text, heading?, bold?, italic?, bullet?, align? })',
+        };
     }
     try {
         // Loaded lazily so the (fairly large) docx/exceljs/pptxgenjs packages
@@ -529,14 +547,18 @@ async function writeDocx(input, workDir) {
         // the client: esbuild-bundled clients (VS Code, desktop) inline them,
         // while the CLI keeps all three external as runtime dependencies (see
         // packages/cli/build.js) so their real versions stay visible to audits.
-        const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType, } = await Promise.resolve().then(() => __importStar(require('docx')));
+        const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType } = await Promise.resolve().then(() => __importStar(require('docx')));
         const headingMap = {
-            1: HeadingLevel.HEADING_1, 2: HeadingLevel.HEADING_2,
-            3: HeadingLevel.HEADING_3, 4: HeadingLevel.HEADING_4,
+            1: HeadingLevel.HEADING_1,
+            2: HeadingLevel.HEADING_2,
+            3: HeadingLevel.HEADING_3,
+            4: HeadingLevel.HEADING_4,
         };
         const alignMap = {
-            left: AlignmentType.LEFT, center: AlignmentType.CENTER,
-            right: AlignmentType.RIGHT, justify: AlignmentType.JUSTIFIED,
+            left: AlignmentType.LEFT,
+            center: AlignmentType.CENTER,
+            right: AlignmentType.RIGHT,
+            justify: AlignmentType.JUSTIFIED,
         };
         const children = [];
         if (title) {
@@ -557,7 +579,9 @@ async function writeDocx(input, workDir) {
         const resolved = resolvePath(filePath, workDir);
         const isNew = !fs.existsSync(resolved);
         atomicWriteBuffer(resolved, buffer);
-        return { output: `${isNew ? 'Created' : 'Overwrote'} ${resolved} (${paragraphsRaw.length} paragraph(s), ${buffer.length} bytes)` };
+        return {
+            output: `${isNew ? 'Created' : 'Overwrote'} ${resolved} (${paragraphsRaw.length} paragraph(s), ${buffer.length} bytes)`,
+        };
     }
     catch (err) {
         return { error: `Failed to write .docx: ${err.message}` };
@@ -597,7 +621,9 @@ async function writeXlsx(input, workDir) {
             }
         }
         else if (mode === 'edit' && isNew) {
-            return { error: `mode: 'edit' but ${resolved} does not exist yet — use mode: 'create' (or omit mode) for a new file.` };
+            return {
+                error: `mode: 'edit' but ${resolved} does not exist yet — use mode: 'create' (or omit mode) for a new file.`,
+            };
         }
         let sheetsTouched = 0;
         for (const raw of sheetsRaw) {
@@ -675,7 +701,9 @@ async function writePptx(input, workDir) {
         // can still go through the same atomic temp+rename write as the other two.
         const buffer = (await pres.write({ outputType: 'nodebuffer' }));
         atomicWriteBuffer(resolved, buffer);
-        return { output: `${isNew ? 'Created' : 'Overwrote'} ${resolved} (${slidesRaw.length} slide(s), ${buffer.length} bytes)` };
+        return {
+            output: `${isNew ? 'Created' : 'Overwrote'} ${resolved} (${slidesRaw.length} slide(s), ${buffer.length} bytes)`,
+        };
     }
     catch (err) {
         return { error: `Failed to write .pptx: ${err.message}` };
@@ -752,11 +780,26 @@ function startBackgroundShell(command, displayCommand, workDir, note) {
     // unconditional `read` guard, an interactive installer step) blocks
     // forever instead of getting an immediate EOF, and the "shell" just sits
     // there as 'running' with zero output forever.
-    const child = (0, child_process_1.spawn)(command, { shell: true, cwd: workDir ?? process.cwd(), env: process.env, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    const child = (0, child_process_1.spawn)(command, {
+        shell: true,
+        cwd: workDir ?? process.cwd(),
+        env: process.env,
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
     const shell = {
-        id, command: displayCommand, child, output: '', readCursor: 0, truncated: false,
-        status: 'running', exitCode: null,
-        spillPath: null, spillFd: null, spillBytes: 0, spillFull: false,
+        id,
+        command: displayCommand,
+        child,
+        output: '',
+        readCursor: 0,
+        truncated: false,
+        status: 'running',
+        exitCode: null,
+        spillPath: null,
+        spillFd: null,
+        spillBytes: 0,
+        spillFull: false,
     };
     // Rolling buffer: keep the LAST MAX_OUTPUT_CHARS instead of the first, so a
     // long-lived watcher/dev-server's recent output (the useful part) is never
@@ -790,7 +833,9 @@ function startBackgroundShell(command, displayCommand, workDir, note) {
                         if (buf.length > room)
                             shell.spillFull = true;
                     }
-                    catch { /* degrade to inline-only */ }
+                    catch {
+                        /* degrade to inline-only */
+                    }
                 }
             }
         }
@@ -825,7 +870,9 @@ function startBackgroundShell(command, displayCommand, workDir, note) {
             try {
                 fs.closeSync(shell.spillFd);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             shell.spillFd = null;
         }
         // Evict oldest exited shell once map grows past 50 to prevent session-long leak
@@ -838,10 +885,15 @@ function startBackgroundShell(command, displayCommand, workDir, note) {
             }
         }
     });
-    child.on('error', (err) => { append(`\n[spawn error: ${err.message}]`); shell.status = 'exited'; });
+    child.on('error', (err) => {
+        append(`\n[spawn error: ${err.message}]`);
+        shell.status = 'exited';
+    });
     _bgShells.set(id, shell);
     const noteLine = note ? `\n[${note}]` : '';
-    return { output: `Started background shell ${id}: ${displayCommand}${noteLine}\nUse bash_output with shell_id "${id}" to read output, kill_shell to stop it.` };
+    return {
+        output: `Started background shell ${id}: ${displayCommand}${noteLine}\nUse bash_output with shell_id "${id}" to read output, kill_shell to stop it.`,
+    };
 }
 async function bashOutput(input) {
     const id = typeof input.shell_id === 'string' ? input.shell_id : '';
@@ -878,13 +930,17 @@ async function killShell(input) {
                 try {
                     shell.child.kill(sig);
                 }
-                catch { /* already dead */ }
+                catch {
+                    /* already dead */
+                }
             }
         };
         killTree('SIGTERM');
         // Escalate to SIGKILL after 3 s if process group is still alive
-        setTimeout(() => { if (shell.status === 'killed')
-            killTree('SIGKILL'); }, 3000);
+        setTimeout(() => {
+            if (shell.status === 'killed')
+                killTree('SIGKILL');
+        }, 3000);
     }
     return { output: `Background shell ${id} ${shell.status}.` };
 }
@@ -971,7 +1027,9 @@ async function bash(input, abortSignal, sandbox, workDir, onStream) {
                 try {
                     child.kill(sig);
                 }
-                catch { /* already dead */ }
+                catch {
+                    /* already dead */
+                }
             }
         };
         // Keep HEAD + TAIL rather than head-only: test runners print the failure
@@ -1020,14 +1078,18 @@ async function bash(input, abortSignal, sandbox, workDir, onStream) {
                 if (buf.length > room)
                     spillFull = true;
             }
-            catch { /* disk full / closed — degrade to inline-only */ }
+            catch {
+                /* disk full / closed — degrade to inline-only */
+            }
         };
         const closeSpill = () => {
             if (spillFd !== null) {
                 try {
                     fs.closeSync(spillFd);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
                 spillFd = null;
             }
         };
@@ -1088,7 +1150,11 @@ async function bash(input, abortSignal, sandbox, workDir, onStream) {
             if (timedOut) {
                 // Return the partial output alongside the error — it usually holds the
                 // reason the command hung (a stuck test, a prompt, a slow step).
-                resolve(prependNote({ error: `Command timed out after ${timeoutMs}ms`, interrupted: true, output: body ? `Partial output before timeout:\n${body}` : undefined }));
+                resolve(prependNote({
+                    error: `Command timed out after ${timeoutMs}ms`,
+                    interrupted: true,
+                    output: body ? `Partial output before timeout:\n${body}` : undefined,
+                }));
             }
             else if (abortSignal?.aborted) {
                 resolve({ error: 'Command stopped by user', interrupted: true, output: body || undefined });
@@ -1116,7 +1182,9 @@ async function bash(input, abortSignal, sandbox, workDir, onStream) {
             try {
                 onStream?.(text);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         });
         child.stderr?.on('data', (chunk) => {
             const text = chunk.toString('utf-8');
@@ -1124,7 +1192,9 @@ async function bash(input, abortSignal, sandbox, workDir, onStream) {
             try {
                 onStream?.(text);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         });
         child.on('close', (code, signal) => done(code, signal));
         child.on('error', (err) => {
@@ -1138,8 +1208,10 @@ async function bash(input, abortSignal, sandbox, workDir, onStream) {
             if (settled)
                 return;
             killTree('SIGTERM');
-            setTimeout(() => { if (!settled)
-                killTree('SIGKILL'); }, 3000);
+            setTimeout(() => {
+                if (!settled)
+                    killTree('SIGKILL');
+            }, 3000);
             done(null, null, true);
         }, timeoutMs);
         child.on('close', () => clearTimeout(timer));
@@ -1173,7 +1245,9 @@ function capExternalOutput(output, label, maxChars = MAX_OUTPUT_CHARS) {
         fs.writeFileSync(spillPath, (0, safeSlice_1.sliceSafeEnd)(output, MAX_SPILL_BYTES));
         spillNote = ` Full output (${output.length} chars) saved to ${spillPath} — use read_file with offset/limit to inspect any section.`;
     }
-    catch { /* spill is best-effort */ }
+    catch {
+        /* spill is best-effort */
+    }
     const headLen = Math.floor(maxChars * 0.7);
     const tailLen = maxChars - headLen;
     const omitted = output.length - headLen - tailLen;
@@ -1207,7 +1281,9 @@ function runCapture(cmd, args, opts) {
             try {
                 child.kill('SIGTERM');
             }
-            catch { /* already gone */ }
+            catch {
+                /* already gone */
+            }
         };
         const timer = setTimeout(() => kill('ETIMEDOUT'), opts.timeout);
         child.stdout.setEncoding('utf-8');
@@ -1224,10 +1300,15 @@ function runCapture(cmd, args, opts) {
             }
             stdout += chunk;
         });
-        child.stderr.on('data', (chunk) => { if (stderr.length < 64 * 1024)
-            stderr += chunk; });
-        child.on('error', (e) => { if (!error)
-            error = e; finish(null, null); });
+        child.stderr.on('data', (chunk) => {
+            if (stderr.length < 64 * 1024)
+                stderr += chunk;
+        });
+        child.on('error', (e) => {
+            if (!error)
+                error = e;
+            finish(null, null);
+        });
         child.on('close', (code, signal) => finish(code, signal));
     });
 }
@@ -1268,27 +1349,33 @@ async function crossFileBreakageWarning(editedAbsPath, oldContent, newContent, w
         return '';
     let removed;
     try {
-        removed = (0, crossFile_1.findRemovedExports)(editedAbsPath, oldContent, newContent)
-            .filter((s) => (0, crossFile_1.isCheckableSymbol)(s.name));
+        removed = (0, crossFile_1.findRemovedExports)(editedAbsPath, oldContent, newContent).filter((s) => (0, crossFile_1.isCheckableSymbol)(s.name));
     }
     catch {
         return '';
     }
     if (!removed.length)
         return '';
-    const editedReal = (() => { try {
-        return fs.realpathSync(editedAbsPath);
-    }
-    catch {
-        return editedAbsPath;
-    } })();
+    const editedReal = (() => {
+        try {
+            return fs.realpathSync(editedAbsPath);
+        }
+        catch {
+            return editedAbsPath;
+        }
+    })();
     const hits = [];
     const MAX_SYMBOLS = 8;
     // Scans run concurrently (they used to be up to 8 sequential blocking rg calls).
-    const scanned = await Promise.all(removed.slice(0, MAX_SYMBOLS).map(async (sym) => ({ sym, refs: await scanReferences(sym.name, workDir, editedReal) })));
+    const scanned = await Promise.all(removed
+        .slice(0, MAX_SYMBOLS)
+        .map(async (sym) => ({ sym, refs: await scanReferences(sym.name, workDir, editedReal) })));
     for (const { sym, refs } of scanned) {
         if (refs.length) {
-            const shown = refs.slice(0, 3).map((r) => `      ${r}`).join('\n');
+            const shown = refs
+                .slice(0, 3)
+                .map((r) => `      ${r}`)
+                .join('\n');
             const more = refs.length > 3 ? `\n      … and ${refs.length - 3} more` : '';
             hits.push(`  • ${sym.kind} "${sym.name}" (removed/renamed) still referenced in:\n${shown}${more}`);
         }
@@ -1308,8 +1395,16 @@ async function scanReferences(name, workDir, excludeRealPath) {
         const opts = { cwd: workDir, timeout: 8000, maxBuffer: 8 * 1024 * 1024 };
         const r = ripgrepAvailable()
             ? await runCapture(rgBin(), ['-l', '--no-messages', '-e', pattern, '.'], opts)
-            : await runCapture('grep', ['-rlI', '--exclude-dir=node_modules', '--exclude-dir=.git',
-                '--exclude-dir=dist', '--exclude-dir=.next', '-E', pattern, '.'], opts);
+            : await runCapture('grep', [
+                '-rlI',
+                '--exclude-dir=node_modules',
+                '--exclude-dir=.git',
+                '--exclude-dir=dist',
+                '--exclude-dir=.next',
+                '-E',
+                pattern,
+                '.',
+            ], opts);
         if (r.stdout)
             for (const line of r.stdout.split('\n')) {
                 if (line.trim())
@@ -1326,7 +1421,9 @@ async function scanReferences(name, workDir, excludeRealPath) {
         try {
             real = fs.realpathSync(abs);
         }
-        catch { /* keep abs */ }
+        catch {
+            /* keep abs */
+        }
         if (real === excludeRealPath)
             continue; // the file we just edited
         rel.push(path.relative(workDir, abs) || f);
@@ -1341,7 +1438,7 @@ async function searchFiles(input, workDir) {
     // Default is "files" (paths of matching files only), like Claude Code's Grep
     // files_with_matches: a content dump of a common pattern was ~50× larger. Asking for
     // context_lines implies the caller wants content.
-    const searchType = typeof input.type === 'string' ? input.type : (contextLines > 0 ? 'content' : 'files');
+    const searchType = typeof input.type === 'string' ? input.type : contextLines > 0 ? 'content' : 'files';
     const filesOnly = searchType === 'files' || searchType === 'files_with_matches';
     const include = typeof input.include === 'string' ? input.include : ''; // e.g. "*.ts"
     if (!pattern)
@@ -1363,18 +1460,24 @@ async function searchFiles(input, workDir) {
                 const rel = path.relative(resolved, filePath).replace(/\\/g, '/');
                 const relLower = rel.toLowerCase();
                 // Support glob-style wildcards (* and ?) in addition to substring + regex
-                if (nameLower.includes(patternLower) || matchesGlob(name, pattern) || matchesPattern(name, pattern) ||
-                    relLower.includes(patternLower) || matchesGlob(rel, pattern) || matchesPattern(rel, pattern)) {
+                if (nameLower.includes(patternLower) ||
+                    matchesGlob(name, pattern) ||
+                    matchesPattern(name, pattern) ||
+                    relLower.includes(patternLower) ||
+                    matchesGlob(rel, pattern) ||
+                    matchesPattern(rel, pattern)) {
                     matches.push(filePath);
                 }
             });
             if (matches.length === 0)
                 return { output: 'No matching files found.' };
             const relBase = workDir ? path.resolve(workDir) : process.cwd();
-            let out = matches.map((f) => {
+            let out = matches
+                .map((f) => {
                 const r = path.relative(relBase, f);
                 return r.startsWith('..') || path.isAbsolute(r) ? f : r.replace(/\\/g, '/');
-            }).join('\n');
+            })
+                .join('\n');
             if (out.length > MAX_OUTPUT_CHARS)
                 out = (0, safeSlice_1.sliceSafeEnd)(out, MAX_OUTPUT_CHARS) + '\n[Truncated]';
             if (listing.truncated)
@@ -1394,15 +1497,24 @@ async function searchFiles(input, workDir) {
             const base = workDir ? path.resolve(workDir) : process.cwd();
             const relTarget = path.relative(base, resolved);
             const inside = !relTarget.startsWith('..') && !path.isAbsolute(relTarget);
-            const target = inside ? (relTarget || '.') : resolved;
+            const target = inside ? relTarget || '.' : resolved;
             const spawnOpts = { timeout: DEFAULT_TIMEOUT_MS, maxBuffer: SEARCH_MAX_BUFFER, cwd: base };
             let result;
             if (ripgrepAvailable()) {
                 const args = filesOnly
                     ? ['--files-with-matches', '--color=never', '--hidden', '--glob', '!.git']
-                    : ['--line-number', '--no-heading', '--color=never', '--hidden', '--glob', '!.git',
+                    : [
+                        '--line-number',
+                        '--no-heading',
+                        '--color=never',
+                        '--hidden',
+                        '--glob',
+                        '!.git',
                         // One minified-bundle hit could otherwise fill the whole output cap.
-                        '--max-columns', '500', '--max-columns-preview'];
+                        '--max-columns',
+                        '500',
+                        '--max-columns-preview',
+                    ];
                 if (ignoreCase)
                     args.push('-i');
                 if (contextLines > 0 && !filesOnly)
@@ -1446,12 +1558,16 @@ async function searchFiles(input, workDir) {
                 // first misreported a too-large result as a timeout.
                 if (spawnErr.code === 'ETIMEDOUT' || (result.signal === 'SIGTERM' && spawnErr.code !== 'ENOBUFS')) {
                     const partial = output ? `\n\nPartial results before timeout:\n${globalCapMatches(output)}` : '';
-                    return { error: `Search timed out after ${Math.round(DEFAULT_TIMEOUT_MS / 1000)}s — narrow the path or pattern (or add an "include" filter).${partial}` };
+                    return {
+                        error: `Search timed out after ${Math.round(DEFAULT_TIMEOUT_MS / 1000)}s — narrow the path or pattern (or add an "include" filter).${partial}`,
+                    };
                 }
                 if (spawnErr.code === 'ENOBUFS') {
                     // We still captured up to maxBuffer of output — return the capped head
                     // instead of failing blind.
-                    return { output: `${globalCapMatches(output)}\n[Too many matches — output exceeded ${SEARCH_MAX_BUFFER / (1024 * 1024)}MB and was capped. Narrow the pattern/path.]` };
+                    return {
+                        output: `${globalCapMatches(output)}\n[Too many matches — output exceeded ${SEARCH_MAX_BUFFER / (1024 * 1024)}MB and was capped. Narrow the pattern/path.]`,
+                    };
                 }
                 return { error: `search failed: ${spawnErr.message}` };
             }
@@ -1475,10 +1591,12 @@ async function searchFiles(input, workDir) {
                     return { output: 'No matches found.' };
                 const shown = files.slice(0, MAX_GLOB_RESULTS);
                 const more = files.length > shown.length
-                    ? `\n[${files.length - shown.length} more files not shown — narrow the pattern/path]` : '';
+                    ? `\n[${files.length - shown.length} more files not shown — narrow the pattern/path]`
+                    : '';
                 return {
                     output: `${files.length} file(s) contain matches (type="content" for the matching lines):\n` +
-                        shown.join('\n') + more,
+                        shown.join('\n') +
+                        more,
                 };
             }
             output = globalCapMatches(output);
@@ -1515,7 +1633,12 @@ function globalCapMatches(output) {
 function matchesGlob(name, pattern) {
     // Convert simple glob (* → .*, ? → .) to regex
     try {
-        const re = new RegExp('^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i');
+        const re = new RegExp('^' +
+            pattern
+                .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+                .replace(/\*/g, '.*')
+                .replace(/\?/g, '.') +
+            '$', 'i');
         return re.test(name);
     }
     catch {
@@ -1538,9 +1661,27 @@ function matchesPattern(name, pattern) {
 // Noise directories never worth walking. .venv/venv matter most: a single Python virtualenv
 // is hundreds of MB of third-party files that drowned glob / filename-search results.
 const WALK_SKIP_DIRS = new Set([
-    '.git', 'node_modules', 'dist', '.next', '__pycache__', '.turbo', 'coverage',
-    '.venv', 'venv', '.tox', '.mypy_cache', '.pytest_cache', '.ruff_cache', '.gradle',
-    '.cache', '.parcel-cache', '.svelte-kit', '.nuxt', 'target', '.idea', '.DS_Store',
+    '.git',
+    'node_modules',
+    'dist',
+    '.next',
+    '__pycache__',
+    '.turbo',
+    'coverage',
+    '.venv',
+    'venv',
+    '.tox',
+    '.mypy_cache',
+    '.pytest_cache',
+    '.ruff_cache',
+    '.gradle',
+    '.cache',
+    '.parcel-cache',
+    '.svelte-kit',
+    '.nuxt',
+    'target',
+    '.idea',
+    '.DS_Store',
 ]);
 /** Hard ceiling on files visited by the fallback directory walk (no ripgrep). */
 const WALK_MAX_FILES = 50000;
@@ -1571,7 +1712,10 @@ async function listFiles(root) {
         // Exit 2 = "some path errored" (a symlink loop, an unreadable dir) — the list of
         // everything else is still complete, so keep it rather than re-walking the tree.
         if (!r.error && (r.status === 0 || r.status === 1 || (r.status === 2 && r.stdout))) {
-            const files = r.stdout.split('\n').filter(Boolean).map((f) => path.join(root, f.replace(/^\.\//, '')));
+            const files = r.stdout
+                .split('\n')
+                .filter(Boolean)
+                .map((f) => path.join(root, f.replace(/^\.\//, '')));
             return { files, truncated: false };
         }
         // Anything else (timeout, overflow, spawn failure): fall through to the walk.
@@ -1603,14 +1747,16 @@ function walkDir(dirPath, callback, _visited = new Set()) {
             const fullPath = path.join(dirPath, entry.name);
             // isDirectory() returns false for symlinks — use isSymbolicLink() to detect
             // symlinked directories and walk them too (with cycle protection above).
-            const isDir = entry.isDirectory() || (entry.isSymbolicLink() && (() => {
-                try {
-                    return fs.statSync(fullPath).isDirectory();
-                }
-                catch {
-                    return false;
-                }
-            })());
+            const isDir = entry.isDirectory() ||
+                (entry.isSymbolicLink() &&
+                    (() => {
+                        try {
+                            return fs.statSync(fullPath).isDirectory();
+                        }
+                        catch {
+                            return false;
+                        }
+                    })());
             if (isDir) {
                 // Skip common noise directories
                 if (WALK_SKIP_DIRS.has(entry.name))
@@ -1715,7 +1861,9 @@ function preflightEdit(resolved) {
     if (stat.isDirectory())
         return { error: `Path is a directory, not a file: ${resolved}.` };
     if (stat.size > MAX_EDIT_BYTES) {
-        return { error: `File too large to edit (${(stat.size / 1024 / 1024).toFixed(1)} MB, max ${MAX_EDIT_BYTES / 1024 / 1024} MB). Use bash (sed/awk) for very large files.` };
+        return {
+            error: `File too large to edit (${(stat.size / 1024 / 1024).toFixed(1)} MB, max ${MAX_EDIT_BYTES / 1024 / 1024} MB). Use bash (sed/awk) for very large files.`,
+        };
     }
     if (isBinaryFile(resolved)) {
         return { error: `Refusing to edit binary file ${resolved} — a text replace would corrupt it.` };
@@ -1782,7 +1930,9 @@ function atomicWrite(resolved, data, mode) {
                 try {
                     fs.chmodSync(target, mode);
                 }
-                catch { /* non-fatal */ }
+                catch {
+                    /* non-fatal */
+                }
             }
             return;
         }
@@ -1791,7 +1941,9 @@ function atomicWrite(resolved, data, mode) {
         try {
             fs.rmSync(tmp, { force: true });
         }
-        catch { /* best effort */ }
+        catch {
+            /* best effort */
+        }
         throw err;
     }
     // ── Commit ───────────────────────────────────────────────────────────────
@@ -1800,7 +1952,9 @@ function atomicWrite(resolved, data, mode) {
             try {
                 fs.chmodSync(tmp, mode);
             }
-            catch { /* non-fatal — keep going */ }
+            catch {
+                /* non-fatal — keep going */
+            }
         }
         fs.renameSync(tmp, target);
     }
@@ -1811,7 +1965,9 @@ function atomicWrite(resolved, data, mode) {
         try {
             fs.rmSync(tmp, { force: true });
         }
-        catch { /* best effort */ }
+        catch {
+            /* best effort */
+        }
         throw err;
     }
 }
@@ -1847,7 +2003,9 @@ async function editFile(input, workDir) {
             return { error: `old_string not found in ${resolved}. Read the file first to verify the exact text to replace.` };
         }
         if (count > 1) {
-            return { error: `old_string appears ${count} times in ${resolved} — it must be unique. Add more surrounding context to make it unambiguous.` };
+            return {
+                error: `old_string appears ${count} times in ${resolved} — it must be unique. Add more surrounding context to make it unambiguous.`,
+            };
         }
         let updated = literalReplace(origNorm, oldNorm, newNorm);
         if (wasCRLF)
@@ -1909,7 +2067,9 @@ async function deleteFile(input, workDir) {
         const resolved = resolvePath(filePath, workDir);
         const stat = fs.statSync(resolved);
         if (stat.isDirectory()) {
-            return { error: `Path is a directory, not a file: ${resolved}. Use a recursive delete tool or remove contents first.` };
+            return {
+                error: `Path is a directory, not a file: ${resolved}. Use a recursive delete tool or remove contents first.`,
+            };
         }
         fs.unlinkSync(resolved);
         return { output: `Deleted: ${resolved}` };
@@ -1920,7 +2080,7 @@ async function deleteFile(input, workDir) {
 }
 // Strip HTML tags → readable plain text (like Claude Code's WebFetch)
 function stripHtml(html) {
-    return html
+    return (html
         // Remove <script> and <style> blocks entirely
         .replace(/<script[\s\S]*?<\/script>/gi, '')
         .replace(/<style[\s\S]*?<\/style>/gi, '')
@@ -1935,10 +2095,15 @@ function stripHtml(html) {
         // Remove all remaining tags
         .replace(/<[^>]+>/g, '')
         // Decode common HTML entities
-        .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
         // Collapse 3+ blank lines → 2
         .replace(/\n{3,}/g, '\n\n')
-        .trim();
+        .trim());
 }
 const MAX_REDIRECTS = 10;
 const FETCH_USER_AGENT = 'Nexrall-Code/1.0 (+https://nexrall.com)';
@@ -2058,7 +2223,10 @@ function fetchBlocklistCheck(parsedUrl) {
     if (!raw)
         return null;
     const host = parsedUrl.hostname.toLowerCase().replace(/^\[|\]$/g, '');
-    const entries = raw.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const entries = raw
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter(Boolean);
     for (const entry of entries) {
         if (host === entry || host.endsWith(`.${entry}`)) {
             return `Refusing to fetch "${host}" — blocked by NEXRALL_FETCH_BLOCKLIST (matched "${entry}").`;
@@ -2090,9 +2258,14 @@ async function fetchUrlTool(input, workDir, abortSignal) {
         try {
             json = JSON.parse(r.body);
         }
-        catch { /* fall through */ }
+        catch {
+            /* fall through */
+        }
         if (r.status !== 200 || !json.text) {
-            return { ...raw, output: `${raw.output ?? ''}\n\n[prompt extraction unavailable (${json.error ?? `HTTP ${r.status}`}) — raw page text shown instead]` };
+            return {
+                ...raw,
+                output: `${raw.output ?? ''}\n\n[prompt extraction unavailable (${json.error ?? `HTTP ${r.status}`}) — raw page text shown instead]`,
+            };
         }
         return {
             output: `[Answer extracted from ${capture.url ?? input.url} by ${json.model ?? 'a low-cost model'} for: "${prompt.slice(0, 200)}"]\n\n` +
@@ -2102,7 +2275,10 @@ async function fetchUrlTool(input, workDir, abortSignal) {
     catch (err) {
         if (err.name === 'AbortError')
             return { error: 'fetch_url stopped by user', interrupted: true };
-        return { ...raw, output: `${raw.output ?? ''}\n\n[prompt extraction failed (${err.message}) — raw page text shown instead]` };
+        return {
+            ...raw,
+            output: `${raw.output ?? ''}\n\n[prompt extraction failed (${err.message}) — raw page text shown instead]`,
+        };
     }
 }
 async function fetchUrl(input, _workDir, _redirectCount = 0, abortSignal, 
@@ -2147,9 +2323,13 @@ capture) {
             return dns.lookup(hostname, options, (err, address, family) => {
                 if (err)
                     return callback(err, address, family);
-                const addrs = Array.isArray(address) ? address.map((a) => a.address) : [address];
+                const addrs = Array.isArray(address)
+                    ? address.map((a) => a.address)
+                    : [address];
                 if (!allowLocal && addrs.some((a) => isPrivateIp(a))) {
-                    return callback(Object.assign(new Error('SSRF guard: host resolved to a private address at connect time'), { code: 'ESSRFBLOCKED' }), address, family);
+                    return callback(Object.assign(new Error('SSRF guard: host resolved to a private address at connect time'), {
+                        code: 'ESSRFBLOCKED',
+                    }), address, family);
                 }
                 return callback(null, address, family);
             });
@@ -2193,7 +2373,7 @@ capture) {
             headers: {
                 'User-Agent': FETCH_USER_AGENT,
                 'Accept-Encoding': 'identity', // opt-out of gzip/deflate — we read raw Buffer as UTF-8
-                'Accept': 'text/html,text/plain,application/json,*/*',
+                Accept: 'text/html,text/plain,application/json,*/*',
             },
         }, (res) => {
             // Follow redirects (301/302/307/308) with depth counter to prevent infinite loops
@@ -2237,7 +2417,9 @@ capture) {
                 // (anyone can put "ignore previous instructions..." on a page). Wrap it in an
                 // explicit untrusted-data delimiter so the model treats it as DATA to read, not
                 // as instructions to follow — defense-in-depth alongside the system-prompt rule.
-                finish({ output: `HTTP ${status}\n\n<untrusted_web_content url="${url}">\n${body}${truncNote}\n</untrusted_web_content>` });
+                finish({
+                    output: `HTTP ${status}\n\n<untrusted_web_content url="${url}">\n${body}${truncNote}\n</untrusted_web_content>`,
+                });
             };
             res.on('data', (chunk) => {
                 if (totalBytes + chunk.length > MAX_FETCH_BYTES) {
@@ -2261,11 +2443,15 @@ capture) {
             res.on('end', emitBody);
             // Ignore errors caused by our own intentional destroy (truncation / redirect);
             // only real transport failures should surface.
-            res.on('error', (err) => { if (!selfAborted)
-                finish({ error: err.message }); });
+            res.on('error', (err) => {
+                if (!selfAborted)
+                    finish({ error: err.message });
+            });
+        });
+        req.on('error', (err) => {
+            if (!selfAborted)
+                finish({ error: err.message });
         });
-        req.on('error', (err) => { if (!selfAborted)
-            finish({ error: err.message }); });
         req.on('timeout', () => {
             selfAborted = true;
             req.destroy();
@@ -2294,10 +2480,10 @@ function buildDiff(filePath, oldStr, newStr, fileContent) {
         }
     }
     const lines = [`--- ${filePath}${hunkHeader}`, `+++ ${filePath}${hunkHeader}`];
-    oldLines.slice(0, MAX_SHOW).forEach(l => lines.push(`- ${l}`));
+    oldLines.slice(0, MAX_SHOW).forEach((l) => lines.push(`- ${l}`));
     if (oldLines.length > MAX_SHOW)
         lines.push(`  … (${oldLines.length - MAX_SHOW} more removed lines)`);
-    newLines.slice(0, MAX_SHOW).forEach(l => lines.push(`+ ${l}`));
+    newLines.slice(0, MAX_SHOW).forEach((l) => lines.push(`+ ${l}`));
     if (newLines.length > MAX_SHOW)
         lines.push(`  … (${newLines.length - MAX_SHOW} more added lines)`);
     return lines.join('\n');
@@ -2336,10 +2522,14 @@ async function multiEdit(input, workDir) {
             // indexOf-based count — safe for regex metacharacters like ( . $ * + ?
             const count = countOccurrences(content, oldStr);
             if (count === 0) {
-                return { error: `Edit #${i + 1}: old_string not found (after applying ${i} prior edit(s)). Re-read the file and retry.` };
+                return {
+                    error: `Edit #${i + 1}: old_string not found (after applying ${i} prior edit(s)). Re-read the file and retry.`,
+                };
             }
             if (count > 1) {
-                return { error: `Edit #${i + 1}: old_string appears ${count} times — it must be unique. Add more surrounding context.` };
+                return {
+                    error: `Edit #${i + 1}: old_string appears ${count} times — it must be unique. Add more surrounding context.`,
+                };
             }
             // literalReplace: $ signs in newStr are never treated as patterns
             // Pass the pre-replace content so line numbers reflect the file state at
@@ -2359,7 +2549,9 @@ async function multiEdit(input, workDir) {
         const sec = (0, securityLint_1.securityNoteText)((0, securityLint_1.checkSecurity)(insertedText.join('\n')));
         return {
             output: `Applied ${edits.length} edit(s) to ${resolved}:\n` +
-                diffs.map((d, i) => `\n--- edit #${i + 1} ---\n${d}`).join('\n') + xfile + sec,
+                diffs.map((d, i) => `\n--- edit #${i + 1} ---\n${d}`).join('\n') +
+                xfile +
+                sec,
             linesAdded,
             linesRemoved,
         };
@@ -2396,18 +2588,25 @@ async function glob(input, workDir) {
             return { output: `No files matched pattern: ${pattern}${scanNote}` };
         // Most recently modified first, capped — same shape as Claude Code's Glob. Paths are
         // relative to the search dir: absolute prefixes were ~25% of the output's tokens.
-        const mtime = (f) => { try {
-            return fs.statSync(f).mtimeMs;
-        }
-        catch {
-            return 0;
-        } };
-        const sorted = matches.map((f) => ({ f, t: mtime(f) })).sort((a, b) => b.t - a.t).map((x) => x.f);
+        const mtime = (f) => {
+            try {
+                return fs.statSync(f).mtimeMs;
+            }
+            catch {
+                return 0;
+            }
+        };
+        const sorted = matches
+            .map((f) => ({ f, t: mtime(f) }))
+            .sort((a, b) => b.t - a.t)
+            .map((x) => x.f);
         const shown = sorted.slice(0, MAX_GLOB_RESULTS).map((f) => path.relative(resolved, f).replace(/\\/g, '/'));
         const more = sorted.length > shown.length
             ? `\n[${sorted.length - shown.length} more not shown — narrow the pattern or path]`
             : '';
-        return { output: `${matches.length} file(s) matched "${pattern}" under ${resolved}:\n${shown.join('\n')}${more}${scanNote}` };
+        return {
+            output: `${matches.length} file(s) matched "${pattern}" under ${resolved}:\n${shown.join('\n')}${more}${scanNote}`,
+        };
     }
     catch (err) {
         return { error: err.message };
@@ -2488,7 +2687,7 @@ async function todoWrite(input, scopeKey) {
     for (const t of todos) {
         const item = t;
         const content = typeof item.content === 'string' ? item.content.trim() : '';
-        const status = (item.status === 'in_progress' || item.status === 'completed') ? item.status : 'pending';
+        const status = item.status === 'in_progress' || item.status === 'completed' ? item.status : 'pending';
         if (!content)
             continue;
         scope.items.push({ id: scope.nextId++, content, status });
@@ -2505,8 +2704,8 @@ function formatTodos(scope) {
     if (!scope.items.length)
         return 'Task list is empty.';
     const icons = { pending: '☐', in_progress: '▶', completed: '✓' };
-    const lines = scope.items.map(t => `${icons[t.status] ?? '☐'} [${t.id}] ${t.content}  (${t.status})`);
-    return `Tasks (${scope.items.filter(t => t.status === 'completed').length}/${scope.items.length} done):\n${lines.join('\n')}`;
+    const lines = scope.items.map((t) => `${icons[t.status] ?? '☐'} [${t.id}] ${t.content}  (${t.status})`);
+    return `Tasks (${scope.items.filter((t) => t.status === 'completed').length}/${scope.items.length} done):\n${lines.join('\n')}`;
 }
 // ─── Shared task list (cross-SESSION coordination — see agent/sharedTasks.ts) ──
 //
@@ -2555,7 +2754,7 @@ async function claimSharedTaskTool(input, workDir) {
         const reasons = {
             'not-found': `No shared task with id "${taskId}" exists for this project.`,
             'already-claimed': `Task "${taskId}" is already claimed by another session. Pick a different task, or check back later.`,
-            'blocked': `Task "${taskId}" is blocked — one or more tasks it depends on are not completed yet.`,
+            blocked: `Task "${taskId}" is blocked — one or more tasks it depends on are not completed yet.`,
             'not-pending': `Task "${taskId}" is already completed.`,
         };
         return { error: reasons[res.reason] ?? `Could not claim task "${taskId}" (${res.reason}).` };
@@ -2578,7 +2777,9 @@ async function updateSharedTaskStatusTool(input, workDir) {
         if (res.reason === 'not-found')
             return { error: `No shared task with id "${taskId}" exists for this project.` };
         if (res.reason === 'already-claimed')
-            return { error: `Task "${taskId}" is claimed by a different session — only the session that claimed it may change its status.` };
+            return {
+                error: `Task "${taskId}" is claimed by a different session — only the session that claimed it may change its status.`,
+            };
         return { error: `Could not update task "${taskId}" (${res.reason}).` };
     }
     return { output: `Updated [${res.task.id}] ${res.task.content} → ${res.task.status}.` };
@@ -2613,7 +2814,9 @@ async function messagePeerSessionTool(input, selfPeer) {
         return { error: 'This session is not registered as a discoverable peer, so it cannot send messages.' };
     const target = (0, peerRegistry_1.findPeerByName)(targetName);
     if (!target)
-        return { error: `No live session named "${targetName}" was found. Use list_peer_sessions to see who is currently reachable.` };
+        return {
+            error: `No live session named "${targetName}" was found. Use list_peer_sessions to see who is currently reachable.`,
+        };
     if (target.id === selfPeer.id)
         return { error: 'Cannot message yourself.' };
     if (!target.socketPath)
@@ -2679,7 +2882,7 @@ function formatNbOutput(out) {
             if (out.traceback) {
                 const clean = out.traceback
                     // eslint-disable-next-line no-control-regex -- ANSI parser: the ESC bytes are the grammar
-                    .map(l => l.replace(/\x1b\[[0-9;]*[mGKH]/g, ''))
+                    .map((l) => l.replace(/\x1b\[[0-9;]*[mGKH]/g, ''))
                     .join('\n');
                 lines.push((0, safeSlice_1.sliceSafeEnd)(clean, 1500) + (clean.length > 1500 ? '\n[truncated]' : ''));
             }
@@ -2708,7 +2911,9 @@ async function notebookRead(input, workDir) {
         nb.cells.forEach((cell, i) => {
             const src = nbJoin(cell.source);
             const execLabel = cell.cell_type === 'code'
-                ? (cell.execution_count != null ? ` (exec #${cell.execution_count})` : ' (not executed)')
+                ? cell.execution_count != null
+                    ? ` (exec #${cell.execution_count})`
+                    : ' (not executed)'
                 : '';
             lines.push('');
             lines.push(`${'─'.repeat(60)}`);
@@ -2718,7 +2923,7 @@ async function notebookRead(input, workDir) {
             if (cell.cell_type === 'code' && cell.outputs?.length) {
                 lines.push('');
                 lines.push('▶ Output:');
-                cell.outputs.forEach(o => {
+                cell.outputs.forEach((o) => {
                     const formatted = formatNbOutput(o);
                     if (formatted)
                         lines.push(formatted);
@@ -2727,7 +2932,9 @@ async function notebookRead(input, workDir) {
         });
         let output = lines.join('\n');
         if (output.length > MAX_OUTPUT_CHARS) {
-            output = (0, safeSlice_1.sliceSafeEnd)(output, MAX_OUTPUT_CHARS) + `\n\n[Notebook output truncated at ${MAX_OUTPUT_CHARS.toLocaleString('en-US')} chars]`;
+            output =
+                (0, safeSlice_1.sliceSafeEnd)(output, MAX_OUTPUT_CHARS) +
+                    `\n\n[Notebook output truncated at ${MAX_OUTPUT_CHARS.toLocaleString('en-US')} chars]`;
         }
         return { output };
     }
@@ -2743,8 +2950,10 @@ async function notebookEdit(input, workDir) {
     const editType = typeof input.edit_type === 'string' ? input.edit_type : '';
     // Accept cell_index as number OR numeric string (model sometimes sends "0" as string)
     const rawIdx = input.cell_index;
-    const cellIndex = typeof rawIdx === 'number' ? Math.floor(rawIdx)
-        : typeof rawIdx === 'string' && rawIdx.trim() !== '' ? parseInt(rawIdx, 10)
+    const cellIndex = typeof rawIdx === 'number'
+        ? Math.floor(rawIdx)
+        : typeof rawIdx === 'string' && rawIdx.trim() !== ''
+            ? parseInt(rawIdx, 10)
             : -1;
     const source = typeof input.source === 'string' ? input.source : null;
     const cellType = (typeof input.cell_type === 'string' ? input.cell_type : 'code');
@@ -2774,14 +2983,18 @@ async function notebookEdit(input, workDir) {
                 cell.execution_count = null;
             }
             save();
-            return { output: `Replaced source of cell ${cellIndex} in ${resolved}.${cell.cell_type === 'code' ? ' Outputs cleared.' : ''}` };
+            return {
+                output: `Replaced source of cell ${cellIndex} in ${resolved}.${cell.cell_type === 'code' ? ' Outputs cleared.' : ''}`,
+            };
         }
         if (editType === 'delete') {
             if (cellIndex < 0 || cellIndex >= n)
                 return { error: `cell_index ${cellIndex} out of range (0–${n - 1})` };
             const removed = nb.cells.splice(cellIndex, 1)[0];
             save();
-            return { output: `Deleted cell ${cellIndex} [${removed.cell_type}] from ${resolved}. Notebook now has ${nb.cells.length} cells.` };
+            return {
+                output: `Deleted cell ${cellIndex} [${removed.cell_type}] from ${resolved}. Notebook now has ${nb.cells.length} cells.`,
+            };
         }
         // insert: inserts AFTER cell_index, or at end if -1
         if (source === null)
@@ -2795,7 +3008,9 @@ async function notebookEdit(input, workDir) {
         };
         nb.cells.splice(insertAt, 0, newCell);
         save();
-        return { output: `Inserted new ${cellType} cell at index ${insertAt} in ${resolved}. Notebook now has ${nb.cells.length} cells.` };
+        return {
+            output: `Inserted new ${cellType} cell at index ${insertAt} in ${resolved}. Notebook now has ${nb.cells.length} cells.`,
+        };
     }
     catch (err) {
         if (err instanceof SyntaxError)
@@ -2821,17 +3036,32 @@ function _httpsPost(url, body, headers, timeoutMs = 30000, abortSignal) {
         const chunks = [];
         let settled = false;
         let abortPoll;
-        const done = (fn) => { if (settled)
-            return; settled = true; if (abortPoll)
-            clearInterval(abortPoll); fn(); };
+        const done = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (abortPoll)
+                clearInterval(abortPoll);
+            fn();
+        };
         // http for an http:// API base (local dev / tests) — https.request would reject it —
         // and the explicit port, which was silently dropped (so :3000 went to :443).
         const mod = u.protocol === 'http:' ? http : https;
-        const req = mod.request({ hostname: u.hostname, ...(u.port ? { port: Number(u.port) } : {}), path: u.pathname + u.search, method: 'POST', headers: { ...headers, 'Content-Length': Buffer.byteLength(body) }, timeout: timeoutMs }, (res) => {
+        const req = mod.request({
+            hostname: u.hostname,
+            ...(u.port ? { port: Number(u.port) } : {}),
+            path: u.pathname + u.search,
+            method: 'POST',
+            headers: { ...headers, 'Content-Length': Buffer.byteLength(body) },
+            timeout: timeoutMs,
+        }, (res) => {
             res.on('data', (c) => chunks.push(c));
             res.on('end', () => done(() => resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString('utf-8') })));
         });
-        req.on('timeout', () => { req.destroy(); done(() => reject(new Error(`Request timed out after ${timeoutMs}ms`))); });
+        req.on('timeout', () => {
+            req.destroy();
+            done(() => reject(new Error(`Request timed out after ${timeoutMs}ms`)));
+        });
         req.on('error', (err) => done(() => reject(err)));
         if (abortSignal) {
             abortPoll = setInterval(() => {
@@ -2852,20 +3082,35 @@ function _httpsGet(url, headers, timeoutMs = 20000, abortSignal) {
         const chunks = [];
         let settled = false;
         let abortPoll;
-        const done = (fn) => { if (settled)
-            return; settled = true; if (abortPoll)
-            clearInterval(abortPoll); fn(); };
+        const done = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (abortPoll)
+                clearInterval(abortPoll);
+            fn();
+        };
         const req = transport.get({ hostname: u.hostname, path: u.pathname + u.search, headers, timeout: timeoutMs }, (res) => {
             // Follow redirects once
-            if ((res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) && res.headers.location) {
+            if ((res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) &&
+                res.headers.location) {
                 req.destroy();
-                done(() => { _httpsGet(new URL(res.headers.location, url).href, headers, timeoutMs, abortSignal).then(resolve, reject); });
+                done(() => {
+                    _httpsGet(new URL(res.headers.location, url).href, headers, timeoutMs, abortSignal).then(resolve, reject);
+                });
                 return;
             }
             res.on('data', (c) => chunks.push(c));
-            res.on('end', () => done(() => resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks), contentType: res.headers['content-type'] ?? '' })));
+            res.on('end', () => done(() => resolve({
+                status: res.statusCode ?? 0,
+                body: Buffer.concat(chunks),
+                contentType: res.headers['content-type'] ?? '',
+            })));
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            done(() => reject(new Error(`Download timed out after ${timeoutMs}ms`)));
         });
-        req.on('timeout', () => { req.destroy(); done(() => reject(new Error(`Download timed out after ${timeoutMs}ms`))); });
         req.on('error', (err) => done(() => reject(err)));
         if (abortSignal) {
             abortPoll = setInterval(() => {
@@ -2887,8 +3132,7 @@ function _httpsGet(url, headers, timeoutMs = 20000, abortSignal) {
 async function generateImage(input, workDir, abortSignal) {
     const prompt = typeof input.prompt === 'string' ? input.prompt.trim() : '';
     const relPath = typeof input.path === 'string' ? input.path.trim() : '';
-    const aspectRatio = typeof input.aspect_ratio === 'string' && VALID_ASPECT_RATIOS.has(input.aspect_ratio)
-        ? input.aspect_ratio : '1:1';
+    const aspectRatio = typeof input.aspect_ratio === 'string' && VALID_ASPECT_RATIOS.has(input.aspect_ratio) ? input.aspect_ratio : '1:1';
     if (!prompt)
         return { error: 'Missing required parameter: prompt' };
     if (!relPath)
@@ -2909,7 +3153,9 @@ async function generateImage(input, workDir, abortSignal) {
         try {
             json = JSON.parse(r.body);
         }
-        catch (_) { /* body may be absent or non-JSON */ }
+        catch (_) {
+            /* body may be absent or non-JSON */
+        }
         if (r.status !== 200)
             return { error: json.error || `Server error ${r.status}` };
         imageUrl = json.url ?? '';
@@ -2928,19 +3174,26 @@ async function generateImage(input, workDir, abortSignal) {
     try {
         fs.mkdirSync(path.dirname(destPath), { recursive: true });
     }
-    catch (_) { /* best-effort */ }
+    catch (_) {
+        /* best-effort */
+    }
     try {
         const dl = await _httpsGet(imageUrl, { 'User-Agent': FETCH_USER_AGENT }, 60000, abortSignal);
         if (dl.status !== 200)
             return { error: `Failed to download generated image (HTTP ${dl.status}).` };
         fs.writeFileSync(destPath, dl.body);
         const kb = (dl.body.length / 1024).toFixed(1);
-        const costNote = cost != null ? ` ($${cost.toFixed(2)} charged` + (balance != null ? `, balance $${balance.toFixed(2)})` : ')') : '';
+        const costNote = cost != null
+            ? ` ($${cost.toFixed(2)} charged` + (balance != null ? `, balance $${balance.toFixed(2)})` : ')')
+            : '';
         return { output: `Generated and saved image to ${destPath} (${kb} KB)${costNote}.` };
     }
     catch (err) {
         if (err.name === 'AbortError')
-            return { error: 'generate_image stopped by user (image was generated and billed, but the download was interrupted)', interrupted: true };
+            return {
+                error: 'generate_image stopped by user (image was generated and billed, but the download was interrupted)',
+                interrupted: true,
+            };
         return { error: `Failed to save image to ${destPath}: ${err.message}` };
     }
 }
@@ -2973,7 +3226,9 @@ async function stockPhoto(input, workDir, abortSignal) {
         try {
             json = JSON.parse(r.body.toString('utf-8'));
         }
-        catch (_) { /* body may be absent or non-JSON */ }
+        catch (_) {
+            /* body may be absent or non-JSON */
+        }
         if (r.status !== 200)
             return { error: json.error || `Server error ${r.status}` };
         photos = (json.photos ?? []);
@@ -2994,7 +3249,9 @@ async function stockPhoto(input, workDir, abortSignal) {
         try {
             fs.mkdirSync(path.dirname(destPath), { recursive: true });
         }
-        catch (_) { /* best-effort */ }
+        catch (_) {
+            /* best-effort */
+        }
         try {
             const dl = await _httpsGet(top.url, { 'User-Agent': FETCH_USER_AGENT }, 20000, abortSignal);
             if (dl.status !== 200)
@@ -3044,7 +3301,9 @@ async function webSearch(input, _workDir, abortSignal) {
         try {
             json = JSON.parse(r.body);
         }
-        catch (_) { /* body may be absent or non-JSON */ }
+        catch (_) {
+            /* body may be absent or non-JSON */
+        }
         if (r.status !== 200)
             return { error: json.error || `Server error ${r.status}` };
         const text = json.text ?? '';
@@ -3108,7 +3367,9 @@ async function useSkill(input, workDir) {
         return { error: 'name is required (the skill to invoke)' };
     const dir = workDir ?? process.cwd();
     const skills = (0, skills_1.loadSkills)(dir);
-    const skill = (0, skills_1.findSkill)(skills, name);
+    // `<dir>:<name>` = a nested skill (see skills.ts); the list above only holds
+    // top-level ones, so a scoped miss falls through to the name-driven lookup.
+    const skill = (0, skills_1.findSkill)(skills, name) ?? (0, skills_1.resolveNestedSkill)(dir, name);
     if (!skill) {
         const known = skills.map((s) => s.name).join(', ') || '(none defined)';
         return { error: `Unknown skill "${name}". Available: ${known}.` };
@@ -3133,7 +3394,12 @@ function semanticPreamble(input, workDir) {
         return { ok: false, err: { error: e.message } };
     }
     if (!(0, tsLangService_1.isTsLike)(resolved)) {
-        return { ok: false, err: { error: `Semantic navigation currently supports TypeScript/JavaScript only. For ${path.extname(resolved) || 'this file type'} use get_symbols / get_workspace_symbols (regex-based).` } };
+        return {
+            ok: false,
+            err: {
+                error: `Semantic navigation currently supports TypeScript/JavaScript only. For ${path.extname(resolved) || 'this file type'} use get_symbols / get_workspace_symbols (regex-based).`,
+            },
+        };
     }
     return { ok: true, args: { workDir: workDir ?? process.cwd(), filePath: resolved, line, character } };
 }
@@ -3211,14 +3477,34 @@ const TOOL_MAP = {
 // their own dedicated branch above (which passes abortSignal too) — kept out
 // of this set so there's exactly one dispatch path per tool, not two.
 const WORKDIR_TOOLS = new Set([
-    'read_file', 'write_file', 'write_docx', 'write_xlsx', 'write_pptx',
-    'list_directory', 'search_files', 'glob',
-    'create_directory', 'edit_file', 'multi_edit', 'copy_file', 'move_file',
-    'delete_file', 'notebook_read', 'notebook_edit',
-    'get_symbols', 'get_workspace_symbols',
-    'go_to_definition', 'find_references', 'get_hover',
-    'memory_write', 'memory_read', 'use_skill',
-    'list_shared_tasks', 'create_shared_task', 'claim_shared_task', 'update_shared_task_status',
+    'read_file',
+    'write_file',
+    'write_docx',
+    'write_xlsx',
+    'write_pptx',
+    'list_directory',
+    'search_files',
+    'glob',
+    'create_directory',
+    'edit_file',
+    'multi_edit',
+    'copy_file',
+    'move_file',
+    'delete_file',
+    'notebook_read',
+    'notebook_edit',
+    'get_symbols',
+    'get_workspace_symbols',
+    'go_to_definition',
+    'find_references',
+    'get_hover',
+    'memory_write',
+    'memory_read',
+    'use_skill',
+    'list_shared_tasks',
+    'create_shared_task',
+    'claim_shared_task',
+    'update_shared_task_status',
 ]);
 async function executeTool(name, input, abortSignal, sandbox, workDir, agentScope, onStream, 
 // This session's own peer identity (see agent/peerRegistry.ts), if it is