@arnilo/prism 0.3.2 → 0.5.0

package/dist/capture.d.ts

@@ -0,0 +1,63 @@
+/** Provider request/response capture middleware (plan 062, review §7 P1):
+ *  opt-in observation of already-normalized provider shapes — never raw HTTP.
+ *
+ *  Request side rides the existing `provider_request` middleware hook; response
+ *  side rides the existing subscriber-event seam (`provider_turn_finished`,
+ *  which core already redacts). No new seam. Captured entries land in a capped
+ *  FIFO ring buffer (`maxEvents`, default 100).
+ *
+ *  Privacy policy `redact` controls content retention:
+ *  - `"all"`: structure only — model id, counts, tool names, usage, latency.
+ *  - `"secrets"` (default): also drops message content (the privacy default:
+ *    captured buffers carry no conversation text unless the host opts in).
+ *  - `"none"`: retains message content for replay debugging.
+ *  Secret redaction is unconditional in every mode (replay-safe by
+ *  construction): retained material passes through the same `redactSecrets`
+ *  helper the logging seams use, so credentials never survive into a buffer
+ *  that a host might persist or replay. Provider request/response options and
+ *  headers are never captured at all — headers are where credentials ride.
+ */
+import type { AgentEvent, ProviderRequest } from "./contracts.js";
+import type { Middleware } from "./middleware.js";
+import { type SecretRedactor } from "./redaction.js";
+export type CaptureRedaction = "secrets" | "all" | "none";
+export interface ProviderCapturePolicy {
+    /** Content-retention level; `"secrets"` (default) drops message content. */
+    readonly redact?: CaptureRedaction;
+    /** Ring-buffer capacity; oldest entries evict first. Default 100. */
+    readonly maxEvents?: number;
+}
+export interface ProviderCaptureOptions {
+    readonly policy?: ProviderCapturePolicy;
+    /** Secrets redacted from every retained field, matching the logging seams. */
+    readonly secrets?: readonly (string | undefined)[];
+    readonly redactor?: SecretRedactor;
+    readonly now?: () => number;
+}
+export interface ProviderCaptureEntry {
+    readonly kind: "request" | "response";
+    readonly at: string;
+    readonly redaction: CaptureRedaction;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly messageCount?: number;
+    readonly toolNames?: readonly string[];
+    /** Message content — present only when the policy retains it (`"none"`), secrets redacted. */
+    readonly content?: unknown;
+    /** Response entries: normalized usage numbers (never sensitive). */
+    readonly usage?: unknown;
+    readonly latencyMs?: number;
+    readonly error?: unknown;
+}
+export interface ProviderCapture {
+    /** Register on the existing `provider_request` middleware hook. Passes the
+     *  request through untouched and records one entry per round. */
+    middleware(): Middleware<ProviderRequest>;
+    /** Feed `provider_turn_finished` events from the session's existing
+     *  subscriber loop (`session.subscribe()`) to record response entries. */
+    observeEvent(event: AgentEvent): void;
+    /** Ring-buffer snapshot, oldest first. */
+    events(): readonly ProviderCaptureEntry[];
+    clear(): void;
+}
+export declare function createProviderCapture(options?: ProviderCaptureOptions): ProviderCapture;

package/dist/capture.js

