open-classify 0.5.0 → 0.7.0

package/README.md

@@ -6,7 +6,7 @@
   Decide what should happen to a user message <em>before</em> it reaches your downstream model.
 </p>
 
-Open Classify is a pre-routing layer for AI products. It runs a small set of fast classifiers in parallel against the latest user message, then returns a single decision envelope your app can act on: a downstream model recommendation, a tool exposure list, an optional acknowledgement, and any custom signals your own classifiers contribute.
+Open Classify is a pre-routing layer for AI products. It runs a small set of fast classifiers in parallel against the latest user message, then returns a single `PipelineResult` your app can act on: an action (`route`, `block`, or `reply`), a downstream model recommendation, a tool exposure list, an optional immediate reply, and any custom signals your own classifiers contribute.
 
 Use it when your frontier model should not be the first thing every request touches. Open Classify can handle tiny terminal replies before they hit an expensive model, recommend the right downstream model for the actual task, suggest what tools or context the downstream model should receive, and add a focused prompt-injection pass.
 
@@ -17,7 +17,7 @@ message
 normalize + trim classifier context
   │
   ├─► preflight ─────────────► final_reply? / ack_reply?
-  ├─► routing ───────────────► model_tier?
+  ├─► model_tier ────────────► model_tier?
   ├─► model_specialization ──► model_specialization?
   ├─► tools ─────────────────► tools?
   ├─► prompt_injection ─────► risk_level?
@@ -28,81 +28,102 @@ normalize + trim classifier context
 aggregator + model catalog
   │
   ▼
-route
+PipelineResult { action, model_id, tools, reply, ... }
 ```
 
 Every classifier uses the same manifest shape and emits the same output envelope: `{ reason, certainty, ...payload }`. Some payload fields are **reserved** — like `model_tier`, `final_reply`, and `risk_level` — and the aggregator knows how to consume them into a routing decision. Everything else is your classifier's own data and passes through to the caller untouched.
 
 ## Why Open Classify
 
-- **Spend frontier tokens only when they matter.** Simple greetings, thanks, spelling checks, and small arithmetic can be answered immediately via `audit.final_reply` without sending the request downstream.
-- **Keep the user interface responsive.** For complex work, preflight can suggest an `ack_reply` while your app routes the request to the real worker.
+- **Spend frontier tokens only when they matter.** Simple greetings, thanks, spelling checks, and small arithmetic can be answered immediately (`action: "reply"`) without sending the request downstream.
+- **Keep the user interface responsive.** For complex work, preflight emits an `ack_reply` — a task-specific acknowledgement your UI can show while routing the real request.
 - **Pick the right model per message.** Classifiers emit soft constraints like tier and specialization; your catalog turns those into a concrete model optimized for cost, capability, and fit.
 - **Shape downstream context intentionally.** Built-in and custom classifiers can recommend tools, retrieval queries, summaries, or other context hints without passing the full conversation history back to the caller.
-- **Add another defensive layer.** The `prompt_injection` classifier surfaces instruction-override attempts so your app can decide whether to continue.
+- **Add another defensive layer.** The `prompt_injection` classifier surfaces instruction-override attempts. High-risk or unknown injection risk automatically sets `action: "block"`.
 
-## Install
+## Getting started
+
+Node 18+. The packaged runner uses local Ollama with `gemma4:e4b-it-q4_K_M` as the zero-config classifier model. Pluggable via `open-classify.config.json` or a custom `RunClassifier`.
+
+**1. Install**
 
 ```sh
 npm install open-classify
 ```
 
-Node 18+. The packaged runner is local Ollama and ships with `gemma4:e4b-it-q4_K_M` as the zero-config classifier model. That runner is configurable through `open-classify.config.json`; arbitrary backends are supported in code by implementing `RunClassifier`.
+**2. Scaffold**
 
-## Hello World
+```sh
+npx open-classify init
+```
+
+This creates `open-classify.config.json` and a `classifiers/` directory in your project root. You'll see exactly what will be written and asked to confirm. Re-run safe: existing files are skipped.
+
+**3. Use it**
 
 ```ts
 import { createClassifier } from "open-classify";
 
