open-classify 0.4.0 → 0.5.0

package/dist/src/classifiers.js

@@ -1,11 +1,13 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { buildStockClassifierPrompt } from "./stock-prompt.js";
+import { buildClassifierPrompt } from "./stock-prompt.js";
 import { validateJsonClassifierManifest, validateOutputForManifest, } from "./stock-validation.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CLASSIFIERS_DIR = join(__dirname, "classifiers");
-const KIND_DIRS = ["stock", "custom"];
+// Directories whose names start with "_" are reserved for shared assets
+// (e.g. `_prompts/`) and are not loaded as classifiers.
+const SHARED_DIRECTORY_PREFIX = "_";
 export class ClassifierManifestError extends Error {
     constructor(message) {
         super(message);
@@ -17,53 +19,53 @@ export function loadClassifierRegistry(classifiersDir = CLASSIFIERS_DIR) {
         throw new ClassifierManifestError(`classifier directory not found: ${classifiersDir}`);
     }
     const manifests = [];
-    for (const kind of KIND_DIRS) {
-        const kindDir = join(classifiersDir, kind);
-        if (!existsSync(kindDir))
+    for (const entry of readdirSync(classifiersDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
             continue;
-        for (const entry of readdirSync(kindDir, { withFileTypes: true })) {
-            if (!entry.isDirectory())
-                continue;
-            if (kind === "stock" && entry.name === "prompts")
-                continue;
-            manifests.push(loadClassifierManifest(join(kindDir, entry.name), kind));
-        }
+        if (entry.name.startsWith(SHARED_DIRECTORY_PREFIX))
+            continue;
+        manifests.push(loadClassifierManifest(join(classifiersDir, entry.name)));
     }
-    manifests.sort((a, b) => a.order - b.order);
+    // Lower dispatch_order runs first. Classifiers without dispatch_order sort
+    // last (treated as +Infinity) — useful for "run me whenever there's a slot".
+    manifests.sort((a, b) => (a.dispatch_order ?? Infinity) - (b.dispatch_order ?? Infinity));
     validateRegistry(manifests);
     return manifests;
 }
-function loadClassifierManifest(classifierDir, expectedKind) {
+function loadClassifierManifest(classifierDir) {
     const manifestPath = join(classifierDir, "manifest.json");
     const promptPath = join(classifierDir, "prompt.md");
     if (!existsSync(manifestPath)) {
         throw new ClassifierManifestError(`missing manifest.json in ${classifierDir}`);
     }
-    if (expectedKind === "custom" && !existsSync(promptPath)) {
+    if (!existsSync(promptPath)) {
         throw new ClassifierManifestError(`missing prompt.md in ${classifierDir}`);
     }
     const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
-    const manifest = validateJsonClassifierManifest(parsed, manifestPath);
-    if (manifest.kind !== expectedKind) {
-        throw new ClassifierManifestError(`${manifestPath}: manifest kind "${manifest.kind}" does not match parent directory "${expectedKind}"`);
-    }
+    const { manifest, reservedFields, composedOutputSchema, appliesTo } = validateJsonClassifierManifest(parsed, manifestPath);
     const directoryName = basename(classifierDir);
     if (manifest.name !== directoryName) {
         throw new ClassifierManifestError(`${manifestPath}: manifest name "${manifest.name}" does not match directory "${directoryName}"`);
     }
-    let systemPrompt = buildStockClassifierPrompt(manifest);
-    if (manifest.kind === "custom") {
-        const classifierPrompt = readFileSync(promptPath, "utf8").trim();
-        if (classifierPrompt.length === 0) {
-            throw new ClassifierManifestError(`prompt.md must not be empty: ${promptPath}`);
-        }
-        systemPrompt = `${systemPrompt}\n\nClassifier guidance:\n${classifierPrompt}`;
+    const classifierPromptText = readFileSync(promptPath, "utf8");
+    if (classifierPromptText.trim().length === 0) {
+        throw new ClassifierManifestError(`prompt.md must not be empty: ${promptPath}`);
     }
-    return { ...manifest, systemPrompt };
+    const systemPrompt = buildClassifierPrompt({
+        manifest,
+        reservedFields,
+        appliesTo,
+        classifierPromptText,
+    });
+    return {
+        ...manifest,
+        systemPrompt,
+        composedOutputSchema,
+        reservedFields,
+        appliesTo,
+    };
 }
 function validateRegistry(manifests) {
-    // Duplicate orders are allowed: same-order classifiers schedule adjacent
-    // and run in parallel when concurrency permits, sequentially otherwise.
     const names = new Set();
     for (const manifest of manifests) {
         if (names.has(manifest.name)) {

package/dist/src/classify.d.ts

@@ -1,10 +1,17 @@
 import { type RunClassifier } from "./classifiers.js";
 import { type OpenClassifyConfig } from "./config.js";
-import type { AggregatorConfig, Catalog, PipelineResult } from "./manifest.js";
+import type { AggregatorConfig, Catalog, InspectResult, PipelineResult } from "./manifest.js";
 import type { OpenClassifyInput } from "./types.js";
 export type Classifier = (input: OpenClassifyInput, options?: {
     signal?: AbortSignal;
 }) => Promise<PipelineResult>;
+export type Inspector = (input: OpenClassifyInput, options?: {
+    signal?: AbortSignal;
+}) => Promise<InspectResult>;
+export interface OpenClassify {
+    readonly classify: Classifier;
+    readonly inspect: Inspector;
+}
 export interface CreateClassifierOptions {
     runClassifier?: RunClassifier;
     catalog?: Catalog;
@@ -20,4 +27,4 @@ export interface CreateClassifierOptions {
     maxConcurrency?: number;
     aggregator?: AggregatorConfig;
 }
-export declare function createClassifier(options?: CreateClassifierOptions): Classifier;
+export declare function createClassifier(options?: CreateClassifierOptions): OpenClassify;

package/dist/src/classify.js

@@ -1,11 +1,11 @@
 // High-level facade for the pipeline. Builds the runner and catalog once,
-// then returns a closure callers can invoke many times without re-loading
-// config or the catalog from disk. Backend-agnostic: pass a custom
-// `runClassifier` to bypass the bundled Ollama runner entirely.
+// then returns two functions — classify() for the user-input/routing pass
+// and inspect() for the assistant-output lean pass. Backend-agnostic: pass a
+// custom `runClassifier` to bypass the bundled Ollama runner entirely.
 import { loadCatalog } from "./catalog.js";
 import { classifierModelsFromConfig, loadOpenClassifyConfig, } from "./config.js";
 import { assertOllamaResources, createOllamaClassifierRunner, OLLAMA_DEFAULT_CATALOG_PATH, } from "./ollama.js";
-import { classifyOpenClassifyInput } from "./pipeline.js";
+import { classifyOpenClassifyInput, inspectOpenClassifyInput, } from "./pipeline.js";
 export function createClassifier(options = {}) {
     const fileConfig = options.config ??
         loadOpenClassifyConfig(options.configPath, {
@@ -30,14 +30,17 @@ export function createClassifier(options = {}) {
         loadCatalog(options.catalogPath ?? fileConfig?.catalog ?? OLLAMA_DEFAULT_CATALOG_PATH);
     const aggregator = options.aggregator ?? fileConfig?.aggregator;
     let resourceCheck;
-    return async (input, callOptions) => {
-        if (needsResourceCheck) {
-            resourceCheck ??= assertOllamaResources({
-                minTotalMemoryBytes: options.minTotalMemoryBytes,
-                minAvailableMemoryBytes: options.minAvailableMemoryBytes,
-            });
-            await resourceCheck;
-        }
+    const ensureResources = async () => {
+        if (!needsResourceCheck)
+            return;
+        resourceCheck ??= assertOllamaResources({
+            minTotalMemoryBytes: options.minTotalMemoryBytes,
+            minAvailableMemoryBytes: options.minAvailableMemoryBytes,
+        });
+        await resourceCheck;
+    };
+    const classify = async (input, callOptions) => {
+        await ensureResources();
         return classifyOpenClassifyInput(input, {
             runClassifier,
             catalog,
@@ -48,4 +51,15 @@ export function createClassifier(options = {}) {
             signal: callOptions?.signal,
         });
     };
+    const inspect = async (input, callOptions) => {
+        await ensureResources();
+        return inspectOpenClassifyInput(input, {
+            runClassifier,
+            classifierTimeoutMs: options.classifierTimeoutMs,
+            classifierRetryCount: options.classifierRetryCount,
+            maxConcurrency: options.maxConcurrency,
+            signal: callOptions?.signal,
+        });
+    };
+    return { classify, inspect };
 }

package/dist/src/config.d.ts

@@ -16,10 +16,7 @@ export interface OllamaRunnerConfig {
         readonly seed?: number;
         readonly num_ctx?: number;
     };
-    readonly models?: {
-        readonly stock?: Readonly<Record<string, string>>;
-        readonly custom?: Readonly<Record<string, string>>;
-    };
+    readonly models?: Readonly<Record<string, string>>;
 }
 export declare class OpenClassifyConfigError extends Error {
     constructor(message: string);

package/dist/src/config.js

@@ -1,6 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { REGISTRY } from "./classifiers.js";
-import { STOCK_CLASSIFIER_NAMES } from "./stock.js";
+import { CLASSIFIER_NAMES } from "./classifiers.js";
 import { isRecord } from "./validation.js";
 export const DEFAULT_OPEN_CLASSIFY_CONFIG_PATH = "open-classify.config.json";
 export class OpenClassifyConfigError extends Error {
@@ -25,13 +24,7 @@ export function loadOpenClassifyConfig(path = process.env.OPEN_CLASSIFY_CONFIG ?
     return validateOpenClassifyConfig(parsed, path);
 }
 export function classifierModelsFromConfig(config) {
-    const models = config?.runner?.models;
-    if (!models)
-        return {};
-    return {
-        ...models.stock,
-        ...models.custom,
-    };
+    return { ...config?.runner?.models };
 }
 export function validateOpenClassifyConfig(value, path = "open-classify config") {
     if (!isRecord(value)) {
@@ -103,37 +96,16 @@ function validateModels(value, path) {
     if (!isRecord(value)) {
         throwConfig(path, "runner.models must be an object");
     }
-    ensureAllowedKeys(value, ["stock", "custom"], path, "runner.models");
-    return {
-        ...(value.stock === undefined
-            ? {}
-            : { stock: validateModelMap(value.stock, path, "runner.models.stock", stockClassifierNames()) }),
-        ...(value.custom === undefined
-            ? {}
-            : { custom: validateModelMap(value.custom, path, "runner.models.custom", customClassifierNames()) }),
-    };
-}
-function validateModelMap(value, path, field, allowedNames) {
-    if (!isRecord(value)) {
-        throwConfig(path, `${field} must be an object`);
-    }
+    const allowed = new Set(CLASSIFIER_NAMES);
     const out = {};
     for (const [name, model] of Object.entries(value)) {
-        if (!allowedNames.has(name)) {
-            throwConfig(path, `${field}.${name} is not a known classifier`);
+        if (!allowed.has(name)) {
+            throwConfig(path, `runner.models.${name} is not a known classifier`);
         }
-        out[name] = requireString(model, path, `${field}.${name}`);
+        out[name] = requireString(model, path, `runner.models.${name}`);
     }
     return out;
 }
-function stockClassifierNames() {
-    return new Set(STOCK_CLASSIFIER_NAMES);
-}
-function customClassifierNames() {
-    return new Set(REGISTRY
-        .filter((classifier) => classifier.kind === "custom")
-        .map((classifier) => classifier.name));
-}
 function requireString(value, path, field) {
     if (typeof value !== "string" || value.trim().length === 0) {
         throwConfig(path, `${field} must be a non-empty string`);

package/dist/src/index.d.ts

@@ -8,6 +8,7 @@ export * from "./input.js";
 export * from "./manifest.js";
 export * from "./ollama.js";
 export * from "./pipeline.js";
+export * from "./reserved-fields.js";
 export * from "./stock.js";
 export * from "./stock-prompt.js";
 export * from "./stock-validation.js";

package/dist/src/index.js

@@ -13,6 +13,7 @@ export * from "./input.js";
 export * from "./manifest.js";
 export * from "./ollama.js";
 export * from "./pipeline.js";
+export * from "./reserved-fields.js";
 export * from "./stock.js";
 export * from "./stock-prompt.js";
 export * from "./stock-validation.js";

package/dist/src/input.d.ts

@@ -1,4 +1,7 @@
 import type { ClassifierInput, NormalizedOpenClassifyInput, OpenClassifyInput } from "./types.js";
 export declare function sanitizeText(raw: string): string;
-export declare function normalizeOpenClassifyInput(input: OpenClassifyInput): NormalizedOpenClassifyInput;
+export interface NormalizeOptions {
+    readonly expectedRole?: "user" | "assistant";
+}
+export declare function normalizeOpenClassifyInput(input: OpenClassifyInput, options?: NormalizeOptions): NormalizedOpenClassifyInput;
 export declare function toClassifierInput(normalized: NormalizedOpenClassifyInput): ClassifierInput;

package/dist/src/input.js

@@ -51,10 +51,11 @@ export function sanitizeText(raw) {
 function hashCanonicalValue(value) {
     return createHash("sha256").update(canonicalJson(value)).digest("hex").slice(0, 8);
 }
-export function normalizeOpenClassifyInput(input) {
+export function normalizeOpenClassifyInput(input, options = {}) {
     assertPlainObject(input, "input");
     rejectUnknownFields(input, INPUT_FIELDS, "input");
-    const messages = normalizeMessages(input.messages);
+    const expectedRole = options.expectedRole ?? "user";
+    const messages = normalizeMessages(input.messages, expectedRole);
     const target = messages[messages.length - 1];
     const text = target.text;
     const normalized = {
@@ -63,7 +64,7 @@ export function normalizeOpenClassifyInput(input) {
         target_message_hash: "",
     };
     normalized.target_message_hash = hashCanonicalValue({
-        role: target.role ?? "user",
+        role: target.role ?? expectedRole,
         text,
     });
     return normalized;
@@ -75,14 +76,14 @@ export function toClassifierInput(normalized) {
         target_message_hash: normalized.target_message_hash,
     };
 }
-function normalizeMessages(messages) {
+function normalizeMessages(messages, expectedRole) {
     if (!Array.isArray(messages)) {
         throw new TypeError("input.messages must be an array");
     }
     if (messages.length === 0) {
         throw new Error("input.messages must contain at least one message");
     }
-    return takeNewestWholeMessagesThatFit(messages);
+    return takeNewestWholeMessagesThatFit(messages, expectedRole);
 }
 function normalizeConversationMessage(message, path) {
     assertPlainObject(message, path);
@@ -104,12 +105,13 @@ function normalizeConversationMessage(message, path) {
 // Walk the message history newest → oldest, keeping whole messages while
 // we're under both the count cap and the character budget. The final
 // message is non-negotiable (it's what we're classifying) — we validate it
-// stricter, force role=user, and never drop it on length grounds.
+// stricter, force role to the expected one, and never drop it on length
+// grounds.
 //
 // We never slice text inside a message: classifiers depend on the full
 // final message, and slicing earlier ones at arbitrary boundaries tends to
 // confuse models more than it helps.
-function takeNewestWholeMessagesThatFit(messages) {
+function takeNewestWholeMessagesThatFit(messages, expectedRole) {
     const selected = [];
     let totalChars = 0;
     for (let index = messages.length - 1; index >= 0; index -= 1) {
@@ -119,10 +121,10 @@ function takeNewestWholeMessagesThatFit(messages) {
             if (normalized.text.length === 0) {
                 throw new Error("final message is empty after sanitization");
             }
-            if (normalized.role !== undefined && normalized.role !== "user") {
-                throw new Error("final message must have role user");
+            if (normalized.role !== undefined && normalized.role !== expectedRole) {
+                throw new Error(`final message must have role ${expectedRole}`);
             }
-            normalized.role = "user";
+            normalized.role = expectedRole;
             if (normalized.text.length > CONVERSATION_TEXT_MAX_CHARS) {
                 throw new RangeError(`final message must be ${CONVERSATION_TEXT_MAX_CHARS} characters or fewer`);
             }

package/dist/src/manifest.d.ts

@@ -1,4 +1,4 @@
-import type { AckReplySignal, ClassifierOutput, CustomClassifierOutput, FinalReplySignal, PromptInjectionSignal, RoutingSignal, RuntimeClassifierManifest, ToolsSignal } from "./stock.js";
+import type { AckReplySignal, ClassifierAuditOutput, ClassifierOutput, FinalReplySignal, PromptInjectionSignal, RoutingSignal, RuntimeClassifierManifest, ToolsSignal } from "./stock.js";
 import type { ClassifierInput, ClassifierRunStatus } from "./types.js";
 import type { DownstreamModelTier, ModelSpecialization } from "./enums.js";
 export type ClassifierName = string;
@@ -20,11 +20,11 @@ export interface Catalog {
 }
 export interface ModelRecommendationResolution {
     readonly constraints_used: Partial<{
-        specialization: ModelSpecialization;
-        tier: DownstreamModelTier;
+        model_specialization: ModelSpecialization;
+        model_tier: DownstreamModelTier;
     }>;
     readonly constraints_dropped: ReadonlyArray<{
-        readonly axis: "specialization" | "tier";
+        readonly axis: "model_specialization" | "model_tier";
         readonly reason: "low_confidence" | "no_match_relaxed" | "default_fallback";
     }>;
     readonly confidences: Partial<{
@@ -47,10 +47,10 @@ export interface Envelope {
     readonly routing?: RoutingSignal;
     readonly tools?: ToolsSignal;
     readonly prompt_injection?: PromptInjectionSignal;
-    readonly custom_outputs: ReadonlyArray<CustomClassifierOutput>;
+    readonly classifier_outputs: ReadonlyArray<ClassifierAuditOutput>;
     readonly model_recommendation: ModelRecommendation;
 }
-export type ClassifierCustomOutputs = Record<string, unknown>;
+export type ClassifierPublicOutputs = Record<string, Record<string, unknown>>;
 export interface DownstreamTargetMessage {
     readonly role: "user";
     readonly text: string;
@@ -76,11 +76,15 @@ export interface PipelineMeta {
 export interface PipelineAudit extends Envelope {
     readonly meta: PipelineMeta;
 }
+export interface InspectResult {
+    readonly target_message_hash: string;
+    readonly classifier_outputs: ClassifierPublicOutputs;
+}
 export interface PipelineResult {
     readonly action: "route";
     readonly target_message_hash: string;
     readonly downstream: DownstreamPayload;
-    readonly classifier_outputs: ClassifierCustomOutputs;
+    readonly classifier_outputs: ClassifierPublicOutputs;
     readonly audit: PipelineAudit;
 }
 export interface AggregatorConfig {

package/dist/src/pipeline.d.ts

@@ -1,5 +1,5 @@
 import { type RunClassifier } from "./classifiers.js";
-import type { AggregatorConfig, Catalog, PipelineResult } from "./manifest.js";
+import type { AggregatorConfig, Catalog, InspectResult, PipelineResult } from "./manifest.js";
 import type { OpenClassifyInput } from "./types.js";
 export declare const DEFAULT_CLASSIFIER_TIMEOUT_MS = 15000;
 export declare const DEFAULT_CLASSIFIER_RETRY_COUNT = 1;
@@ -16,4 +16,12 @@ export interface ClassifyOptions {
     aggregator?: AggregatorConfig;
     signal?: AbortSignal;
 }
+export interface InspectOptions {
+    runClassifier: RunClassifier;
+    classifierTimeoutMs?: number;
+    classifierRetryCount?: number;
+    maxConcurrency?: number;
+    signal?: AbortSignal;
+}
 export declare function classifyOpenClassifyInput(input: OpenClassifyInput, options: ClassifyOptions): Promise<PipelineResult>;
+export declare function inspectOpenClassifyInput(input: OpenClassifyInput, options: InspectOptions): Promise<InspectResult>;

package/dist/src/pipeline.js

@@ -1,7 +1,7 @@
 import { composeEnvelope } from "./aggregator.js";
 import { MODULES_BY_NAME, REGISTRY, } from "./classifiers.js";
 import { normalizeOpenClassifyInput, toClassifierInput } from "./input.js";
-import { certaintyScore, isCustomManifest } from "./stock.js";
+import { certaintyScore } from "./stock.js";
 export const DEFAULT_CLASSIFIER_TIMEOUT_MS = 15_000;
 export const DEFAULT_CLASSIFIER_RETRY_COUNT = 1;
 export const DEFAULT_MAX_CONCURRENCY = 7;
@@ -12,9 +12,28 @@ export class OpenClassifyNormalizationError extends Error {
     }
 }
 export async function classifyOpenClassifyInput(input, options) {
+    const { request, results, meta } = await runPipeline(input, "user", options);
+    const classifierInput = toClassifierInput(request);
+    const envelope = composeEnvelope({
+        registry: filteredRegistry("user"),
+        results,
+        catalog: options.catalog,
+        input: classifierInput,
+        config: options.aggregator,
+    });
+    return buildRouteResult(request, envelope, results, meta);
+}
+export async function inspectOpenClassifyInput(input, options) {
+    const { request, results } = await runPipeline(input, "assistant", options);
+    return {
+        target_message_hash: request.target_message_hash,
+        classifier_outputs: classifierPublicOutputs(filteredRegistry("assistant"), results),
+    };
+}
+async function runPipeline(input, role, options) {
     let request;
     try {
-        request = normalizeOpenClassifyInput(input);
+        request = normalizeOpenClassifyInput(input, { expectedRole: role });
     }
     catch (error) {
         throw new OpenClassifyNormalizationError(error);
@@ -33,26 +52,26 @@ export async function classifyOpenClassifyInput(input, options) {
     const classifierTimeoutMs = options.classifierTimeoutMs ?? DEFAULT_CLASSIFIER_TIMEOUT_MS;
     const classifierRetryCount = options.classifierRetryCount ?? DEFAULT_CLASSIFIER_RETRY_COUNT;
     const maxConcurrency = resolveMaxConcurrency(options.maxConcurrency);
-    // REGISTRY is already sorted by `order` ascending (see classifiers.ts).
-    // The worker pool dispatches in array order, so classifiers with the same
-    // order are scheduled adjacent and run together when slots are free.
-    const queue = REGISTRY.map((m) => m.name);
+    // REGISTRY is already sorted by `dispatch_order` ascending. Filter by
+    // applies_to so we only dispatch classifiers relevant to this role; the
+    // worker pool then runs them in the remaining order.
+    const registry = filteredRegistry(role);
+    const queue = registry.map((m) => m.name);
     try {
         const settled = await runWithConcurrency(queue, maxConcurrency, controller.signal, (name) => runClassifierWithRetry(name, classifierInput, options.runClassifier, controller.signal, classifierTimeoutMs, classifierRetryCount));
-        const { results, meta } = collectFullEntries(settled);
-        const envelope = composeEnvelope({
-            registry: REGISTRY,
-            results,
-            catalog: options.catalog,
-            input: classifierInput,
-            config: options.aggregator,
-        });
-        return buildRouteResult(request, envelope, results, meta);
+        const { results, meta } = collectFullEntries(settled, registry);
+        return { request, results, meta };
     }
     finally {
         options.signal?.removeEventListener("abort", abortFromOptions);
     }
 }
+function filteredRegistry(role) {
+    return REGISTRY.filter((m) => roleAppliesTo(m.appliesTo, role));
+}
+function roleAppliesTo(appliesTo, role) {
+    return appliesTo === "both" || appliesTo === role;
+}
 function resolveMaxConcurrency(value) {
     if (value === undefined)
         return DEFAULT_MAX_CONCURRENCY;
@@ -90,7 +109,7 @@ async function runWithConcurrency(names, maxConcurrency, signal, start) {
     await Promise.all(Array.from({ length: workerCount }, () => worker()));
     return results;
 }
-function collectFullEntries(settled) {
+function collectFullEntries(settled, registry) {
     const results = {};
     const classifiers = {};
     for (const s of settled) {
@@ -103,10 +122,10 @@ function collectFullEntries(settled) {
             version: manifest.version,
         };
     }
-    return { results, meta: { classifiers, certainty: certaintySummary(results) } };
+    return { results, meta: { classifiers, certainty: certaintySummary(results, registry) } };
 }
-function certaintySummary(results) {
-    const scores = REGISTRY.map((m) => scoreCertainty(results[m.name]?.certainty));
+function certaintySummary(results, registry) {
+    const scores = registry.map((m) => scoreCertainty(results[m.name]?.certainty));
     if (scores.length === 0)
         return { min: 0, avg: 0 };
     const min = Math.min(...scores);
@@ -130,25 +149,32 @@ function buildRouteResult(request, envelope, results, meta) {
         action: "route",
         target_message_hash: request.target_message_hash,
         downstream,
-        classifier_outputs: classifierCustomOutputs(results),
+        classifier_outputs: classifierPublicOutputs(filteredRegistry("user"), results),
         audit: {
             ...envelope,
             meta,
         },
     };
 }
-function classifierCustomOutputs(results) {
+// Expose each classifier's payload — every output field except `reason` and
+// `certainty`. Iterates the supplied registry so we only surface classifiers
+// that actually ran for this role.
+function classifierPublicOutputs(registry, results) {
     const out = {};
-    for (const manifest of REGISTRY) {
-        if (!isCustomManifest(manifest))
-            continue;
+    for (const manifest of registry) {
         const result = results[manifest.name];
         if (result === undefined)
             continue;
-        out[manifest.name] = result.output;
+        out[manifest.name] = stripMetadata(result);
     }
     return out;
 }
+function stripMetadata(output) {
+    const { reason, certainty, ...payload } = output;
+    void reason;
+    void certainty;
+    return payload;
+}
 async function runClassifierWithRetry(name, input, runClassifier, rootSignal, timeoutMs, retryCount) {
     let lastError = new Error(`${name} classifier did not run`);
     let lastReason = "error";

package/dist/src/reserved-fields.d.ts

@@ -0,0 +1,18 @@
+import type { ToolDefinition } from "./stock.js";
+export declare const RESERVED_FIELD_NAMES: readonly ["final_reply", "ack_reply", "model_tier", "model_specialization", "tools", "risk_level"];
+export type ReservedFieldName = (typeof RESERVED_FIELD_NAMES)[number];
+export declare const RESERVED_FIELD_NAME_SET: ReadonlySet<string>;
+export declare const RESERVED_FIELD_EXCLUSIONS: ReadonlyArray<ReadonlyArray<ReservedFieldName>>;
+export declare const RESERVED_REPLY_MAX_CHARS = 200;
+export interface ReservedFieldContext {
+    readonly allowed_tools?: ReadonlyArray<ToolDefinition>;
+}
+export interface ReservedFieldDefinition {
+    readonly name: ReservedFieldName;
+    readonly requiresAllowedTools: boolean;
+    subSchema(context: ReservedFieldContext): unknown;
+    promptFragment(context: ReservedFieldContext): string;
+}
+export declare const RESERVED_FIELDS: Readonly<Record<ReservedFieldName, ReservedFieldDefinition>>;
+export declare function isReservedFieldName(name: string): name is ReservedFieldName;
+export declare function normalizeToolId(tool: string): string;