@@ -0,0 +1,67 @@
+import { resolveRedactor } from "./redaction.js";
+const DEFAULT_MAX_EVENTS = 100;
+const HARD_MAX_EVENTS_CAP = 10_000;
+function resolveMaxEvents(maxEvents) {
+    const value = maxEvents ?? DEFAULT_MAX_EVENTS;
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new Error("maxEvents must be a positive integer");
+    return Math.min(value, HARD_MAX_EVENTS_CAP);
+}
+export function createProviderCapture(options = {}) {
+    const redaction = options.policy?.redact ?? "secrets";
+    const maxEvents = resolveMaxEvents(options.policy?.maxEvents);
+    const now = options.now ?? Date.now;
+    const redactor = resolveRedactor(options.redactor, options.secrets);
+    const buffer = [];
+    const record = (entry) => {
+        buffer.push(entry);
+        if (buffer.length > maxEvents)
+            buffer.splice(0, buffer.length - maxEvents);
+    };
+    return {
+        middleware() {
+            return (request, next) => {
+                const entry = {
+                    kind: "request",
+                    at: new Date(now()).toISOString(),
+                    redaction,
+                    provider: request.model.provider,
+                    model: request.model.model,
+                    messageCount: request.messages.length,
+                    toolNames: request.tools?.map((tool) => tool.name),
+                    ...(redaction === "none" && request.messages.length > 0
+                        ? { content: redactor ? redactor.redact(request.messages) : request.messages }
+                        : {}),
+                };
+                record(entry);
+                return next(request);
+            };
+        },
+        observeEvent(event) {
+            if (event.type !== "provider_turn_finished")
+                return;
+            const metadata = (event.metadata ?? {});
+            record({
+                kind: "response",
+                at: new Date(now()).toISOString(),
+                redaction,
+                provider: typeof metadata.providerId === "string" ? metadata.providerId : undefined,
+                model: typeof metadata.model?.model === "string"
+                    ? metadata.model.model
+                    : undefined,
+                usage: event.usage,
+                latencyMs: typeof metadata.latencyMs === "number" ? metadata.latencyMs : undefined,
+                // Core already redacts emitted errors; redact again so replay safety holds even
+                // when a host feeds events captured before redaction.
+                error: event.error && redactor ? redactor.redact(event.error) : event.error,
+            });
+        },
+        events() {
+            return [...buffer];
+        },
+        clear() {
+            buffer.length = 0;
+        },
+    };
+}
+//# sourceMappingURL=capture.js.map

package/dist/cli-dev.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Plan 040 Task 4 — `prism dev` delegation into `@arnilo/prism-dev`.
+ * The core deliberately holds no compile-time dependency on the dev package
+ * (dev-only surface, omitted from umbrellas): the subcommand resolves the
+ * package from the current project's own `node_modules` and hands the CLI
+ * over. Unresolvable → actionable install hint, exit 2.
+ */
+import type { Writable } from "node:stream";
+export interface DevCliModule {
+    runDevCli(argv: readonly string[], runtime: {
+        stdout: Writable;
+        stderr: Writable;
+        cwd?: string;
+    }): Promise<number>;
+}
+export type PrismDevLoader = () => Promise<DevCliModule | undefined>;
+export interface PrismDevSubcommandRuntime {
+    readonly stdout: Writable;
+    readonly stderr: Writable;
+    /** Test injection: overrides project-level `@arnilo/prism-dev` resolution. */
+    readonly loadDevCli?: PrismDevLoader;
+}
+/**
+ * Default loader: resolve `@arnilo/prism-coding-tools/dev/cli` (or `@arnilo/prism-dev/cli`)
+ * from the project the user is standing in, falling back to this CLI's own installation.
+ */
+export declare const defaultLoadDevCli: PrismDevLoader;
+/** Runs the `prism dev` subcommand by delegating into the resolved package. */
+export declare function runPrismDevSubcommand(argv: readonly string[], runtime: PrismDevSubcommandRuntime): Promise<number>;

package/dist/cli-dev.js

@@ -0,0 +1,52 @@
+/**
+ * Plan 040 Task 4 — `prism dev` delegation into `@arnilo/prism-dev`.
+ * The core deliberately holds no compile-time dependency on the dev package
+ * (dev-only surface, omitted from umbrellas): the subcommand resolves the
+ * package from the current project's own `node_modules` and hands the CLI
+ * over. Unresolvable → actionable install hint, exit 2.
+ */
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+const installHint = "prism dev requires the dev inspector package in this project.\n" +
+    "  npm install --save-dev @arnilo/prism-coding-tools\n" +
+    "(Scaffolded projects from newer `prism init` templates already include it.)\n";
+/**
+ * Default loader: resolve `@arnilo/prism-coding-tools/dev/cli` (or `@arnilo/prism-dev/cli`)
+ * from the project the user is standing in, falling back to this CLI's own installation.
+ */
+export const defaultLoadDevCli = async () => {
+    const specifiers = ["@arnilo/prism-coding-tools/dev/cli", "@arnilo/prism-dev/cli"];
+    for (const specifier of specifiers) {
+        try {
+            const require = createRequire(join(process.cwd(), "package.json"));
+            const resolved = require.resolve(specifier);
+            const mod = (await import(pathToFileURL(resolved).href));
+            if (typeof mod.runDevCli === "function")
+                return mod;
+        }
+        catch {
+            try {
+                const mod = (await import(specifier));
+                if (typeof mod.runDevCli === "function")
+                    return mod;
+            }
+            catch {
+                // try next specifier
+            }
+        }
+    }
+    return undefined;
+};
+/** Runs the `prism dev` subcommand by delegating into the resolved package. */
+export async function runPrismDevSubcommand(argv, runtime) {
+    const load = runtime.loadDevCli ?? defaultLoadDevCli;
+    const mod = await load();
+    if (!mod || typeof mod.runDevCli !== "function") {
+        runtime.stderr.write(installHint);
+        return 2;
+    }
+    return mod.runDevCli(argv, { stdout: runtime.stdout, stderr: runtime.stderr });
+}
+//# sourceMappingURL=cli-dev.js.map

