@v1nvn/agentic-core 0.44.0 → 0.45.0

package/README.md

@@ -13,7 +13,7 @@ User-facing docs: [root README](../../README.md).
 | ------------------- | ----------------------------------------------------------------------- |
 | `src/last-reply.ts` | finds the previous assistant reply across local Claude Code transcripts |
 | `src/input.ts`      | stdin and markdown-file input with the CLI error contracts              |
-| `src/cli.ts`        | quiet commander parsing, usage/exit, and the runMain failure tail       |
+| `src/cli.ts`        | the runCli/parseCli doors over declarative command specs                |
 | `src/logger.ts`     | level-filtered stderr logger for the MCP servers                        |
 | `src/shutdown.ts`   | close-then-exit signal handling for the server entrypoints              |
 | `src/dev.ts`        | the hot-reload watcher wiring the servers' `yarn dev` harnesses share   |

package/package.json

@@ -1,21 +1,15 @@
 {
   "name": "@v1nvn/agentic-core",
-  "version": "0.44.0",
-  "description": "Shared runtime for the @v1nvn agent tools — last-reply transcript reader.",
+  "version": "0.45.0",
+  "description": "Shared source home for the @v1nvn agent tools — runtime helpers and the drawing kit every process-side surface imports.",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./src/index.ts",
   "exports": {
-    ".": {
-      "types": "./src/index.ts",
-      "default": "./dist/index.js"
-    },
-    "./vite": {
-      "types": "./src/vite.ts",
-      "default": "./dist/vite.js"
-    }
+    ".": "./src/index.ts",
+    "./draw": "./src/draw.ts",
+    "./vite": "./src/vite.ts"
   },
   "scripts": {
-    "build": "vite build",
     "test": "vitest run",
     "test:watch": "vitest"
   },
@@ -35,11 +29,12 @@
     "directory": "packages/core"
   },
   "files": [
-    "dist",
     "src"
   ],
+  "dependencies": {
+    "commander": "^15.0.0"
+  },
   "devDependencies": {
-    "commander": "^15.0.0",
     "vite": "^8.1.4",
     "vitest": "^4.1.10"
   },
@@ -47,6 +42,6 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=23.6"
   }
 }

package/src/cli.ts

@@ -1,60 +1,274 @@
-import type { Command } from 'commander';
+import { Command, InvalidArgumentError, Option } from 'commander';
 
