@nexrall/code-core 1.4.76 → 1.4.78

package/dist/plugins/validate.js

@@ -0,0 +1,222 @@
+"use strict";
+// ─── `nex plugin validate` (S24) ─────────────────────────────────────────────
+//
+// One structural check of a plugin directory, runnable in CI before anyone
+// installs it. It answers the questions the install-time inspector cannot:
+//
+//   • does the manifest parse, and is its `userConfig` block legal (strict —
+//     an unknown field inside an option is an error, matching Claude Code)?
+//   • do hooks.json / mcp.json parse, and resolve through the SAME file table
+//     the runtime loader reads (a component under a path the loader ignores
+//     would otherwise pass validation and do nothing);
+//   • does every `${user_config.KEY}` reference name a DECLARED option
+//     (Claude Code 2.1.281's check) — and is it used in a place that accepts
+//     it? A shell-form hook `command` never does: the substituted value would
+//     be re-parsed by the shell, so the runtime rejects that reference and the
+//     validate report says to read NEXRALL_PLUGIN_OPTION_<KEY> from the
+//     environment instead;
+//   • does every MCP server entry carry what a connection needs (a string
+//     `command`, or a string `url`)?
+//   • insecure remote URLs (plain http:// to a non-localhost host) as warnings.
+//
+// Pure reads; no plugin code ever executes here.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePluginDir = validatePluginDir;
+exports.formatValidateReport = formatValidateReport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const files_1 = require("./files");
+const userConfig_1 = require("./userConfig");
+const LOCALHOST = /^(localhost|127\.0\.0\.1|\[::1\]|::1)$/i;
+function insecureUrl(url) {
+    if (!/^http:\/\//i.test(url))
+        return false;
+    try {
+        const host = new URL(url).hostname;
+        return !LOCALHOST.test(host);
+    }
+    catch {
+        return true; // unparseable http URL: still the insecure scheme
+    }
+}
+/** Walk one hooks phase entry (flat and nested CC forms) into handler objects. */
+function hookHandlers(entry) {
+    if (!entry || typeof entry !== 'object')
+        return [];
+    const e = entry;
+    if (Array.isArray(e.hooks))
+        return e.hooks.filter((h) => !!h && typeof h === 'object');
+    return [e];
+}
+function validatePluginDir(dir) {
+    const errors = [];
+    const warnings = [];
+    const report = { ok: true, dir, manifest: null, userConfig: [], errors, warnings };
+    try {
+        if (!fs.statSync(dir).isDirectory()) {
+            errors.push(`not a directory: ${dir}`);
+            return { ...report, ok: false };
+        }
+    }
+    catch {
+        errors.push(`does not exist: ${dir}`);
+        return { ...report, ok: false };
+    }
+    // ── manifest ───────────────────────────────────────────────────────────────
+    const manifestFile = (0, files_1.resolvePluginFile)(dir, 'manifest');
+    report.manifest = manifestFile;
+    let manifest = null;
+    if (!manifestFile) {
+        warnings.push('no plugin.json found (the plugin still loads by directory name, but cannot declare userConfig)');
+    }
+    else {
+        try {
+            const j = JSON.parse(fs.readFileSync(manifestFile, 'utf-8'));
+            if (!j || typeof j !== 'object' || Array.isArray(j)) {
+                errors.push(`${manifestFile}: must be a JSON object`);
+            }
+            else {
+                manifest = j;
+            }
+        }
+        catch (e) {
+            errors.push(`${manifestFile}: ${e.message}`);
+        }
+    }
+    if (manifest) {
+        for (const field of ['name', 'version', 'description']) {
+            if (manifest[field] !== undefined && typeof manifest[field] !== 'string') {
+                errors.push(`plugin.json: "${field}" must be a string`);
+            }
+        }
+        if (manifest.userConfig !== undefined) {
+            const parsed = (0, userConfig_1.parseUserConfig)(manifest);
+            report.userConfig = parsed.options;
+            errors.push(...parsed.errors);
+        }
+    }
+    const declared = new Set(report.userConfig.map((o) => o.key));
+    // ── hooks.json ─────────────────────────────────────────────────────────────
+    const hooksFile = (0, files_1.resolvePluginFile)(dir, 'hooks');
+    if (hooksFile) {
+        try {
+            const j = JSON.parse(fs.readFileSync(hooksFile, 'utf-8'));
+            const hooks = (j?.hooks ?? j);
+            if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) {
+                errors.push(`${hooksFile}: must be an object of hook phases`);
+            }
+            else {
+                for (const [phase, entries] of Object.entries(hooks)) {
+                    if (!Array.isArray(entries)) {
+                        errors.push(`${hooksFile}: "${phase}" must be an array`);
+                        continue;
+                    }
+                    for (const handler of entries.flatMap(hookHandlers)) {
+                        const type = handler.type ?? (handler.url ? 'http' : handler.prompt ? 'prompt' : 'command');
+                        if (type === 'command') {
+                            const cmd = handler.command;
+                            if (typeof cmd !== 'string' || !cmd.trim()) {
+                                errors.push(`${hooksFile}: a command hook in "${phase}" has no command string`);
+                                continue;
+                            }
+                            if ((0, userConfig_1.findUserConfigRefs)(cmd).length) {
+                                errors.push(`${hooksFile}: a command hook in "${phase}" uses \${user_config.*} in its shell-form command — ` +
+                                    'the value would be re-parsed by the shell. Read NEXRALL_PLUGIN_OPTION_<KEY> from the hook environment instead');
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            errors.push(`${hooksFile}: ${e.message}`);
+        }
+    }
+    // ── mcp.json ───────────────────────────────────────────────────────────────
+    const mcpFile = (0, files_1.resolvePluginFile)(dir, 'mcp');
+    if (mcpFile) {
+        try {
+            const j = JSON.parse(fs.readFileSync(mcpFile, 'utf-8'));
+            const servers = (j?.mcpServers ?? j);
+            if (!servers || typeof servers !== 'object' || Array.isArray(servers)) {
+                errors.push(`${mcpFile}: must be an object of server configs (or { mcpServers: … })`);
+            }
+            else {
+                for (const [name, cfg] of Object.entries(servers)) {
+                    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) {
+                        errors.push(`${mcpFile}: server "${name}" is not an object — it will not connect`);
+                        continue;
+                    }
+                    const c = cfg;
+                    const hasCommand = typeof c.command === 'string' && c.command.trim() !== '';
+                    const hasUrl = typeof c.url === 'string' && c.url.trim() !== '';
+                    if (!hasCommand && !hasUrl) {
+                        errors.push(`${mcpFile}: server "${name}" has neither a string "command" nor a "url" — it will not connect`);
+                    }
+                    if (hasUrl && insecureUrl(String(c.url))) {
+                        warnings.push(`${mcpFile}: server "${name}" uses a plain http:// URL (${String(c.url)})`);
+                    }
+                    for (const ref of (0, userConfig_1.collectUserConfigRefsDeep)(cfg)) {
+                        if (!declared.has(ref)) {
+                            errors.push(`${mcpFile}: server "${name}" references \${user_config.${ref}} but the manifest does not declare "${ref}"`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            errors.push(`${mcpFile}: ${e.message}`);
+        }
+    }
+    report.ok = errors.length === 0;
+    return report;
+}
+/** One-line human summary lines for the CLI printer (warnings then errors). */
+function formatValidateReport(r) {
+    const lines = [];
+    const label = path.basename(r.dir) || r.dir;
+    lines.push(`  Plugin: ${label}`);
+    lines.push(`  Manifest: ${r.manifest ?? '(none)'}`);
+    if (r.userConfig.length)
+        lines.push(`  userConfig options: ${r.userConfig.map((o) => o.key).join(', ')}`);
+    for (const w of r.warnings)
+        lines.push(`  ⚠ ${w}`);
+    for (const e of r.errors)
+        lines.push(`  ✗ ${e}`);
+    lines.push(r.ok ? '  ✓ Validation passed' : `  ✗ Validation failed (${r.errors.length} error(s))`);
+    return lines;
+}
+//# sourceMappingURL=validate.js.map

package/dist/project/projectCommands.d.ts

@@ -0,0 +1,33 @@
+export interface ProjectCommand {
+    /** What the user types after `/run`: an npm script name, a make target, … */
+    name: string;
+    /** The full shell command. */
+    command: string;
+    /** The file it came from, shown in the picker and in errors. */
+    source: string;
+}
+/** The package manager whose scripts this project's lockfile asks for. */
+export declare function packageManager(workDir: string): 'npm' | 'pnpm' | 'yarn' | 'bun';
+/**
+ * Every command this folder can run, in a stable order (package.json first — the most
+ * common source — then the rest alphabetically). Missing files are simply absent: a
+ * project with no package.json is not an error, it is a Cargo project.
+ */
+export declare function detectProjectCommands(workDir: string): ProjectCommand[];
+/**
+ * The commands a shortcut should run: everything in the best tier it finds, best
+ * first. More than one means the caller asks which (a repo with `test` and
+ * `test:integration` should not silently pick one — running the wrong suite and
+ * calling it "the tests" is worse than one extra keystroke).
+ */
+export declare function resolveShortcut<T extends {
+    name: string;
+}>(cmds: T[], want: string): T[];
+/**
+ * Runs `git` with the user's arguments: `/git` alone means `git status`, `/git log -5`
+ * means exactly that. Not a list of allowed subcommands — the read-only gate in front
+ * of this (core's isReadOnlyBash) is what decides whether it may run unprompted, so
+ * `/git commit` works in a normal session and is refused under `--readonly`.
+ */
+export declare function gitCommand(arg: string): string;
+//# sourceMappingURL=projectCommands.d.ts.map

package/dist/project/projectCommands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectCommands.d.ts","sourceRoot":"","sources":["../../src/project/projectCommands.ts"],"names":[],"mappings":"AAqBA,MAAM,WAAW,cAAc;IAC7B,6EAA6E;IAC7E,IAAI,EAAE,MAAM,CAAC;IACb,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;CAChB;AAkCD,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAM/E;AAsED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAiEvE;AAsBD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,CAKxF;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG9C"}

package/dist/project/projectCommands.js

@@ -0,0 +1,246 @@
+"use strict";
+// Project commands: `/run`, `/test`, `/build`, `/lint` and `/git` (spec §85).
+//
+// Lives in core (moved from the CLI's projectCommands.ts, 2026-10-04) so the
+// VS Code panel detects the same commands and runs them in its own terminal;
+// the CLI module is a re-export shim.
+//
+// WHY: the everyday things you do next to an agent are "run the tests", "build it",
+// "show me the diff" — and the only way to do them was `!npm test`, typed out in
+// full, or asking the model (a whole turn, tokens, and an approval prompt for
+// something YOU decided). `/test` should mean "whatever testing means in this
+// project". That is a detection problem, and detection is what this file is: what
+// `test` IS depends on the folder, so we read the folder instead of guessing.
+//
+// Kept free of chat.ts/Ink so every rule here is unit-testable (test/projectCommands.test.ts).
+// The command that comes out is run through the SAME path as `!cmd` (permission
+// rules, read-only gate, output limits, background, transcript) — this module only
+// decides WHAT to run, never runs it.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageManager = packageManager;
+exports.detectProjectCommands = detectProjectCommands;
+exports.resolveShortcut = resolveShortcut;
+exports.gitCommand = gitCommand;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** Lifecycle hooks: npm runs these itself, so they are noise in a "what can I run" list. */
+const NPM_HOOKS = new Set([
+    'preinstall',
+    'install',
+    'postinstall',
+    'prepare',
+    'prepublish',
+    'prepublishOnly',
+    'prepack',
+    'postpack',
+    'preversion',
+    'postversion',
+    'dependencies',
+    'prepublishOnly',
+]);
+function readText(file) {
+    try {
+        return node_fs_1.default.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function isFile(file) {
+    try {
+        return node_fs_1.default.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** The package manager whose scripts this project's lockfile asks for. */
+function packageManager(workDir) {
+    const has = (f) => isFile(node_path_1.default.join(workDir, f));
+    if (has('pnpm-lock.yaml') || has('pnpm-workspace.yaml'))
+        return 'pnpm';
+    if (has('yarn.lock'))
+        return 'yarn';
+    if (has('bun.lockb') || has('bun.lock'))
+        return 'bun';
+    return 'npm';
+}
+/** Reads `scripts` out of a package.json-shaped file. Never throws on bad JSON. */
+function readScripts(file, rel) {
+    const raw = readText(file);
+    if (raw === null)
+        return [];
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const scripts = json?.scripts;
+    if (!scripts || typeof scripts !== 'object')
+        return [];
+    const pm = packageManager(node_path_1.default.dirname(file));
+    return Object.keys(scripts)
+        .filter((n) => !NPM_HOOKS.has(n))
+        .map((n) => ({ name: n, command: `${pm} run ${n}`, source: rel }));
+}
+/**
+ * Make targets: column-0 `name:` rules, minus assignments (`VAR := x`, `+=`).
+ *
+ * Pattern rules (`%.o: %.c`) need no test of their own: the name is
+ * `[A-Za-z0-9][\w.-]*` and must be followed directly by `:`, so a `%` — which is not in
+ * that class — can never reach the name. A guard for it was written, proved
+ * unreachable by a mutation run, and removed rather than left looking load-bearing.
+ * Targets containing `/` are deliberately not listed: `src/foo.o: src/foo.c` would
+ * flood /run with one entry per object file.
+ */
+function makeTargets(file, rel) {
+    const raw = readText(file);
+    if (raw === null)
+        return [];
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const m = /^([A-Za-z0-9][\w.-]*)\s*:(?!=)/.exec(line);
+        if (!m)
+            continue;
+        out.push({ name: m[1], command: `make ${m[1]}`, source: rel });
+    }
+    return out;
+}
+/** justfile recipes: column-0 `name arg:` / `name:`, minus assignments (`x := y`). */
+function justRecipes(file, rel) {
+    const raw = readText(file);
+    if (raw === null)
+        return [];
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const m = /^([A-Za-z_][\w-]*)(\s[^:]*)?\s*:(?!=)/.exec(line);
+        if (!m)
+            continue;
+        out.push({ name: m[1], command: `just ${m[1]}`, source: rel });
+    }
+    return out;
+}
+/** `deno task` entries. deno.jsonc is skipped: its comments need a real JSONC parser. */
+function denoTasks(file, rel) {
+    const raw = readText(file);
+    if (raw === null)
+        return [];
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const tasks = json?.tasks;
+    if (!tasks || typeof tasks !== 'object')
+        return [];
+    return Object.keys(tasks).map((n) => ({ name: n, command: `deno task ${n}`, source: rel }));
+}
+/**
+ * Every command this folder can run, in a stable order (package.json first — the most
+ * common source — then the rest alphabetically). Missing files are simply absent: a
+ * project with no package.json is not an error, it is a Cargo project.
+ */
+function detectProjectCommands(workDir) {
+    const out = [];
+    const at = (f) => node_path_1.default.join(workDir, f);
+    out.push(...readScripts(at('package.json'), 'package.json'));
+    const makefile = ['Makefile', 'makefile', 'GNUmakefile'].find((f) => isFile(at(f)));
+    if (makefile)
+        out.push(...makeTargets(at(makefile), makefile));
+    const justfile = ['justfile', 'Justfile'].find((f) => isFile(at(f)));
+    if (justfile)
+        out.push(...justRecipes(at(justfile), justfile));
+    if (isFile(at('deno.json')))
+        out.push(...denoTasks(at('deno.json'), 'deno.json'));
+    const composer = readText(at('composer.json'));
+    if (composer !== null) {
+        try {
+            const json = JSON.parse(composer);
+            for (const n of Object.keys(json?.scripts ?? {})) {
+                out.push({ name: n, command: `composer run ${n}`, source: 'composer.json' });
+            }
+        }
+        catch {
+            /* a broken composer.json is not this command's problem */
+        }
+    }
+    // Go and Rust have one obvious command per task; no file to read beyond the manifest.
+    if (isFile(at('go.mod'))) {
+        out.push({ name: 'build', command: 'go build ./...', source: 'go.mod' }, { name: 'test', command: 'go test ./...', source: 'go.mod' }, { name: 'vet', command: 'go vet ./...', source: 'go.mod' }, { name: 'fmt', command: 'gofmt -l .', source: 'go.mod' });
+    }
+    if (isFile(at('Cargo.toml'))) {
+        out.push({ name: 'build', command: 'cargo build', source: 'Cargo.toml' }, { name: 'test', command: 'cargo test', source: 'Cargo.toml' }, { name: 'check', command: 'cargo check', source: 'Cargo.toml' }, { name: 'clippy', command: 'cargo clippy', source: 'Cargo.toml' }, { name: 'fmt', command: 'cargo fmt --check', source: 'Cargo.toml' });
+    }
+    // Python: only when the folder actually says how it is tested/linted. `pytest -q` in a
+    // project with no pytest is a wasted round trip, so evidence is required.
+    const pyproject = readText(at('pyproject.toml')) ?? '';
+    const hasPytest = isFile(at('pytest.ini')) ||
+        isFile(at('tox.ini')) ||
+        pyproject.includes('[tool.pytest') ||
+        node_fs_1.default.existsSync(at('tests'));
+    if (hasPytest)
+        out.push({ name: 'test', command: 'pytest -q', source: pyproject ? 'pyproject.toml' : 'pytest' });
+    if (pyproject.includes('[tool.ruff') || isFile(at('ruff.toml'))) {
+        out.push({ name: 'lint', command: 'ruff check .', source: 'ruff.toml' });
+    }
+    if (pyproject.includes('[tool.mypy')) {
+        out.push({ name: 'typecheck', command: 'mypy .', source: 'pyproject.toml' });
+    }
+    // An identical row twice (a Makefile that defines the same target twice, two
+    // manifests offering the same command) is always noise; the first source wins.
+    const seen = new Set();
+    return out.filter((c) => (seen.has(c.command) ? false : (seen.add(c.command), true)));
+}
+/**
+ * How well a command name answers a shortcut, lower is better, -1 means "not this one".
+ * `test:unit` and `test-unit` both answer `/test`; `e2e:test` only just.
+ *
+ * Word-based, never substring: an endsWith rule was tried and dropped, because
+ * "latest".endsWith("test") is TRUE — so `/test` in a project whose only script was
+ * `latest` would have run it and called it the test suite. `eslint` losing to that
+ * rule is the price, and `/run eslint` still works: running the wrong thing quietly
+ * is far worse than not finding a name.
+ */
+function tier(name, want) {
+    const n = name.toLowerCase();
+    const w = want.toLowerCase();
+    if (n === w)
+        return 0;
+    const parts = n.split(/[:._-]+/);
+    if (parts[0] === w)
+        return 1;
+    if (parts.includes(w))
+        return 2;
+    return -1;
+}
+/**
+ * The commands a shortcut should run: everything in the best tier it finds, best
+ * first. More than one means the caller asks which (a repo with `test` and
+ * `test:integration` should not silently pick one — running the wrong suite and
+ * calling it "the tests" is worse than one extra keystroke).
+ */
+function resolveShortcut(cmds, want) {
+    const scored = cmds.map((c) => ({ c, t: tier(c.name, want) })).filter((x) => x.t >= 0);
+    if (!scored.length)
+        return [];
+    const best = Math.min(...scored.map((x) => x.t));
+    return scored.filter((x) => x.t === best).map((x) => x.c);
+}
+/**
+ * Runs `git` with the user's arguments: `/git` alone means `git status`, `/git log -5`
+ * means exactly that. Not a list of allowed subcommands — the read-only gate in front
+ * of this (core's isReadOnlyBash) is what decides whether it may run unprompted, so
+ * `/git commit` works in a normal session and is refused under `--readonly`.
+ */
+function gitCommand(arg) {
+    const a = arg.trim();
+    return a ? `git ${a}` : 'git status';
+}
+//# sourceMappingURL=projectCommands.js.map

package/dist/search/conversationTurns.d.ts

@@ -0,0 +1,53 @@
+import { type Message } from '../types';
+/** `!cmd` transcripts are synthesised user messages; this is their prefix (moved
+ *  here from commands/bangShell.ts so the synthetic-user list has one home). */
+export declare const BANG_TRANSCRIPT_PREFIX = "I ran this command myself in the terminal:";
+/** Lines of a turn's body shown by a jump before the rest is summarised. */
+export declare const MAX_TURN_LINES = 80;
+/** Tool-result lines kept inline; the rest is a count. */
+export declare const RESULT_PREVIEW_LINES = 3;
+/** Newest turns kept — a 400-turn session does not need all of it in memory. */
+export declare const MAX_TURNS = 200;
+/** Prompt length in a turn header / search label. */
+export declare const PROMPT_CLIP = 100;
+export interface Turn {
+    /** 1-based, in conversation order. */
+    index: number;
+    /** The user's prompt, flattened to one line. */
+    prompt: string;
+    /** Body lines, ready to print (no colour). */
+    lines: string[];
+    toolCalls: number;
+    /** Lines dropped by MAX_TURN_LINES (0 when everything fit). */
+    dropped: number;
+}
+export declare function flatten(s: string): string;
+export declare function clip(s: string, max: number): string;
+/** One display line per content block, or null for blocks that are not conversation. */
+export declare function blockLines(m: Message, b: Message['content'][number]): string[] | null;
+/** Did this user message start a turn, or is it agent bookkeeping? */
+export declare function startsTurn(m: Message): boolean;
+export declare function isSyntheticUserText(text: string): boolean;
+/**
+ * Group the conversation into turns. Content before the first real prompt (the
+ * opening context block) is not a turn and is skipped.
+ */
+export declare function turnsFrom(messages: Message[], opts?: {
+    maxLines?: number;
+    maxTurns?: number;
+}): Turn[];
+/**
+ * The most recent real prompt in the conversation — the label a `/cost` turn row carries.
+ *
+ * Scans BACKWARDS so a mid-turn follow-up (folded in by the loop while the agent works) is
+ * what the row reads: that is the last thing the user actually asked for. '' when nothing
+ * has been typed yet.
+ */
+export declare function lastPrompt(messages: Message[], max?: number): string;
+/**
+ * The last prompt the USER actually typed — skips the synthetic user messages (a `!cmd`
+ * transcript, a task notification, a peer message), which are turns but were not typed.
+ * The §81 handoff goal is built from this; `lastPrompt` deliberately does not skip them.
+ */
+export declare function lastTypedPrompt(messages: Message[], max?: number): string;
+//# sourceMappingURL=conversationTurns.d.ts.map

package/dist/search/conversationTurns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversationTurns.d.ts","sourceRoot":"","sources":["../../src/search/conversationTurns.ts"],"names":[],"mappings":"AAGA,OAAO,EAAyB,KAAK,OAAO,EAAE,MAAM,UAAU,CAAC;AAG/D;gFACgF;AAChF,eAAO,MAAM,sBAAsB,+CAA+C,CAAC;AAEnF,4EAA4E;AAC5E,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,0DAA0D;AAC1D,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,gFAAgF;AAChF,eAAO,MAAM,SAAS,MAAM,CAAC;AAC7B,qDAAqD;AACrD,eAAO,MAAM,WAAW,MAAM,CAAC;AAE/B,MAAM,WAAW,IAAI;IACnB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wFAAwF;AACxF,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,CAwBrF;AAUD,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAG9C;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,IAAI,EAAE,CA4C1G;AAUD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,SAAc,GAAG,MAAM,CAQzE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,SAAc,GAAG,MAAM,CAQ9E"}