package/dist/cli-init.d.ts

@@ -4,6 +4,8 @@ export declare class InitUsageError extends Error {
 export type InitProvider = string;
 export interface InitOptions {
     readonly directory: string;
+    readonly template?: string;
+    readonly listTemplates?: boolean;
     readonly provider: InitProvider;
     readonly withWorkflows: boolean;
     readonly withEvals: boolean;
@@ -15,6 +17,8 @@ export interface InitRuntime {
     readonly stderr: Writable;
     /** Override template root (tests). Defaults to package `templates/init`. */
     readonly templatesRoot?: string;
+    /** Override gallery root (tests). Defaults to package `templates`. */
+    readonly galleryRoot?: string;
     /** Override package version stamped into generated package.json. */
     readonly packageVersion?: string;
     /** Working directory used to resolve relative destinations. Defaults to process.cwd(). */
@@ -23,17 +27,44 @@ export interface InitRuntime {
 export interface InitResult {
     readonly targetDir: string;
     readonly writtenFiles: readonly string[];
+    readonly template?: string;
     readonly provider: InitProvider;
     readonly withWorkflows: boolean;
     readonly withEvals: boolean;
     readonly totalBytes: number;
 }
+export interface TemplateInfo {
+    readonly name: string;
+    readonly description: string;
+    readonly version?: string;
+    readonly path: string;
+}
+interface ProviderSpec {
+    readonly id: string;
+    readonly packageName?: string;
+    /** Module specifier the CLI's real-provider mode dynamically imports (e.g. `@arnilo/prism-providers/openai`). */
+    readonly factoryModule?: string;
+    /** Named export on `factoryModule` that builds the provider. */
+    readonly factoryExport?: string;
+    readonly envKey?: string;
+    readonly envPlaceholder?: string;
+    readonly modelProvider: string;
+    readonly modelName: string;
+    readonly imports: string;
+    readonly providerExpression: string;
+    readonly modelExpression: string;
+}
+/** Provider catalog shared by `prism init` templates and the CLI's real-provider mode. */
+export declare function loadProvidersCatalog(templatesRoot?: string): ReadonlyMap<string, ProviderSpec>;
 /** Provider ids supported by `prism init --provider`. Loaded from templates data. */
 export declare function listInitProviders(templatesRoot?: string): readonly string[];
-export declare function getInitUsage(templatesRoot?: string): string;
+/** Template list discovered from the templates gallery. */
+export declare function listInitTemplates(galleryRoot?: string): readonly TemplateInfo[];
+export declare function getInitUsage(templatesRoot?: string, galleryRoot?: string): string;
 export declare const initUsage: string;
-export declare function parseInitArgs(argv: readonly string[], templatesRoot?: string): InitOptions;
+export declare function parseInitArgs(argv: readonly string[], templatesRoot?: string, galleryRoot?: string): InitOptions;
 export declare function runInitCommand(argv: readonly string[], runtime: InitRuntime): Promise<number>;
 export declare function createInitProject(options: InitOptions, runtime?: InitRuntime): Promise<InitResult>;
 export declare function defaultTemplatesRoot(): string;
-export declare function isInitProvider(value: string, templatesRoot?: string): value is InitProvider;
+export declare function defaultGalleryRoot(): string;
+export {};

package/dist/cli-init.js

@@ -1,4 +1,4 @@
-import { constants as fsConstants, readFileSync } from "node:fs";
+import { existsSync, constants as fsConstants, readdirSync, readFileSync } from "node:fs";
 import { access, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -9,7 +9,8 @@ let cachedProviderIds;
 function providersCatalogPath(templatesRoot) {
     return join(templatesRoot, "providers.json");
 }
-function loadProvidersCatalog(templatesRoot = defaultTemplatesRoot()) {
+/** Provider catalog shared by `prism init` templates and the CLI's real-provider mode. */
+export function loadProvidersCatalog(templatesRoot = defaultTemplatesRoot()) {
     if (cachedCatalog && templatesRoot === defaultTemplatesRoot())
         return cachedCatalog;
     const raw = JSON.parse(readFileSync(providersCatalogPath(templatesRoot), "utf8"));
@@ -34,16 +35,73 @@ export function listInitProviders(templatesRoot) {
         return cachedProviderIds;
     return Object.freeze([...loadProvidersCatalog(templatesRoot).keys()]);
 }
-export function getInitUsage(templatesRoot) {
+/** Template list discovered from the templates gallery. */
+export function listInitTemplates(galleryRoot = defaultGalleryRoot()) {
+    try {
+        const entries = readdirSync(galleryRoot, { withFileTypes: true });
+        const templates = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const manifestPath = join(galleryRoot, entry.name, "manifest.json");
+                if (existsSync(manifestPath)) {
+                    try {
+                        const raw = JSON.parse(readFileSync(manifestPath, "utf8"));
+                        if (raw && typeof raw === "object" && typeof raw.name === "string") {
+                            templates.push({
+                                name: raw.name,
+                                description: typeof raw.description === "string" ? raw.description : "",
+                                version: typeof raw.version === "string" ? raw.version : undefined,
+                                path: join(galleryRoot, entry.name),
+                            });
+                        }
+                    }
+                    catch {
+                        // skip invalid manifests
+                    }
+                }
+                else if (entry.name === "init") {
+                    templates.push({
+                        name: "init",
+                        description: "Minimal starter Prism agent with one selected provider and offline mock test",
+                        path: join(galleryRoot, "init"),
+                    });
+                }
+            }
+        }
+        return Object.freeze(templates.sort((a, b) => {
+            if (a.name === "init")
+                return -1;
+            if (b.name === "init")
+                return 1;
+            return a.name.localeCompare(b.name);
+        }));
+    }
+    catch {
+        return Object.freeze([
+            {
+                name: "init",
+                description: "Minimal starter Prism agent with one selected provider and offline mock test",
+                path: join(galleryRoot, "init"),
+            },
+        ]);
+    }
+}
+export function getInitUsage(templatesRoot, galleryRoot) {
     const providers = listInitProviders(templatesRoot).join("|");
+    const templates = listInitTemplates(galleryRoot)
+        .map((t) => t.name)
+        .join("|");
     return `Usage: prism init <dir> [options]
+       prism init --list-templates
 
-Create a minimal TypeScript Prism project with one explicit provider and an offline mock test.
+Create a minimal TypeScript Prism project or scaffold from a template gallery.
 
 Arguments:
   <dir>                      Destination directory (created if missing)
 
 Options:
+  --template <name>          Template name (${templates || "init|deep-research"}). Default: init
+  --list-templates           List available templates from the gallery
   --provider <name>          Provider id (${providers}). Default: mock
   --with-workflows           Add optional workflows dependency and example
   --with-evals               Add optional evals dependency and example
@@ -52,19 +110,24 @@ Options:
 
 Examples:
   prism init my-agent
+  prism init my-research --template deep-research
+  prism init --list-templates
   prism init my-agent --provider openai
   prism init my-agent --provider openai --with-workflows
 `;
 }
 export const initUsage = getInitUsage();
-export function parseInitArgs(argv, templatesRoot) {
+export function parseInitArgs(argv, templatesRoot, galleryRoot) {
     let directory;
+    let template;
+    let listTemplates = false;
     let provider = "mock";
     let withWorkflows = false;
     let withEvals = false;
     let force = false;
     let help = false;
     const providers = listInitProviders(templatesRoot);
+    const availableTemplates = listInitTemplates(galleryRoot);
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "-h" || arg === "--help") {
@@ -75,6 +138,10 @@ export function parseInitArgs(argv, templatesRoot) {
             force = true;
             continue;
         }
+        if (arg === "--list-templates") {
+            listTemplates = true;
+            continue;
+        }
         if (arg === "--with-workflows") {
             withWorkflows = true;
             continue;
@@ -83,6 +150,18 @@ export function parseInitArgs(argv, templatesRoot) {
             withEvals = true;
             continue;
         }
+        if (arg === "--template") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("-")) {
+                throw new InitUsageError("Missing value for --template");
+            }
+            i += 1;
+            if (!availableTemplates.some((t) => t.name === value)) {
+                throw new InitUsageError(`Unknown template: ${value}. Expected one of ${availableTemplates.map((t) => t.name).join(", ")}`);
+            }
+            template = value;
+            continue;
+        }
         if (arg === "--provider") {
             const value = argv[i + 1];
             if (value === undefined || value.startsWith("-")) {
@@ -103,11 +182,13 @@ export function parseInitArgs(argv, templatesRoot) {
         }
         directory = arg;
     }
-    if (!help && directory === undefined) {
+    if (!help && !listTemplates && directory === undefined) {
         throw new InitUsageError("Missing destination directory");
     }
     return {
         directory: directory ?? ".",
+        template,
+        listTemplates,
         provider,
         withWorkflows,
         withEvals,
@@ -118,20 +199,34 @@ export function parseInitArgs(argv, templatesRoot) {
 export async function runInitCommand(argv, runtime) {
     let options;
     try {
-        options = parseInitArgs(argv, runtime.templatesRoot);
+        options = parseInitArgs(argv, runtime.templatesRoot, runtime.galleryRoot);
     }
     catch (error) {
-        write(runtime.stderr, `${error instanceof Error ? error.message : String(error)}\n${getInitUsage(runtime.templatesRoot)}`);
+        write(runtime.stderr, `${error instanceof Error ? error.message : String(error)}\n${getInitUsage(runtime.templatesRoot, runtime.galleryRoot)}`);
         return 2;
     }
     if (options.help) {
-        write(runtime.stdout, getInitUsage(runtime.templatesRoot));
+        write(runtime.stdout, getInitUsage(runtime.templatesRoot, runtime.galleryRoot));
+        return 0;
+    }
+    if (options.listTemplates) {
+        const templates = listInitTemplates(runtime.galleryRoot);
+        const lines = [
+            "Available templates:",
+            ...templates.map((t) => `  ${t.name.padEnd(16)} - ${t.description}`),
+            "",
+            "Usage:",
+            "  prism init <dir> --template <name>",
+            "",
+        ];
+        write(runtime.stdout, lines.join("\n"));
         return 0;
     }
     try {
         const result = await createInitProject(options, runtime);
         write(runtime.stdout, [
             `Created Prism project in ${result.targetDir}`,
+            ...(result.template ? [`  template: ${result.template}`] : []),
             `  provider: ${result.provider}`,
             `  files: ${result.writtenFiles.length}`,
             `  bytes: ${result.totalBytes}`,
@@ -149,7 +244,7 @@ export async function runInitCommand(argv, runtime) {
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         if (error instanceof InitUsageError) {
-            write(runtime.stderr, `${message}\n${getInitUsage(runtime.templatesRoot)}`);
+            write(runtime.stderr, `${message}\n${getInitUsage(runtime.templatesRoot, runtime.galleryRoot)}`);
             return 2;
         }
         write(runtime.stderr, `${message}\n`);
@@ -163,6 +258,7 @@ export async function createInitProject(options, runtime = {
     const cwd = runtime.cwd ?? process.cwd();
     const targetDir = resolveInitDirectory(options.directory, cwd);
     const templatesRoot = runtime.templatesRoot ?? defaultTemplatesRoot();
+    const galleryRoot = runtime.galleryRoot ?? defaultGalleryRoot();
     const version = runtime.packageVersion ?? (await readPackageVersion());
     const catalog = loadProvidersCatalog(templatesRoot);
     const provider = catalog.get(options.provider);
@@ -171,18 +267,38 @@ export async function createInitProject(options, runtime = {
     }
     const projectName = sanitizePackageName(basenameSafe(targetDir));
     await assertDestinationWritable(targetDir, options.force);
-    const tokens = buildTokens({
-        projectName,
-        version,
-        provider,
-        withWorkflows: options.withWorkflows,
-        withEvals: options.withEvals,
-    });
-    const planned = await planFiles({
-        templatesRoot,
-        withWorkflows: options.withWorkflows,
-        withEvals: options.withEvals,
-    });
+    const isCustomTemplate = Boolean(options.template && options.template !== "init");
+    let planned;
+    let tokens;
+    if (isCustomTemplate) {
+        const templateName = options.template;
+        const templateDir = join(galleryRoot, templateName);
+        if (!(await exists(templateDir))) {
+            const available = listInitTemplates(galleryRoot);
+            throw new InitUsageError(`Unknown template: ${templateName}. Expected one of ${available.map((t) => t.name).join(", ")}`);
+        }
+        planned = await planTemplateFiles(templateDir);
+        tokens = buildTokensForTemplate({
+            projectName,
+            version,
+            templateName,
+            provider,
+        });
+    }
+    else {
+        tokens = buildTokens({
+            projectName,
+            version,
+            provider,
+            withWorkflows: options.withWorkflows,
+            withEvals: options.withEvals,
+        });
+        planned = await planFiles({
+            templatesRoot,
+            withWorkflows: options.withWorkflows,
+            withEvals: options.withEvals,
+        });
+    }
     if (!options.force) {
         for (const file of planned) {
             const dest = join(targetDir, file.relativePath);
@@ -206,6 +322,7 @@ export async function createInitProject(options, runtime = {
     return {
         targetDir,
         writtenFiles,
+        template: options.template,
         provider: options.provider,
         withWorkflows: options.withWorkflows,
         withEvals: options.withEvals,
@@ -215,8 +332,59 @@ export async function createInitProject(options, runtime = {
 export function defaultTemplatesRoot() {
     return join(dirname(fileURLToPath(import.meta.url)), "..", "templates", "init");
 }
-export function isInitProvider(value, templatesRoot) {
-    return listInitProviders(templatesRoot).includes(value);
+export function defaultGalleryRoot() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..", "templates");
+}
+async function planTemplateFiles(templateDir) {
+    const files = [];
+    async function walk(dir, baseRel = "") {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            const relPath = baseRel ? `${baseRel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                await walk(fullPath, relPath);
+            }
+            else if (entry.isFile()) {
+                if (entry.name === "manifest.json")
+                    continue;
+                let targetRel = relPath.endsWith(".tmpl") ? relPath.slice(0, -5) : relPath;
+                if (targetRel.startsWith("src/tests/")) {
+                    targetRel = `src/__tests__/${targetRel.slice("src/tests/".length)}`;
+                }
+                files.push({ relativePath: targetRel, sourcePath: fullPath });
+            }
+        }
+    }
+    await walk(templateDir);
+    return files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+function buildTokensForTemplate(input) {
+    const dependencies = {
+        "@arnilo/prism": input.version,
+        "@arnilo/prism-memory": input.version,
+        "@arnilo/prism-web-tools": input.version,
+        "@arnilo/prism-workflows": input.version,
+    };
+    const dependencyLines = Object.entries(dependencies)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, ver]) => `    ${JSON.stringify(name)}: ${JSON.stringify(ver)}`)
+        .join(",\n");
+    return {
+        __PROJECT_NAME__: input.projectName,
+        __PRISM_VERSION__: input.version,
+        __TEMPLATE_NAME__: input.templateName,
+        __PROVIDER_ID__: input.provider.id,
+        __PROVIDER_PACKAGE__: input.provider.packageName ?? "",
+        __DEPENDENCIES__: dependencyLines,
+        __PROVIDER_IMPORTS__: input.provider.imports,
+        __PROVIDER_EXPRESSION__: input.provider.providerExpression,
+        __MODEL_EXPRESSION__: input.provider.modelExpression,
+        __ENV_EXAMPLE__: "",
+        __NEXT_STEPS_LIVE__: "",
+        __OPTIONAL_DOCS__: "",
+        __PROVIDER_README_NOTE__: "",
+    };
 }
 function resolveInitDirectory(input, cwd) {
     const trimmed = input.trim();

package/dist/cli-runner.d.ts

@@ -49,7 +49,7 @@ export interface CliRuntime {
     readonly stdin: Readable;
     readonly stdout: Writable;
     readonly stderr: Writable;
-    readonly createSession?: (options: CliOptions) => AgentSession;
+    readonly createSession?: (options: CliOptions) => AgentSession | Promise<AgentSession>;
     readonly commands?: RpcSessionFactory["commands"];
     /** Workspace root for `--discover`. Defaults to `process.cwd()`. */
     readonly workspaceRoot?: string;
@@ -58,6 +58,8 @@ export interface CliRuntime {
     readonly globalRoot?: string;
     /** Override init template root (tests). */
     readonly initTemplatesRoot?: string;
+    /** Override template gallery root (tests). */
+    readonly initGalleryRoot?: string;
     /** Override version stamped by `prism init` (tests). */
     readonly initPackageVersion?: string;
     /** Override provider-scaffold template root (tests). */
@@ -66,8 +68,10 @@ export interface CliRuntime {
     readonly providerPackageVersion?: string;
     /** Working directory for relative `prism init` destinations (tests). */
     readonly cwd?: string;
+    /** Test injection for `prism dev`: overrides `@arnilo/prism-dev` resolution. */
+    readonly loadDevCli?: () => Promise<unknown>;
 }
-export declare const usage = "Usage: prism [--mode print|json|rpc] [-p prompt] [options]\n       prism init <dir> [--provider <name>] [--with-workflows] [--with-evals] [--force]\n       prism providers add <name> [--base-url <url>] [--env-key <name>] [--model <id>] [--force]\n\nOptions:\n  -p, --prompt <text>        Prompt to run in print/json mode\n  --provider <name>          Explicit provider id (mock is built in for smoke tests)\n  --model <name>             Explicit model name\n  --session <id>             Session id\n  --system <text>            System instructions\n  --context <text>           Context text\n  --compact <entries>        Auto-compaction threshold\n  --max-tool-rounds <n>      Maximum tool rounds\n  --discover                 Enable workspace contribution discovery (opt-in)\n  --discover-kinds <csv>     Kinds to discover (default: skill; skill,tool,context,instructions)\n  --no-discovery             Disable discovery even if --discover is set\n  --agents-config <path>     App config root holding agents/<name>/AGENT.md bundles (opt-in)\n  --no-agents-md             Skip auto-loading <workspaceRoot>/AGENTS.md\n  --no-system-md             Skip auto-loading the global SYSTEM.md layer\n  --agents-md-file <path>    Read AGENTS.md from <path> instead (trust-gated, source: app)\n  --system-md-file <path>    Read SYSTEM.md from <path> instead (source: user)\n  -h, --help                 Show this help\n";
+export declare const usage = "Usage: prism [--mode print|json|rpc] [-p prompt] [options]\n       prism init <dir> [--template <name>] [--list-templates] [--provider <name>] [--with-workflows] [--with-evals] [--force]\n       prism providers add <name> [--base-url <url>] [--env-key <name>] [--model <id>] [--force]\n       prism dev [--port <n>] [--host <addr>]   (loopback inspector; delegates into @arnilo/prism-dev)\n\n\nOptions:\n  -p, --prompt <text>        Prompt to run in print/json mode\n  --provider <name>          Provider id from the init provider catalog ('mock' is built in;\n                             real providers need their @arnilo/prism-providers package +\n                             credential env var)\n  --model <name>             Explicit model name\n  --session <id>             Session id\n  --system <text>            System instructions\n  --context <text>           Context text\n  --compact <entries>        Auto-compaction threshold\n  --max-tool-rounds <n>      Maximum tool rounds\n  --discover                 Enable workspace contribution discovery (opt-in)\n  --discover-kinds <csv>     Kinds to discover (default: skill; skill,tool,context,instructions)\n  --no-discovery             Disable discovery even if --discover is set\n  --agents-config <path>     App config root holding agents/<name>/AGENT.md bundles (opt-in)\n  --no-agents-md             Skip auto-loading <workspaceRoot>/AGENTS.md\n  --no-system-md             Skip auto-loading the global SYSTEM.md layer\n  --agents-md-file <path>    Read AGENTS.md from <path> instead (trust-gated, source: app)\n  --system-md-file <path>    Read SYSTEM.md from <path> instead (source: user)\n  -h, --help                 Show this help\n";
 export declare function parseCliArgs(argv: readonly string[]): CliOptions;
 export declare function runCli(argv: readonly string[], runtime: CliRuntime): Promise<number>;
 export declare function runPromptMode(session: AgentSession, options: CliOptions, stdout: Writable, mode: "print" | "json"): Promise<void>;