-// A --help ask caught mid-parse: parseQuietly returns it instead of exiting,
-// so a spec can drive the parse and the bin decides to print and exit.
+import { describeError } from './mcp.ts';
+
+export interface CliOption {
+  readonly choices?: readonly string[];
+  readonly default?: string;
+  readonly description: string;
+  readonly env?: string;
+  readonly flags: string;
+  readonly parse?: (value: string) => unknown;
+}
+
+export type CliResult = number | undefined;
+
+export type CliRun = (
+  options: Record<string, unknown>,
+  args: readonly string[],
+) => CliResult | Promise<CliResult>;
+
+export interface CliSpec {
+  readonly argument?: { readonly description: string; readonly flags: string };
+  readonly commands?: readonly CliSpec[];
+  readonly description?: string;
+  readonly name: string;
+  readonly options?: readonly CliOption[];
+  readonly run?: CliRun;
+  readonly usageExit?: number;
+  readonly version?: string;
+}
+
+export interface CliInvocation {
+  readonly args: readonly string[];
+  readonly command?: string;
+  readonly options: Record<string, unknown>;
+  readonly root: Record<string, unknown>;
+}
+
+// A --help ask caught mid-parse: the parse doors return it instead of exiting,
+// and runCli answers it (the help payload) on stdout with 0.
 export class HelpRequested extends Error {
-  constructor(readonly command: Command) {
+  readonly command: Command;
+
+  constructor(command: Command) {
     super(`${command.name()} --help`);
+    this.command = command;
   }
 }
 
-export function parseQuietly(
-  program: Command,
-  args: readonly string[],
-): Command | HelpRequested | undefined {
-  function quiet(command: Command): void {
-    command.configureOutput({
-      writeOut: () => undefined,
-      writeErr: () => undefined,
-    });
-    command.exitOverride(err => {
-      const code = (err as { code?: string }).code;
-      if (code === 'commander.help' || code === 'commander.helpDisplayed') {
-        throw new HelpRequested(command);
+export type CliHelpHook<T> = (topic: string, text: string) => T;
+
+function addOption(cmd: Command, option: CliOption): void {
+  const bare =
+    option.env === undefined &&
+    option.choices === undefined &&
+    option.default === undefined &&
+    option.parse === undefined;
+  if (bare) {
+    cmd.option(option.flags, option.description);
+    return;
+  }
+  const built = new Option(option.flags, option.description);
+  if (option.env !== undefined) {
+    built.env(option.env);
+  }
+  if (option.choices !== undefined) {
+    built.choices(option.choices);
+  }
+  if (option.default !== undefined) {
+    built.default(option.default);
+  }
+  const { parse } = option;
+  if (parse !== undefined) {
+    // A plain Error from a parse fn skips commander's exitOverride, which is
+    // what records the subcommand for the usage print — wrap it so it rides.
+    built.argParser((value: string) => {
+      try {
+        return parse(value);
+      } catch (err) {
+        if ((err as { code?: string }).code === 'commander.invalidArgument') {
+          throw err;
+        }
+        throw new InvalidArgumentError(describeError(err));
       }
-      throw err;
     });
-    command.commands.forEach(quiet);
   }
+  cmd.addOption(built);
+}
+
+function wire(
+  cmd: Command,
+  spec: CliSpec,
+  program: Command,
+  isRoot: boolean,
+  sink?: (invocation: CliInvocation) => void,
+): void {
+  if (spec.description !== undefined) {
+    cmd.description(spec.description);
+  }
+  if (spec.argument !== undefined) {
+    cmd.argument(spec.argument.flags, spec.argument.description);
+  }
+  for (const option of spec.options ?? []) {
+    addOption(cmd, option);
+  }
+  if (isRoot && spec.version !== undefined) {
+    cmd.option('-V, --version', 'print the version and exit');
+  }
+  cmd.action((...all: unknown[]) => {
+    const options = all.at(-2) as Record<string, unknown>;
+    const command = all.at(-1) as Command;
+    sink?.({
+      command: isRoot ? undefined : spec.name,
+      options,
+      args: command.args,
+      root: program.opts(),
+    });
+  });
+  for (const sub of spec.commands ?? []) {
+    const child = new Command(sub.name);
+    wire(child, sub, program, false, sink);
+    cmd.addCommand(child);
+  }
+}
+
+function materialize(
+  spec: CliSpec,
+  sink?: (invocation: CliInvocation) => void,
+): Command {
+  const program = new Command(spec.name);
+  wire(program, spec, program, true, sink);
+  return program;
+}
+
+export function buildCli(spec: CliSpec): Command {
+  return materialize(spec);
+}
+
+function quiet(
+  command: Command,
+  onUsageError: (command: Command) => void,
+): void {
+  command.configureOutput({
+    writeOut: () => undefined,
+    writeErr: () => undefined,
+  });
+  command.exitOverride(err => {
+    const code = (err as { code?: string }).code;
+    if (code === 'commander.help' || code === 'commander.helpDisplayed') {
+      throw new HelpRequested(command);
+    }
+    onUsageError(command);
+    throw err;
+  });
+  command.commands.forEach(c => {
+    quiet(c, onUsageError);
+  });
+}
+
+export function parseCli<T = HelpRequested>(
+  spec: CliSpec,
+  argv: readonly string[],
+  onHelp?: CliHelpHook<T>,
+  onUsageError?: (command: Command, err: Error) => void,
+): CliInvocation | HelpRequested | T | undefined {
+  let invocation: CliInvocation | undefined;
+  const program = materialize(spec, found => {
+    invocation = found;
+  });
+  let errored: Command | undefined;
+  quiet(program, command => {
+    errored = command;
+  });
   try {
-    quiet(program);
-    program.parse([...args], { from: 'user' });
-    return program;
+    program.parse([...argv], { from: 'user' });
   } catch (err) {
-    return err instanceof HelpRequested ? err : undefined;
+    if (!(err instanceof HelpRequested)) {
+      if (errored !== undefined) {
+        const cause = err instanceof Error ? err : new Error(String(err));
+        onUsageError?.(errored, cause);
+      }
+      return undefined;
+    }
+    return onHelp !== undefined
+      ? onHelp(err.command.name(), err.command.helpInformation())
+      : err;
   }
+  return invocation;
 }
 
-function exitWithCode(code: number): never {
-  // eslint-disable-next-line n/no-process-exit
-  process.exit(code);
+export function helpTextFor(spec: CliSpec, topic: string): string {
+  const program = materialize(spec);
+  const command =
+    topic === spec.name
+      ? program
+      : program.commands.find(c => c.name() === topic);
+  if (command === undefined) {
+    throw new Error(`no '${topic}' command to describe`);
+  }
+  return command.helpInformation();
 }
 
-export function printHelpAndExit(command: Command): never {
-  console.log(command.helpInformation());
-  exitWithCode(0);
+function usageError(spec: CliSpec, topic?: string, message?: string): number {
+  if (message !== undefined) {
+    // Commander 15 builds its messages with the 'error: ' prefix already in.
+    process.stderr.write(`${message}\n`);
+  }
+  process.stderr.write(
+    `${helpTextFor(spec, topic === undefined ? spec.name : topic)}\n`,
+  );
+  return spec.usageExit ?? 1;
 }
 
-export function printUsageAndExit(program: Command): never {
-  console.error(program.helpInformation());
-  exitWithCode(1);
+async function call(
+  run: CliRun,
+  options: Record<string, unknown>,
+  args: readonly string[],
+): Promise<number> {
+  try {
+    return (await run(options, args)) ?? 0;
+  } catch (err) {
+    console.error((err as Error).message);
+    return 1;
+  }
 }
 
-export async function runMain(main: () => Promise<void> | void): Promise<void> {
-  try {
-    await main();
-  } catch (e) {
-    console.error((e as Error).message);
-    exitWithCode(1);
+export async function runCli(
+  spec: CliSpec,
+  argv: readonly string[],
+  onHelp?: CliHelpHook<CliResult>,
+): Promise<number> {
+  let asked: undefined | { readonly text: string; readonly topic: string };
+  let usageTopic: string | undefined;
+  let usageMessage: string | undefined;
+  const parsed = parseCli(
+    spec,
+    argv,
+    (topic, text) => {
+      asked = { topic, text };
+      return 0;
+    },
+    (command, err) => {
+      usageTopic = command.name();
+      usageMessage = err.message;
+    },
+  );
+  if (parsed === undefined) {
+    return usageError(spec, usageTopic, usageMessage);
+  }
+  if (asked !== undefined) {
+    if (onHelp !== undefined) {
+      return onHelp(asked.topic, asked.text) ?? 0;
+    }
+    process.stdout.write(`${asked.text}\n`);
+    return 0;
+  }
+  const invocation = parsed as CliInvocation;
+  if (spec.version !== undefined && invocation.root.version === true) {
+    process.stdout.write(`${spec.version}\n`);
+    return 0;
+  }
+  if (invocation.command === undefined) {
+    if ((spec.commands?.length ?? 0) > 0) {
+      return usageError(spec);
+    }
+    return spec.run === undefined
+      ? 0
+      : await call(spec.run, invocation.options, invocation.args);
   }
+  const sub = spec.commands?.find(c => c.name === invocation.command);
+  return sub?.run === undefined
+    ? 0
+    : await call(sub.run, invocation.options, invocation.args);
 }

package/src/dev.ts

@@ -1,11 +1,6 @@
-// Structural stand-ins for vite's dev server and module runner — the shared
-// hot-reload wiring below must not pull vite into core's runtime surface; the
-// MCP packages pass their real instances through.
-export interface ReloadableRunner {
-  readonly evaluatedModules: { clear(): void };
-  import<T>(entry: string): Promise<T>;
-}
-
+// A structural stand-in for vite's dev server — the shared hot-reload wiring
+// below must not pull vite into core's runtime surface; vite.ts passes the
+// real instance through.
 export interface WatchableDevServer {
   close(): Promise<unknown>;
   readonly watcher: {

package/src/draw.ts

@@ -0,0 +1,332 @@
+/**
+ * The drawing kit — the one home of the repo's terminal drawing model: ink
+ * kinds are a closed union, color values are data, surfaces render
+ * documents, and `toSgr` is the one skin, resetting each inked segment
+ * unless it carries its ink into the next. Loaded only by processes — the
+ * engine's island loader imports its own files by relative path alone.
+ */
+
+export type InkKind =
+  | 'blue'
+  | 'bold'
+  | 'brightBlack'
+  | 'cyan'
+  | 'dim'
+  | 'green'
+  | 'magenta'
+  | 'mark'
+  | 'plain'
+  | 'red'
+  | 'white'
+  | 'yellow';
+
+export type Ink =
+  | InkKind
+  | { readonly bg: Ink }
+  | { readonly indexed: number }
+  | { readonly rgb: readonly [number, number, number] };
+
+export function rgb(r: number, g: number, b: number): Ink {
+  return { rgb: [r, g, b] };
+}
+
+export function indexed(n: number): Ink {
+  return { indexed: n };
+}
+
+export function bg(ink: Ink): Ink {
+  return { bg: ink };
+}
+
+export interface Segment {
+  readonly carry?: boolean;
+  readonly ink?: Ink;
+  readonly text: string;
+}
+
+declare const lineBrand: unique symbol;
+declare const docBrand: unique symbol;
+
+export type Line = readonly Segment[] & { readonly [lineBrand]: true };
+export type Doc = readonly Line[] & { readonly [docBrand]: true };
+
+export function line(...segments: Segment[]): Line {
+  return segments as unknown as Line;
+}
+
+export function doc(...rows: Line[]): Doc {
+  return rows as unknown as Doc;
+}
+
+export function plain(text: string): Segment {
+  return { text };
+}
+
+export function dim(text: string): Segment {
+  return { text, ink: 'dim' };
+}
+
+export function bold(text: string): Segment {
+  return { text, ink: 'bold' };
+}
+
+export function green(text: string): Segment {
+  return { text, ink: 'green' };
+}
+
+export function magenta(text: string): Segment {
+  return { text, ink: 'magenta' };
+}
+
+export function red(text: string): Segment {
+  return { text, ink: 'red' };
+}
+
+export function yellow(text: string): Segment {
+  return { text, ink: 'yellow' };
+}
+
+function assertNever(kind: never): never {
+  throw new Error(`unhandled Ink kind: ${String(kind)}`);
+}
+
+function paramsOf(ink: Ink): string {
+  if (typeof ink !== 'string') {
+    if ('bg' in ink) {
+      return paramsOf(ink.bg)
+        .replace(/^3(\d)/, '4$1')
+        .replace(/^9(\d)/, '10$1');
+    }
+    return 'indexed' in ink
+      ? `38;5;${ink.indexed}`
+      : `38;2;${ink.rgb[0]};${ink.rgb[1]};${ink.rgb[2]}`;
+  }
+  switch (ink) {
+    case 'blue':
+      return '34';
+    case 'bold':
+      return '1';
+    case 'brightBlack':
+      return '90';
+    case 'cyan':
+      return '36';
+    case 'dim':
+      return '2';
+    case 'green':
+      return '32';
+    case 'magenta':
+      return '35';
+    case 'mark':
+      return '1;97';
+    case 'plain':
+      return '39';
+    case 'red':
+      return '31';
+    case 'white':
+      return '37';
+    case 'yellow':
+      return '33';
+    default:
+      return assertNever(ink);
+  }
+}
+
+function rowsOf(rows: Doc | Line): readonly (readonly Segment[])[] {
+  return (rows as readonly unknown[]).every(r => Array.isArray(r))
+    ? (rows as Doc)
+    : [rows as Line];
+}
+
+export function toSgr(rows: Doc | Line): string {
+  return rowsOf(rows)
+    .map(row => {
+      let out = '';
+      let inkOpen = false;
+      for (const seg of row) {
+        if (seg.ink === undefined) {
+          out += (inkOpen ? '\x1b[0m' : '') + seg.text;
+          inkOpen = false;
+          continue;
+        }
+        out += `\x1b[${paramsOf(seg.ink)}m${seg.text}`;
+        if (seg.carry === true) {
+          inkOpen = true;
+        } else {
+          out += '\x1b[0m';
+          inkOpen = false;
+        }
+      }
+      return inkOpen ? `${out}\x1b[0m` : out;
+    })
+    .join('\n');
+}
+
+export function stripSgr(text: string): string {
+  // eslint-disable-next-line no-control-regex
+  return text.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+export function textOf(rows: Doc | Line): string {
+  return rowsOf(rows)
+    .map(row => row.map(seg => seg.text).join(''))
+    .join('\n');
+}
+
+export interface ToolLineSource {
+  readonly deny?: string;
+  readonly isError?: boolean;
+  readonly result?: unknown;
+  readonly text?: string;
+}
+
+interface Stdio {
+  readonly stderr?: unknown;
+  readonly stdout?: unknown;
+}
+
+function stdioOf(result: unknown): Stdio {
+  return typeof result === 'object' && result !== null ? result : {};
+}
+
+export function stdoutOf(result: unknown): string {
+  const { stdout } = stdioOf(result);
+  return typeof stdout === 'string' ? stdout : '';
+}
+
+/** The one line an exec shows: the refusal's reason, stdout, else stderr or `fallback`. */
+export function lineOf(call: ToolLineSource, fallback: string): string {
+  if (call.deny !== undefined) {
+    return call.deny;
+  }
+  if (call.isError === true) {
+    return call.text ?? fallback;
+  }
+  const out = stdoutOf(call.result).trim();
+  if (out !== '') {
+    return out;
+  }
+  const { stderr } = stdioOf(call.result);
+  const err = typeof stderr === 'string' ? stderr.trim() : '';
+  return err !== '' ? err : fallback;
+}
+
+export const RULE_WIDTH = 68;
+
+export const BLOCK = '█';
+export const TRACK = '·';
+export const EIGHTHS: readonly (string | undefined)[] = [
+  '',
+  '▏',
+  '▎',
+  '▍',
+  '▌',
+  '▋',
+  '▊',
+  '▉',
+];
+
+export function rule(width: number = RULE_WIDTH): string {
+  return '─'.repeat(Math.max(0, width));
+}
+
+export function pad(
+  text: string,
+  width: number,
+  side: 'left' | 'right',
+): string {
+  if (text.length >= width) {
+    return text;
+  }
+  const gap = ' '.repeat(width - text.length);
+  return side === 'left' ? gap + text : text + gap;
+}
+
+export function meter(
+  pct: null | number | undefined,
+  width: number,
+  filled: Ink = 'green',
+): Line {
+  const safePct = typeof pct === 'number' && Number.isFinite(pct) ? pct : 0;
+  const n = Math.max(0, Math.min(width, Math.round((safePct / 100) * width)));
+  return line(
+    { text: BLOCK.repeat(n), ink: filled },
+    { text: TRACK.repeat(width - n), ink: 'dim' },
+  );
+}
+
+/** Fixed-width bar field: full blocks, an eighth-fraction edge, spaces to width. */
+export function bar(value: number, max: number, width: number): string {
+  if (!(value > 0) || !(max > 0)) {
+    return ' '.repeat(width);
+  }
+  const scaled = (value / max) * width;
+  let full = Math.floor(scaled);
+  let fi = Math.round((scaled - full) * 8);
+  if (fi === 8) {
+    full += 1;
+    fi = 0;
+  }
+  if (full === 0 && fi === 0) {
+    fi = 1;
+  }
+  let out = BLOCK.repeat(Math.min(full, width));
+  if (full < width && fi > 0) {
+    out += EIGHTHS[fi] ?? '';
+  }
+  return pad(out, width, 'right');
+}
+
+export function pad2(n: number): string {
+  return String(n).padStart(2, '0');
+}
+
+export const MONTHS = [
+  'Jan',
+  'Feb',
+  'Mar',
+  'Apr',
+  'May',
+  'Jun',
+  'Jul',
+  'Aug',
+  'Sep',
+  'Oct',
+  'Nov',
+  'Dec',
+] as const;
+
+/** Compact count: 1.2K / 3.4M / 5.6B; '—' for absent or NaN. */
+export function fmtTokens(n: null | number | undefined): string {
+  if (n == null || Number.isNaN(n)) {
+    return '—';
+  }
+  if (n >= 1e9) {
+    return (n / 1e9).toFixed(1) + 'B';
+  }
+  if (n >= 1e6) {
+    return (n / 1e6).toFixed(1) + 'M';
+  }
+  if (n >= 1e3) {
+    return (n / 1e3).toFixed(1) + 'K';
+  }
+  return String(n);
+}
+
+/** Grouped integer, en-US separators; 0 for absent. */
+export function fmtNum(n: null | number | undefined): string {
+  return (n || 0).toLocaleString('en-US');
+}
+
+export type Clock = 'minute' | 'none' | 'second';
+
+/** Local date-time stamp: `YYYY-MM-DD`, plus `HH:mm` and optionally seconds. */
+export function localStamp(now: Date, clock: Clock): string {
+  const day = `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())}`;
+  if (clock === 'none') {
+    return day;
+  }
+  const hhmm = `${pad2(now.getHours())}:${pad2(now.getMinutes())}`;
+  return clock === 'second'
+    ? `${day} ${hhmm}:${pad2(now.getSeconds())}`
+    : `${day} ${hhmm}`;
+}

package/src/index.ts

@@ -1,6 +1,8 @@
-export * from './cli.js';
-export * from './dev.js';
-export * from './input.js';
-export * from './last-reply.js';
-export * from './logger.js';
-export * from './shutdown.js';
+export * from './cli.ts';
+export * from './dev.ts';
+export * from './draw.ts';
+export * from './input.ts';
+export * from './last-reply.ts';
+export * from './logger.ts';
+export * from './mcp.ts';
+export * from './shutdown.ts';

package/src/logger.ts

@@ -15,16 +15,36 @@ const LEVEL_LABEL: Record<Exclude<LogLevel, 'silent'>, string> = {
   warn: 'WARN',
 };
 
+const VALID_LEVELS: readonly LogLevel[] = [
+  'debug',
+  'info',
+  'warn',
+  'error',
+  'silent',
+];
+
+export function loggerFromEnv(
+  env: NodeJS.ProcessEnv,
+  variable: string,
+  fallback: LogLevel = 'info',
+): Logger {
+  const raw = env[variable];
+  return new Logger(VALID_LEVELS.find(level => level === raw) ?? fallback);
+}
+
 type Writer = (message: string) => void;
 
 // stdout carries the MCP transport; everything here goes to stderr.
 export class Logger {
+  readonly activeLevel: LogLevel;
+
   private readonly stderr: Writer;
 
   constructor(
-    readonly activeLevel: LogLevel,
+    activeLevel: LogLevel,
     stderr: Writer = line => process.stderr.write(`${line}\n`),
   ) {
+    this.activeLevel = activeLevel;
     this.stderr = stderr;
   }
 

package/src/mcp.ts

@@ -0,0 +1,69 @@
+import type { Logger } from './logger.ts';
+
+export interface TextContent {
+  readonly text: string;
+  readonly type: 'text';
+}
+
+// The index signature mirrors the SDK's CallToolResult (zod-inferred, so it
+// carries one); without it an interface would not assign to that type.
+export interface ErrorResult {
+  [key: string]: unknown;
+  readonly content: TextContent[];
+  readonly isError: true;
+}
+
+export function describeError(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+export type ToolRun<Args, Result> = (args: Args) => Promise<Result> | Result;
+
+/** A zod schema, named structurally so core stays zod-free. */
+export interface ToolInputSchema<Args> {
+  parse(raw: unknown): Args;
+}
+
+/**
+ * The wrapper owns the error-drift class: a thrown or rejected error (zod
+ * parse included) logs and answers an `isError` result instead of escaping
+ * the tool call.
+ */
+export function toolHandler<Result>(
+  log: Logger,
+  toErrorResult: (err: unknown) => Result,
+) {
+  return tool;
+
+  function tool<Args>(
+    name: string,
+    run: (args: Args) => Promise<Result>,
+    schema?: ToolInputSchema<Args>,
+  ): (raw?: unknown) => Promise<Result>;
+  function tool<Args>(
+    name: string,
+    run: (args: Args) => Result,
+    schema?: ToolInputSchema<Args>,
+  ): (raw?: unknown) => Result;
+  function tool<Args>(
+    name: string,
+    run: ToolRun<Args, Result>,
+    schema?: ToolInputSchema<Args>,
+  ): ToolRun<unknown, Result> {
+    function fail(err: unknown): Result {
+      log.error(`${name} failed: ${describeError(err)}`);
+      return toErrorResult(err);
+    }
+    return raw => {
+      try {
+        const args = schema === undefined ? (raw as Args) : schema.parse(raw);
+        const result = run(args);
+        return result instanceof Promise
+          ? result.then(undefined, fail)
+          : result;
+      } catch (err) {
+        return fail(err);
+      }
+    };
+  }
+}

package/src/vite.ts

@@ -1,71 +1,89 @@
-/**
- * The one two-mode build every mod home runs — a home's `vite.config.ts` is a
- * thin wrapper handing `modVite` its standalone mode name and extra entries.
- */
+import { dirname, resolve } from 'node:path';
+import {
+  createServerModuleRunner,
+  createServer as createViteServer,
+} from 'vite';
 import { configDefaults } from 'vitest/config';
 
-export interface ModViteOptions {
-  /** Extra CLI-pass entries beside the CLI itself, e.g. tokens' `text` library chunk. */
-  entries?: Record<string, string>;
-  /** The `--mode` that builds the standalone artifact, and the `bin/<name>.mjs` it emits. */
-  standalone: { mode: string; name: string };
+import type { Logger } from './logger.ts';
+
+import { watchWithReload } from './dev.ts';
+import { describeError } from './mcp.ts';
+import { shutdownOnSignals } from './shutdown.ts';
+
+export interface ServerViteOptions {
+  testTimeout?: number;
 }
 
-export function modVite(
-  mode: string,
-  { standalone, entries = {} }: ModViteOptions,
-) {
-  // The standalone pass emits the artifact the plugin folder carries — the
-  // mod execs it through the session's Bash tool, where no node_modules
-  // exists, so it inlines every dependency. Only ever run under `node`, where
-  // the banner is inert.
-  if (mode === standalone.mode) {
-    return {
-      ssr: { noExternal: true },
-      build: {
-        outDir: 'dist',
-        emptyOutDir: false,
-        sourcemap: true,
-        minify: false,
-        ssr: true,
-        rollupOptions: {
-          input: { [standalone.name]: 'src/index.ts' },
-          output: {
-            banner: '#!/usr/bin/env node',
-            entryFileNames: `${standalone.name}.mjs`,
-          },
-        },
-      },
-    };
-  }
-  // The CLI pass builds the default way: external deps, installed beside it
-  // by npx. SSR/Node build: Vite externalizes node built-ins AND package.json
-  // `dependencies` (`@v1nvn/agentic-core` stays a real dep), so only source
-  // is bundled; ESM out matches "type":"module".
+export function serverVite({ testTimeout }: ServerViteOptions = {}) {
   return {
-    build: {
-      outDir: 'dist',
-      emptyOutDir: true,
-      sourcemap: true,
-      minify: false,
-      ssr: true,
-      rollupOptions: {
-        input: { index: 'src/index.ts', ...entries },
-        // `bin` (dist/index.js) is exec'd by the kernel; without a shebang
-        // the OS runs it under /bin/sh and `npx <bin>` dies parsing `import`.
-        // Library chunks carry none.
-        output: {
-          banner: (chunk: { facadeModuleId?: string; isEntry: boolean }) =>
-            chunk.isEntry && chunk.facadeModuleId?.endsWith('src/index.ts')
-              ? '#!/usr/bin/env node'
-              : '',
-        },
-      },
-    },
+    // Vite 8 spins the HMR websocket from `server.ws`, not `server.hmr`
+    // (`hmr: false` stops messaging, not the socket): without this a second
+    // dev boot dies fighting over the default ws port 24678.
+    server: { ws: false },
     test: {
       globals: true,
       environment: 'node',
-      exclude: [...configDefaults.exclude, 'dist/**', 'tests/**'],
+      ...(testTimeout === undefined ? {} : { testTimeout }),
+      exclude: [...configDefaults.exclude, 'dist/**'],
     },
   };
 }
+
+export interface DevSession<T> {
+  closers: readonly { close(): Promise<unknown> }[];
+  reload(module: T): void;
+}
+
+/**
+ * The hot-reload harness every MCP-server dev entry runs. The transport and
+ * McpServer are single-use under the SDK (`StdioServerTransport.start()`
+ * throws on a second call), so `start` creates and connects them once and
+ * only the registrations swap on each file change. `start` must register
+ * before connecting — the SDK's `registerCapabilities` throws post-connect.
+ * `entry` is the module that exports the registration families, at
+ * `<package root>/src/<name>.ts`.
+ */
+export async function runDevServer<T>(options: {
+  entry: string;
+  log: Logger;
+  start: (module: T) => DevSession<T> | Promise<DevSession<T>>;
+}): Promise<void> {
+  const vite = await createViteServer({
+    appType: 'custom',
+    configFile: false,
+    // Vite logs `info` (e.g. "(ssr) page reload") via console.log to stdout,
+    // which corrupts the MCP stream; `warn` keeps errors on stderr.
+    logLevel: 'warn',
+    root: resolve(dirname(options.entry), '..'),
+    server: { middlewareMode: true, ws: false },
+  });
+
+  // hmr: false in a hot-reload harness looks wrong but is right: the
+  // watcher re-imports the whole entry rather than patching modules.
+  const runner = createServerModuleRunner(vite.environments.ssr, {
+    hmr: false,
+  });
+
+  const first = await runner.import<T>(options.entry);
+  const session = await options.start(first);
+
+  async function runOneReload(): Promise<void> {
+    try {
+      runner.evaluatedModules.clear();
+      // Import the next module before reload removes the live
+      // registrations: a failed import leaves what is serving intact.
+      const next = await runner.import<T>(options.entry);
+      session.reload(next);
+      options.log.info('[reload] success');
+    } catch (err) {
+      options.log.error(`[reload] failed: ${describeError(err)}`);
+    }
+  }
+
+  watchWithReload(vite, runOneReload);
+
+  options.log.info('[reload] ready');
+
+  shutdownOnSignals([...session.closers, vite]);
+}

package/dist/index.js

@@ -1,214 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-//#region src/cli.ts
-var HelpRequested = class extends Error {
-	command;
-	constructor(command) {
-		super(`${command.name()} --help`);
-		this.command = command;
-	}
-};
-function parseQuietly(program, args) {
-	function quiet(command) {
-		command.configureOutput({
-			writeOut: () => void 0,
-			writeErr: () => void 0
-		});
-		command.exitOverride((err) => {
-			const code = err.code;
-			if (code === "commander.help" || code === "commander.helpDisplayed") throw new HelpRequested(command);
-			throw err;
-		});
-		command.commands.forEach(quiet);
-	}
-	try {
-		quiet(program);
-		program.parse([...args], { from: "user" });
-		return program;
-	} catch (err) {
-		return err instanceof HelpRequested ? err : void 0;
-	}
-}
-function exitWithCode(code) {
-	process.exit(code);
-}
-function printHelpAndExit(command) {
-	console.log(command.helpInformation());
-	exitWithCode(0);
-}
-function printUsageAndExit(program) {
-	console.error(program.helpInformation());
-	exitWithCode(1);
-}
-async function runMain(main) {
-	try {
-		await main();
-	} catch (e) {
-		console.error(e.message);
-		exitWithCode(1);
-	}
-}
-//#endregion
-//#region src/dev.ts
-var RELOAD_DEBOUNCE_MS = 150;
-var IGNORED_SEGMENTS = [
-	"/node_modules/",
-	"/dist/",
-	"/.git/",
-	"/coverage/"
-];
-function shouldReload(file) {
-	return IGNORED_SEGMENTS.every((seg) => !file.includes(seg));
-}
-/**
-* Debounced file-change reloads, serialized via a promise chain: concurrent
-* saves never overlap, and a mid-reload save still produces a follow-up.
-*/
-function watchWithReload(vite, reload) {
-	let chain = Promise.resolve();
-	let timer;
-	vite.watcher.on("change", (file) => {
-		if (!shouldReload(file)) return;
-		if (timer) clearTimeout(timer);
-		timer = setTimeout(() => {
-			timer = void 0;
-			chain = chain.then(reload);
-		}, RELOAD_DEBOUNCE_MS);
-	});
-}
-//#endregion
-//#region src/input.ts
-function readAll(stream) {
-	return new Promise((resolve, reject) => {
-		let data = "";
-		stream.setEncoding("utf8");
-		stream.on("data", (chunk) => {
-			data += chunk;
-		});
-		stream.on("end", () => {
-			resolve(data);
-		});
-		stream.on("error", reject);
-	});
-}
-function readStdin(stream = process.stdin) {
-	return readAll(stream);
-}
-/** A markdown file's contents, with the CLI's no-such-file error. */
-function readMarkdownFile(path) {
-	if (!statSync(path, { throwIfNoEntry: false })?.isFile()) throw new Error(`no such file: ${path}`);
-	return readFileSync(path, "utf8");
-}
-//#endregion
-//#region src/last-reply.ts
-function isFile(path) {
-	try {
-		return statSync(path).isFile();
-	} catch {
-		return false;
-	}
-}
-function textBlocks(entry) {
-	const content = entry.message?.content;
-	if (entry.type !== "assistant" || !Array.isArray(content)) return;
-	const blocks = content.filter((b) => typeof b === "object" && b !== null && b.type === "text");
-	return blocks.length > 0 ? blocks : void 0;
-}
-function claudeProjectsDir() {
-	const claudeDir = process.env.CLAUDE_DIR ?? join(homedir(), ".claude");
-	return join(claudeDir, "projects");
-}
-/**
-* The last assistant text reply from a Claude Code session, reproducing Claude
-* Code's `/copy` byte-for-byte: the last assistant entry that contains a
-* `text` block, only its `text` block(s) (tool_use / thinking dropped), blocks
-* joined with a blank line, and no trailing newline.
-*
-* @param arg a transcript file, a session UUID under the project dir, or
-*   nothing to use the newest session for the current project.
-*/
-function lastReply(arg) {
-	const proj = (process.env.CLAUDE_PROJECT_DIR ?? process.cwd()).replaceAll("/", "-");
-	const projDir = join(claudeProjectsDir(), proj);
-	let file;
-	if (arg !== void 0) file = isFile(arg) ? arg : join(projDir, `${arg}.jsonl`);
-	else if (existsSync(projDir)) {
-		const newest = readdirSync(projDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({
-			f,
-			mtimeMs: statSync(join(projDir, f)).mtimeMs
-		})).sort((a, b) => b.mtimeMs - a.mtimeMs).at(0);
-		if (newest) file = join(projDir, newest.f);
-	}
-	if (file === void 0 || !isFile(file)) throw new Error(`no session transcript found in ${projDir}`);
-	let last;
-	for (const line of readFileSync(file, "utf8").split("\n")) {
-		if (!line.includes("\"assistant\"")) continue;
-		let entry;
-		try {
-			entry = JSON.parse(line);
-		} catch {
-			continue;
-		}
-		const blocks = textBlocks(entry);
-		if (blocks) last = blocks;
-	}
-	return (last ?? []).map((b) => b.text ?? "").join("\n\n");
-}
-//#endregion
-//#region src/logger.ts
-var LEVEL_RANK = {
-	debug: 10,
-	info: 20,
-	warn: 30,
-	error: 40,
-	silent: Number.MAX_SAFE_INTEGER
-};
-var LEVEL_LABEL = {
-	debug: "DEBUG",
-	error: "ERROR",
-	info: "INFO",
-	warn: "WARN"
-};
-var Logger = class {
-	activeLevel;
-	stderr;
-	constructor(activeLevel, stderr = (line) => process.stderr.write(`${line}\n`)) {
-		this.activeLevel = activeLevel;
-		this.stderr = stderr;
-	}
-	debug(message) {
-		this.log("debug", message);
-	}
-	error(message) {
-		this.log("error", message);
-	}
-	info(message) {
-		this.log("info", message);
-	}
-	warn(message) {
-		this.log("warn", message);
-	}
-	log(level, message) {
-		if (LEVEL_RANK[level] >= LEVEL_RANK[this.activeLevel]) this.stderr(`${LEVEL_LABEL[level]} ${message}`);
-	}
-};
-//#endregion
-//#region src/shutdown.ts
-/** Close each closable in order (best-effort), then force-exit. */
-function shutdownOnSignals(closables, signals = ["SIGINT", "SIGTERM"]) {
-	function shutdown() {
-		closables.reduce((acc, closable) => acc.then(async () => {
-			try {
-				await closable.close();
-			} catch {}
-		}), Promise.resolve()).finally(() => {
-			process.exit(0);
-		});
-	}
-	for (const signal of signals) process.on(signal, shutdown);
-}
-//#endregion
-export { HelpRequested, Logger, claudeProjectsDir, lastReply, parseQuietly, printHelpAndExit, printUsageAndExit, readMarkdownFile, readStdin, runMain, shutdownOnSignals, watchWithReload };
-
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/cli.ts","../src/dev.ts","../src/input.ts","../src/last-reply.ts","../src/logger.ts","../src/shutdown.ts"],"sourcesContent":["import type { Command } from 'commander';\n\n// A --help ask caught mid-parse: parseQuietly returns it instead of exiting,\n// so a spec can drive the parse and the bin decides to print and exit.\nexport class HelpRequested extends Error {\n  constructor(readonly command: Command) {\n    super(`${command.name()} --help`);\n  }\n}\n\nexport function parseQuietly(\n  program: Command,\n  args: readonly string[],\n): Command | HelpRequested | undefined {\n  function quiet(command: Command): void {\n    command.configureOutput({\n      writeOut: () => undefined,\n      writeErr: () => undefined,\n    });\n    command.exitOverride(err => {\n      const code = (err as { code?: string }).code;\n      if (code === 'commander.help' || code === 'commander.helpDisplayed') {\n        throw new HelpRequested(command);\n      }\n      throw err;\n    });\n    command.commands.forEach(quiet);\n  }\n  try {\n    quiet(program);\n    program.parse([...args], { from: 'user' });\n    return program;\n  } catch (err) {\n    return err instanceof HelpRequested ? err : undefined;\n  }\n}\n\nfunction exitWithCode(code: number): never {\n  // eslint-disable-next-line n/no-process-exit\n  process.exit(code);\n}\n\nexport function printHelpAndExit(command: Command): never {\n  console.log(command.helpInformation());\n  exitWithCode(0);\n}\n\nexport function printUsageAndExit(program: Command): never {\n  console.error(program.helpInformation());\n  exitWithCode(1);\n}\n\nexport async function runMain(main: () => Promise<void> | void): Promise<void> {\n  try {\n    await main();\n  } catch (e) {\n    console.error((e as Error).message);\n    exitWithCode(1);\n  }\n}\n","// Structural stand-ins for vite's dev server and module runner — the shared\n// hot-reload wiring below must not pull vite into core's runtime surface; the\n// MCP packages pass their real instances through.\nexport interface ReloadableRunner {\n  readonly evaluatedModules: { clear(): void };\n  import<T>(entry: string): Promise<T>;\n}\n\nexport interface WatchableDevServer {\n  close(): Promise<unknown>;\n  readonly watcher: {\n    on(event: 'change', cb: (file: string) => void): unknown;\n  };\n}\n\nconst RELOAD_DEBOUNCE_MS = 150;\n\nconst IGNORED_SEGMENTS = ['/node_modules/', '/dist/', '/.git/', '/coverage/'];\n\nfunction shouldReload(file: string): boolean {\n  return IGNORED_SEGMENTS.every(seg => !file.includes(seg));\n}\n\n/**\n * Debounced file-change reloads, serialized via a promise chain: concurrent\n * saves never overlap, and a mid-reload save still produces a follow-up.\n */\nexport function watchWithReload(\n  vite: WatchableDevServer,\n  reload: () => Promise<void>,\n): void {\n  let chain: Promise<void> = Promise.resolve();\n  let timer: NodeJS.Timeout | undefined;\n  vite.watcher.on('change', file => {\n    if (!shouldReload(file)) {\n      return;\n    }\n    if (timer) {\n      clearTimeout(timer);\n    }\n    timer = setTimeout(() => {\n      timer = undefined;\n      chain = chain.then(reload);\n    }, RELOAD_DEBOUNCE_MS);\n  });\n}\n","import { readFileSync, statSync } from 'node:fs';\n\nfunction readAll(stream: NodeJS.ReadableStream): Promise<string> {\n  return new Promise((resolve, reject) => {\n    let data = '';\n    stream.setEncoding('utf8');\n    stream.on('data', (chunk: string) => {\n      data += chunk;\n    });\n    stream.on('end', () => {\n      resolve(data);\n    });\n    stream.on('error', reject);\n  });\n}\n\nexport function readStdin(\n  stream: NodeJS.ReadableStream = process.stdin,\n): Promise<string> {\n  return readAll(stream);\n}\n\n/** A markdown file's contents, with the CLI's no-such-file error. */\nexport function readMarkdownFile(path: string): string {\n  const stats = statSync(path, { throwIfNoEntry: false });\n  if (!stats?.isFile()) {\n    throw new Error(`no such file: ${path}`);\n  }\n  return readFileSync(path, 'utf8');\n}\n","import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';\nimport { homedir } from 'node:os';\nimport { join } from 'node:path';\n\nfunction isFile(path: string): boolean {\n  try {\n    return statSync(path).isFile();\n  } catch {\n    return false;\n  }\n}\n\ninterface ContentBlock {\n  text?: string;\n  type: string;\n}\n\ninterface TranscriptEntry {\n  message?: { content?: unknown };\n  type?: string;\n}\n\nfunction textBlocks(entry: TranscriptEntry): ContentBlock[] | undefined {\n  const content = entry.message?.content;\n  if (entry.type !== 'assistant' || !Array.isArray(content)) {\n    return undefined;\n  }\n  const blocks = content.filter(\n    (b): b is ContentBlock =>\n      typeof b === 'object' &&\n      b !== null &&\n      (b as ContentBlock).type === 'text',\n  );\n  return blocks.length > 0 ? blocks : undefined;\n}\n\nexport function claudeProjectsDir(): string {\n  const claudeDir = process.env.CLAUDE_DIR ?? join(homedir(), '.claude');\n  return join(claudeDir, 'projects');\n}\n\n/**\n * The last assistant text reply from a Claude Code session, reproducing Claude\n * Code's `/copy` byte-for-byte: the last assistant entry that contains a\n * `text` block, only its `text` block(s) (tool_use / thinking dropped), blocks\n * joined with a blank line, and no trailing newline.\n *\n * @param arg a transcript file, a session UUID under the project dir, or\n *   nothing to use the newest session for the current project.\n */\nexport function lastReply(arg?: string): string {\n  // Claude Code keys transcripts under the project root with \"/\" → \"-\".\n  // Prefer $CLAUDE_PROJECT_DIR (exported to hook processes) over $PWD.\n  const proj = (process.env.CLAUDE_PROJECT_DIR ?? process.cwd()).replaceAll(\n    '/',\n    '-',\n  );\n  const projDir = join(claudeProjectsDir(), proj);\n\n  let file: string | undefined;\n  if (arg !== undefined) {\n    file = isFile(arg) ? arg : join(projDir, `${arg}.jsonl`);\n  } else if (existsSync(projDir)) {\n    const newest = readdirSync(projDir)\n      .filter(f => f.endsWith('.jsonl'))\n      .map(f => ({ f, mtimeMs: statSync(join(projDir, f)).mtimeMs }))\n      .sort((a, b) => b.mtimeMs - a.mtimeMs)\n      .at(0);\n    if (newest) {\n      file = join(projDir, newest.f);\n    }\n  }\n\n  if (file === undefined || !isFile(file)) {\n    throw new Error(`no session transcript found in ${projDir}`);\n  }\n\n  let last: ContentBlock[] | undefined;\n  for (const line of readFileSync(file, 'utf8').split('\\n')) {\n    if (!line.includes('\"assistant\"')) {\n      continue;\n    }\n    let entry: TranscriptEntry;\n    try {\n      entry = JSON.parse(line) as TranscriptEntry;\n    } catch {\n      continue;\n    }\n    const blocks = textBlocks(entry);\n    if (blocks) {\n      last = blocks;\n    }\n  }\n  return (last ?? []).map(b => b.text ?? '').join('\\n\\n');\n}\n","export type LogLevel = 'debug' | 'error' | 'info' | 'silent' | 'warn';\n\nconst LEVEL_RANK: Record<LogLevel, number> = {\n  debug: 10,\n  info: 20,\n  warn: 30,\n  error: 40,\n  silent: Number.MAX_SAFE_INTEGER,\n};\n\nconst LEVEL_LABEL: Record<Exclude<LogLevel, 'silent'>, string> = {\n  debug: 'DEBUG',\n  error: 'ERROR',\n  info: 'INFO',\n  warn: 'WARN',\n};\n\ntype Writer = (message: string) => void;\n\n// stdout carries the MCP transport; everything here goes to stderr.\nexport class Logger {\n  private readonly stderr: Writer;\n\n  constructor(\n    readonly activeLevel: LogLevel,\n    stderr: Writer = line => process.stderr.write(`${line}\\n`),\n  ) {\n    this.stderr = stderr;\n  }\n\n  debug(message: string): void {\n    this.log('debug', message);\n  }\n\n  error(message: string): void {\n    this.log('error', message);\n  }\n\n  info(message: string): void {\n    this.log('info', message);\n  }\n\n  warn(message: string): void {\n    this.log('warn', message);\n  }\n\n  private log(level: Exclude<LogLevel, 'silent'>, message: string): void {\n    if (LEVEL_RANK[level] >= LEVEL_RANK[this.activeLevel]) {\n      this.stderr(`${LEVEL_LABEL[level]} ${message}`);\n    }\n  }\n}\n","/** Close each closable in order (best-effort), then force-exit. */\nexport function shutdownOnSignals(\n  closables: readonly { close(): Promise<unknown> }[],\n  signals: readonly NodeJS.Signals[] = ['SIGINT', 'SIGTERM'],\n): void {\n  function shutdown(): void {\n    void closables\n      .reduce(\n        (acc: Promise<void>, closable) =>\n          acc.then(async () => {\n            try {\n              await closable.close();\n            } catch {\n              // best-effort; exiting regardless\n            }\n            return;\n          }),\n        Promise.resolve(),\n      )\n      .finally(() => {\n        // Force-exit on signal; the n/no-process-exit rule targets libraries.\n        // eslint-disable-next-line n/no-process-exit\n        process.exit(0);\n      });\n  }\n  for (const signal of signals) {\n    process.on(signal, shutdown);\n  }\n}\n"],"mappings":"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"}

package/dist/vite.js

@@ -1,54 +0,0 @@
-import { configDefaults } from "vitest/config";
-//#region src/vite.ts
-/**
-* The one two-mode build every mod home runs — a home's `vite.config.ts` is a
-* thin wrapper handing `modVite` its standalone mode name and extra entries.
-*/
-function modVite(mode, { standalone, entries = {} }) {
-	if (mode === standalone.mode) return {
-		ssr: { noExternal: true },
-		build: {
-			outDir: "dist",
-			emptyOutDir: false,
-			sourcemap: true,
-			minify: false,
-			ssr: true,
-			rollupOptions: {
-				input: { [standalone.name]: "src/index.ts" },
-				output: {
-					banner: "#!/usr/bin/env node",
-					entryFileNames: `${standalone.name}.mjs`
-				}
-			}
-		}
-	};
-	return {
-		build: {
-			outDir: "dist",
-			emptyOutDir: true,
-			sourcemap: true,
-			minify: false,
-			ssr: true,
-			rollupOptions: {
-				input: {
-					index: "src/index.ts",
-					...entries
-				},
-				output: { banner: (chunk) => chunk.isEntry && chunk.facadeModuleId?.endsWith("src/index.ts") ? "#!/usr/bin/env node" : "" }
-			}
-		},
-		test: {
-			globals: true,
-			environment: "node",
-			exclude: [
-				...configDefaults.exclude,
-				"dist/**",
-				"tests/**"
-			]
-		}
-	};
-}
-//#endregion
-export { modVite };
-
-//# sourceMappingURL=vite.js.map

package/dist/vite.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite.js","names":[],"sources":["../src/vite.ts"],"sourcesContent":["/**\n * The one two-mode build every mod home runs — a home's `vite.config.ts` is a\n * thin wrapper handing `modVite` its standalone mode name and extra entries.\n */\nimport { configDefaults } from 'vitest/config';\n\nexport interface ModViteOptions {\n  /** Extra CLI-pass entries beside the CLI itself, e.g. tokens' `text` library chunk. */\n  entries?: Record<string, string>;\n  /** The `--mode` that builds the standalone artifact, and the `bin/<name>.mjs` it emits. */\n  standalone: { mode: string; name: string };\n}\n\nexport function modVite(\n  mode: string,\n  { standalone, entries = {} }: ModViteOptions,\n) {\n  // The standalone pass emits the artifact the plugin folder carries — the\n  // mod execs it through the session's Bash tool, where no node_modules\n  // exists, so it inlines every dependency. Only ever run under `node`, where\n  // the banner is inert.\n  if (mode === standalone.mode) {\n    return {\n      ssr: { noExternal: true },\n      build: {\n        outDir: 'dist',\n        emptyOutDir: false,\n        sourcemap: true,\n        minify: false,\n        ssr: true,\n        rollupOptions: {\n          input: { [standalone.name]: 'src/index.ts' },\n          output: {\n            banner: '#!/usr/bin/env node',\n            entryFileNames: `${standalone.name}.mjs`,\n          },\n        },\n      },\n    };\n  }\n  // The CLI pass builds the default way: external deps, installed beside it\n  // by npx. SSR/Node build: Vite externalizes node built-ins AND package.json\n  // `dependencies` (`@v1nvn/agentic-core` stays a real dep), so only source\n  // is bundled; ESM out matches \"type\":\"module\".\n  return {\n    build: {\n      outDir: 'dist',\n      emptyOutDir: true,\n      sourcemap: true,\n      minify: false,\n      ssr: true,\n      rollupOptions: {\n        input: { index: 'src/index.ts', ...entries },\n        // `bin` (dist/index.js) is exec'd by the kernel; without a shebang\n        // the OS runs it under /bin/sh and `npx <bin>` dies parsing `import`.\n        // Library chunks carry none.\n        output: {\n          banner: (chunk: { facadeModuleId?: string; isEntry: boolean }) =>\n            chunk.isEntry && chunk.facadeModuleId?.endsWith('src/index.ts')\n              ? '#!/usr/bin/env node'\n              : '',\n        },\n      },\n    },\n    test: {\n      globals: true,\n      environment: 'node',\n      exclude: [...configDefaults.exclude, 'dist/**', 'tests/**'],\n    },\n  };\n}\n"],"mappings":";;;;;;AAaA,SAAgB,QACd,MACA,EAAE,YAAY,UAAU,CAAC,KACzB;CAKA,IAAI,SAAS,WAAW,MACtB,OAAO;EACL,KAAK,EAAE,YAAY,KAAK;EACxB,OAAO;GACL,QAAQ;GACR,aAAa;GACb,WAAW;GACX,QAAQ;GACR,KAAK;GACL,eAAe;IACb,OAAO,GAAG,WAAW,OAAO,eAAe;IAC3C,QAAQ;KACN,QAAQ;KACR,gBAAgB,GAAG,WAAW,KAAK;IACrC;GACF;EACF;CACF;CAMF,OAAO;EACL,OAAO;GACL,QAAQ;GACR,aAAa;GACb,WAAW;GACX,QAAQ;GACR,KAAK;GACL,eAAe;IACb,OAAO;KAAE,OAAO;KAAgB,GAAG;IAAQ;IAI3C,QAAQ,EACN,SAAS,UACP,MAAM,WAAW,MAAM,gBAAgB,SAAS,cAAc,IAC1D,wBACA,GACR;GACF;EACF;EACA,MAAM;GACJ,SAAS;GACT,aAAa;GACb,SAAS;IAAC,GAAG,eAAe;IAAS;IAAW;GAAU;EAC5D;CACF;AACF"}