-const { classify, inspect } = createClassifier();
+const { classify } = createClassifier({
+  extraClassifierDirs: ["./classifiers"],
+});
 
 const result = await classify({
-  messages: [
-    { role: "user", text: "Can you review the attached contract?" },
-  ],
+  messages: [{ role: "user", text: "Can you review the attached contract?" }],
 });
 
-// result.action is always "route". Use the audit envelope and the per-classifier
-// outputs to decide what to do next.
-const { model_id, target_message, tools } = result.downstream;
-const ackReply = result.audit.ack_reply?.text;
-const queries = result.classifier_outputs.memory_retrieval_queries?.queries;
+if (result.action === "reply") respondToUser(result.reply.text);          // preflight answered it
+else if (result.action === "block") handleBlock(result.block_reason);     // injection or error
+else callDownstream(result.model_id, result.tools, result.reply?.text);   // route the real request
+```
+
+**4. Activate or customize a classifier**
+
+Inside `classifiers/` you'll find four `_<name>/` directories — templates copied from the package, inactive because of the underscore prefix. To turn one on, drop the underscore:
+
+```sh
+mv classifiers/_tools classifiers/tools
 ```
 
-`createClassifier` builds the runner and loads the model catalog once. Reuse the returned `classify` and `inspect` functions across your app — every call is a plain function invocation, no re-initialization.
+Edit `manifest.json` first if you need to (e.g. trim `allowed_tools` for your app). The same underscore convention works the other way too: rename `my_classifier/` → `_my_classifier/` to take any classifier out of the active set without deleting it.
+
+To write a new classifier from scratch, drop a `<name>/manifest.json` + `<name>/prompt.md` in `classifiers/`. See [docs/adding-a-classifier.md](docs/adding-a-classifier.md).
 
 ### Classifying assistant output
 
-`inspect()` is a lean second pass for the **assistant's reply**. It only runs classifiers tagged `applies_to: "both"` (or `"assistant"`) in their manifest, and returns just the per-classifier outputs — no routing, no model resolution, no audit envelope.
+`inspect()` is a lean second pass for the **assistant's reply**. It only runs classifiers tagged `applies_to: "both"` (or `"assistant"`) in their manifest, and returns the per-classifier outputs plus the message that was inspected — no routing, no action, no block logic.
 
 ```ts
-const reply = await inspect({
+const result = await inspect({
   messages: [
     { role: "user", text: "Summarize the contract." },
     { role: "assistant", text: "The contract has three notable risks…" },
   ],
 });
 
-const risk = reply.classifier_outputs.prompt_injection?.risk_level;
+// result.message is { role: "assistant", text: "..." }
+const risk = result.classifier_outputs.prompt_injection?.risk_level;
 ```
 
-Use it for things like prompt-injection checks on model output, summarized slugs, or any classifier you want to apply post-hoc. The built-in `prompt_injection` classifier ships tagged `"both"`, so it runs in both passes; everything else is `"user"` by default. Tag your own classifiers with `applies_to` in their manifest to opt into either side.
+Use it for things like prompt-injection checks on model output, summarized slugs, or any classifier you want to apply post-hoc. The built-in `prompt_injection` classifier ships tagged `"both"`, so it runs in both passes; everything else is `"user"` by default.
 
 ## What you get back
 
-Every call returns a `PipelineResult`:
+Every `classify()` call returns a `PipelineResult`:
 
 | Field | What it is |
 |---|---|
-| `action` | Always `"route"` — the worker pool always runs every classifier and returns aggregated results |
+| `action` | `"route"` \| `"block"` \| `"reply"` |
+| `block_reason` | `"prompt_injection"` \| `"classification_error"` (only when `action === "block"`) |
 | `target_message_hash` | Stable 8-hex fingerprint of the target message |
-| `downstream.model_id` | Concrete model id chosen from your catalog |
-| `downstream.target_message` | The sanitized target message that should be sent downstream |
-| `downstream.tools` | The recommended tool exposure (may be `{ tools: [] }`) |
-| `classifier_outputs[name]` | Each classifier's payload (reserved + custom fields) with `reason` and `certainty` stripped |
-| `audit` | The full envelope: reserved-field slots, every classifier's full output, model resolution details, and run metadata |
-
-For complex requests, look for `audit.ack_reply` — that's the immediate acknowledgement your UI can show while the downstream model works. For trivial requests, `audit.final_reply.text` is a tiny terminal answer your app can return directly without ever calling the downstream model. The pipeline never decides for you; the caller chooses what to act on.
+| `model_id` | Concrete model id chosen from your catalog (or `null` if unresolvable) |
+| `tools` | Recommended tool ids (always an array; empty if not emitted) |
+| `reply` | `{ text }` — the `ack_reply` or `final_reply` text, if any |
+| `prompt_injection` | `{ risk_level }` from the injection classifier, or `null` |
+| `avg_certainty` | Arithmetic mean certainty score (float 0–1) across all classifiers |
+| `min_certainty` | Minimum certainty score (float 0–1) across all classifiers |
+| `failed_classifiers` | Names of classifiers that errored or timed out (always present; may be empty) |
+| `classifier_outputs` | Each classifier's payload with `reason` (string) and `certainty` (float) |
 
 Example result:
 
@@ -110,56 +131,55 @@ Example result:
 {
   "action": "route",
   "target_message_hash": "b11d5268",
-  "downstream": {
-    "model_id": "gpt-5.5",
-    "tools": { "tools": ["workspace"] },
-    "target_message": { "role": "user", "text": "...", "hash": "b11d5268" }
-  },
+  "model_id": "gpt-5.5",
+  "tools": ["workspace"],
+  "reply": { "text": "On it — I'll review the contract now." },
+  "prompt_injection": { "risk_level": "normal" },
+  "avg_certainty": 0.84,
+  "min_certainty": 0.75,
+  "failed_classifiers": [],
   "classifier_outputs": {
-    "routing": { "model_tier": "frontier_strong" },
-    "model_specialization": { "model_specialization": "coding" },
-    "tools": { "tools": ["workspace"] },
-    "prompt_injection": { "risk_level": "normal" },
-    "memory_retrieval_queries": { "queries": ["user code review preferences"] }
-  },
-  "audit": {
-    "ack_reply": { "text": "Let me check." },
-    "routing": { "model_tier": "frontier_strong", "model_specialization": "coding" },
-    "tools": { "tools": ["workspace"] },
-    "prompt_injection": { "risk_level": "normal" },
-    "classifier_outputs": [ /* every classifier's full output, with reason + certainty */ ],
-    "model_recommendation": {
-      "id": "gpt-5.5",
-      "context_window": 1050000,
-      "resolution": { "...": "..." }
-    },
-    "meta": { "classifiers": { "...": "..." } }
+    "model_tier": { "model_tier": "frontier_strong", "reason": "...", "certainty": 0.88 },
+    "model_specialization": { "model_specialization": "coding", "reason": "...", "certainty": 0.75 },
+    "tools": { "tools": ["workspace"], "reason": "...", "certainty": 0.88 },
+    "prompt_injection": { "risk_level": "normal", "reason": "...", "certainty": 0.97 },
+    "memory_retrieval_queries": { "queries": ["user code review preferences"], "reason": "...", "certainty": 0.75 }
   }
 }
 ```
 
 ## Classifier model
 
-Open Classify ships with eight built-in classifiers; all use the same manifest shape. There is no distinction between "stock" and "custom" — the runtime only cares about which **reserved fields** a classifier declares.
+Every classifier — bundled or your own — uses the same two-file shape (`manifest.json` + `prompt.md`) and emits the same envelope: `{ reason, certainty, ...payload }`. Some payload fields are **reserved** (like `model_tier`, `final_reply`, `risk_level`); the aggregator knows how to consume them into the routing decision. Everything else passes through to the caller.
+
+Open Classify ships eight built-in classifiers. **Four are mandatory** — they always load, they can't be turned off, and extras can't override them. The other four ship as **templates** that `init` copies into your project as inactive (`_<name>/`); rename to activate.
 
-| Name | Reserved fields | What the aggregator does with it |
-|---|---|---|
-| `preflight` | `final_reply`, `ack_reply` | Surfaces the highest-certainty reply in `audit.final_reply` / `audit.ack_reply` |
-| `routing` | `model_tier` | Feeds the catalog resolver as a soft constraint |
-| `model_specialization` | `model_specialization` | Feeds the catalog resolver as a soft constraint |
-| `tools` | `tools` | Sets `downstream.tools` |
-| `prompt_injection` | `risk_level` | Surfaces in `audit.prompt_injection` |
-| `memory_retrieval_queries` | — | Passes through to `classifier_outputs.memory_retrieval_queries` |
-| `conversation_digest` | — | Passes through |
-| `context_shift` | — | Passes through |
+| Name | dispatch_order | Reserved fields | Bundled as | What the aggregator does with it |
+|---|---|---|---|---|
+| `preflight` | 10 | `final_reply`, `ack_reply` | mandatory | Sets `action: "reply"` or populates `result.reply` |
+| `model_tier` | 20 | `model_tier` | mandatory | Feeds the catalog resolver as a soft constraint |
+| `model_specialization` | 30 | `model_specialization` | mandatory | Feeds the catalog resolver as a soft constraint |
+| `prompt_injection` | 50 | `risk_level` | mandatory | High-risk/unknown → `action: "block"`; suspicious → advisory |
+| `tools` | 40 | `tools` | template | Sets `result.tools` |
+| `memory_retrieval_queries` | 60 | — | template | Passes through to `classifier_outputs` |
+| `conversation_digest` | 70 | — | template | Passes through |
+| `context_shift` | 80 | — | template | Passes through |
 
-Reserved fields are well-known output keys with canonical JSON Schemas and prompt fragments baked into the runtime. When you declare one in your manifest, you don't have to redeclare its enum values or shape — the runtime injects them.
+The directory-naming convention (`_<name>/` = inactive) is the only on/off mechanism, and it applies equally to bundled templates and your own classifiers. No `disabled` config, no allow-lists, no flags. If a folder is in `classifiers/` without a leading underscore, it runs.
 
-## Adding a classifier
+> Need to customize `preflight`'s prompt or any other mandatory built-in? Use a custom `RunClassifier` (see [Bring your own backend](#bring-your-own-backend)) to intercept it, or fork the package.
 
-Every classifier is two files in `src/classifiers/<name>/`:
+## Adding your own classifier
 
-`manifest.json` describes the output shape and a fallback for when the classifier errors:
+The two files are:
+
+```
+classifiers/topic_tags/
+├── manifest.json
+└── prompt.md
+```
+
+`manifest.json` declares the output shape and a fallback for when the classifier errors:
 
 ```json
 {
@@ -184,35 +204,26 @@ Every classifier is two files in `src/classifiers/<name>/`:
 }
 ```
 
-`prompt.md` describes the classification rule in plain language. You don't need to write JSON examples — the runtime synthesizes one from your schema and shows it to the model — and you don't paste enum values for reserved fields. Just describe what each output key means and when to abstain:
+`prompt.md` is the classification rule in plain language. No need to write JSON examples — the runtime synthesizes one from your schema — and no need to paste enum values for reserved fields:
 
 ```markdown
 You are the topic_tags classifier.
 
 `tags` are short single-word topic labels (lowercase, no spaces). Use at most five.
 Return an empty array when no clear topic applies.
-Do not invent tags for vague or ambiguous messages.
 ```
 
-Rules:
-
-- `name` must match the directory name.
-- Reserved field names cannot appear in `output_schema.properties` — declare them in `reserved_fields` instead.
-- `fallback` must validate against the composed schema; reserved fields are optional in fallback since "I failed" means "no signal."
-- If you want hand-picked examples (preflight does this), add an `output_schema.examples` array. Each entry must validate against the composed schema at load time. Otherwise the runtime synthesizes a skeleton example for you.
-
-Consume your output:
+Consume:
 
 ```ts
-const result = await classify(input);
 const tags = result.classifier_outputs.topic_tags?.tags ?? [];
 ```
 
-See [docs/adding-a-classifier.md](docs/adding-a-classifier.md) for a full walkthrough and [docs/manifests.md](docs/manifests.md) for the field reference.
+Rules: `name` must match the directory name; reserved-field names can't appear in `output_schema.properties` (declare them under `reserved_fields` instead); `fallback` only needs `reason` and `certainty`; name collisions throw at startup. See [docs/adding-a-classifier.md](docs/adding-a-classifier.md) for the full reference.
 
 ## Using reserved fields in your own classifier
 
-Any classifier can emit reserved fields. If you write your own `task_router` that emits `model_tier`, the aggregator will fold it into the model resolution alongside the built-in `routing` classifier — highest-certainty contributor wins, ties broken by manifest `dispatch_order` ascending.
+Any classifier can emit reserved fields. If you write your own `task_router` that emits `model_tier`, the aggregator will fold it into the model resolution alongside the built-in `model_tier` classifier — highest-certainty contributor wins, ties broken by manifest `dispatch_order` ascending.
 
 ```json
 {
@@ -262,7 +273,7 @@ Classifiers never emit model ids. They emit constraints; your catalog maps const
 }
 ```
 
-The resolver picks the cheapest model matching `model_specialization` and `model_tier`, relaxing constraints in order when nothing fits, and reports what it dropped on `audit.model_recommendation.resolution`. See [docs/resolver.md](docs/resolver.md) for ranking details.
+The resolver picks the cheapest model matching `model_specialization` and `model_tier`, relaxing constraints in order when nothing fits. See [docs/resolver.md](docs/resolver.md) for ranking details.
 
 ## Input contract
 
@@ -292,14 +303,11 @@ cp open-classify.config.example.json open-classify.config.json
     "provider": "ollama",
     "defaultModel": "gemma4:e4b-it-q4_K_M",
     "models": {
-      "routing": "qwen2.5:7b-instruct-q4_K_M",
+      "model_tier": "qwen2.5:7b-instruct-q4_K_M",
       "prompt_injection": "llama-guard3:8b",
       "memory_retrieval_queries": "qwen2.5:7b-instruct-q4_K_M"
     }
   },
-  "aggregator": {
-    "certaintyThreshold": 0.65
-  },
   "catalog": "downstream-models.json"
 }
 ```

package/bin/open-classify.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// open-classify CLI. Currently exposes a single subcommand: `init`.
+//
+// `init` scaffolds the standard project layout for a consumer:
+//   - open-classify.config.json (minimal)
+//   - classifiers/
+//     - README.md
+//     - _conversation_digest/  (templates, prefix means inactive)
+//     - _context_shift/
+//     - _memory_retrieval_queries/
+//     - _tools/
+//
+// Re-run safe: existing files are skipped, never overwritten. Use
+// `--yes` to skip the confirmation prompt (for scripted setup).
+
+import { cpSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = resolve(SCRIPT_DIR, "..");
+const TEMPLATES_DIR = join(PACKAGE_ROOT, "templates");
+
+const TEMPLATE_NAMES = ["conversation_digest", "context_shift", "memory_retrieval_queries", "tools"];
+
+const CLASSIFIERS_README = `# classifiers/
+
+Drop a folder here per classifier. Each folder needs:
+
+- \`manifest.json\` — see [open-classify docs](https://github.com/taylorbayouth/open-classify/blob/main/docs/adding-a-classifier.md)
+- \`prompt.md\` — the classifier-specific instructions
+
+## Activating templates
+
+The four \`_<name>/\` directories below are templates copied from the package — they ship inactive (the loader skips any folder starting with \`_\`). Activate one by dropping the underscore:
+
+\`\`\`sh
+mv _tools tools
+\`\`\`
+
+You probably also want to edit its \`manifest.json\` first to fit your app (e.g. trim the \`allowed_tools\` list).
+
+## Deactivating without deleting
+
+Same trick in reverse — rename \`my_classifier\` → \`_my_classifier\` to take it out of the active set without losing your work.
+`;
+
+const DEFAULT_CONFIG = {
+  runner: {
+    provider: "ollama",
+    host: "http://127.0.0.1:11434",
+    defaultModel: "gemma4:e4b-it-q4_K_M",
+  },
+  catalog: "downstream-models.json",
+};
+
+async function main() {
+  const args = process.argv.slice(2);
+  const subcommand = args[0];
+
+  if (!subcommand || subcommand === "-h" || subcommand === "--help") {
+    printHelp();
+    process.exit(subcommand ? 0 : 1);
+  }
+
+  if (subcommand === "init") {
+    const yes = args.includes("--yes") || args.includes("-y");
+    await runInit({ cwd: process.cwd(), yes });
+    return;
+  }
+
+  console.error(`Unknown subcommand: ${subcommand}`);
+  printHelp();
+  process.exit(1);
+}
+
+function printHelp() {
+  process.stdout.write(`open-classify — runtime CLI
+
+Commands:
+  init [--yes]    Scaffold open-classify.config.json and classifiers/ in the
+                  current directory. Re-run safe: existing files are skipped.
+
+`);
+}
+
+async function runInit({ cwd, yes }) {
+  const plan = planInit(cwd);
+
+  if (plan.toCreate.length === 0) {
+    console.log("Nothing to do — your project already has all the scaffolded files.");
+    if (plan.toSkip.length > 0) {
+      console.log("\nAlready in place:");
+      for (const p of plan.toSkip) console.log(`  ${p}`);
+    }
+    return;
+  }
+
+  console.log("This will create:");
+  for (const p of plan.toCreate) console.log(`  ${p}`);
+  if (plan.toSkip.length > 0) {
+    console.log("\nAlready exists (will skip):");
+    for (const p of plan.toSkip) console.log(`  ${p}`);
+  }
+
+  if (!yes) {
+    const proceed = await confirm("\nContinue? [Y/n] ");
+    if (!proceed) {
+      console.log("Aborted.");
+      process.exit(1);
+    }
+  }
+
+  for (const action of plan.actions) {
+    action();
+  }
+
+  console.log("\nDone. Wire it into your code:\n");
+  console.log("  import { createClassifier } from \"open-classify\";");
+  console.log("  const { classify } = createClassifier({");
+  console.log("    extraClassifierDirs: [\"./classifiers\"],");
+  console.log("  });");
+}
+
+function planInit(cwd) {
+  const toCreate = [];
+  const toSkip = [];
+  const actions = [];
+
+  const configPath = join(cwd, "open-classify.config.json");
+  if (existsSync(configPath)) {
+    toSkip.push(relative(cwd, configPath));
+  } else {
+    toCreate.push(relative(cwd, configPath));
+    actions.push(() => {
+      writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
+      console.log(`wrote ${relative(cwd, configPath)}`);
+    });
+  }
+
+  const classifiersDir = join(cwd, "classifiers");
+  if (!existsSync(classifiersDir)) {
+    toCreate.push(relative(cwd, classifiersDir) + "/");
+    actions.push(() => {
+      mkdirSync(classifiersDir, { recursive: true });
+      console.log(`created ${relative(cwd, classifiersDir)}/`);
+    });
+  }
+
+  const readmePath = join(classifiersDir, "README.md");
+  if (existsSync(readmePath)) {
+    toSkip.push(relative(cwd, readmePath));
+  } else {
+    toCreate.push(relative(cwd, readmePath));
+    actions.push(() => {
+      // The classifiers dir may not yet exist when we generated the plan,
+      // but it will by the time this action runs.
+      mkdirSync(classifiersDir, { recursive: true });
+      writeFileSync(readmePath, CLASSIFIERS_README);
+      console.log(`wrote ${relative(cwd, readmePath)}`);
+    });
+  }
+
+  for (const name of TEMPLATE_NAMES) {
+    const inactivePath = join(classifiersDir, `_${name}`);
+    const activePath = join(classifiersDir, name);
+
+    if (existsSync(inactivePath) || existsSync(activePath)) {
+      // Either already scaffolded (inactive) or already activated by the
+      // consumer. Either way, leave it alone.
+      toSkip.push(relative(cwd, existsSync(activePath) ? activePath : inactivePath) + "/");
+      continue;
+    }
+
+    toCreate.push(relative(cwd, inactivePath) + "/");
+    actions.push(() => {
+      mkdirSync(classifiersDir, { recursive: true });
+      cpSync(join(TEMPLATES_DIR, name), inactivePath, { recursive: true });
+      console.log(`wrote ${relative(cwd, inactivePath)}/`);
+    });
+  }
+
+  return { toCreate, toSkip, actions };
+}
+
+function confirm(prompt) {
+  return new Promise((resolveAnswer) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(prompt, (answer) => {
+      rl.close();
+      const normalized = (answer || "").trim().toLowerCase();
+      resolveAnswer(normalized === "" || normalized === "y" || normalized === "yes");
+    });
+  });
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});

package/dist/src/aggregator.d.ts

@@ -1,28 +1,12 @@
-import type { AggregatorConfig, Catalog, ClassifierRegistry, ClassifierResults, Envelope, ModelRecommendation, ModelRecommendationResolution } from "./manifest.js";
-import type { AckReplySignal, Certainty, FinalReplySignal, RoutingSignal, ToolsSignal } from "./stock.js";
-import type { DownstreamModelTier, ModelSpecialization } from "./enums.js";
-import type { ClassifierInput } from "./types.js";
-export declare const DEFAULT_CERTAINTY_THRESHOLD = 0.65;
-/** @deprecated Use DEFAULT_CERTAINTY_THRESHOLD. */
-export declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.65;
-export interface ComposeEnvelopeArgs {
+import type { Catalog, ClassifierPublicOutputs, ClassifierRegistry, ClassifierResults, PipelineResult } from "./manifest.js";
+import type { AckReplySignal, FinalReplySignal, ToolsSignal } from "./stock.js";
+export interface AssembleResultArgs {
     readonly registry: ClassifierRegistry;
     readonly results: ClassifierResults;
+    readonly failedClassifiers: ReadonlyArray<string>;
     readonly catalog: Catalog;
-    readonly input: ClassifierInput;
-    readonly config?: AggregatorConfig;
 }
-export declare function composeEnvelope(args: ComposeEnvelopeArgs): Envelope;
-export declare function certaintyThreshold(config: AggregatorConfig | undefined): number;
-export declare function resolveModelFromRouting(routing: RoutingSignal | undefined, catalog: Catalog, confidence: number | undefined, ignoredConstraints?: ModelRecommendationResolution["constraints_dropped"]): ModelRecommendation;
-export declare function resolveModel(results: Readonly<{
-    routing?: {
-        model_tier?: DownstreamModelTier;
-        certainty?: Certainty;
-    };
-    model_specialization?: {
-        model_specialization?: ModelSpecialization;
-        certainty?: Certainty;
-    };
-}>, catalog: Catalog, threshold: number): ModelRecommendation;
+type AssembledResult = Omit<PipelineResult, "target_message_hash">;
+export declare function assembleResult(args: AssembleResultArgs): AssembledResult;
+export declare function buildPublicOutputs(registry: ClassifierRegistry, results: ClassifierResults): ClassifierPublicOutputs;
 export type { FinalReplySignal, AckReplySignal, ToolsSignal };