@konneal/engine 0.2.152 → 0.2.155

package/dist/worker_public/src/index.js

@@ -4,7 +4,7 @@ import {
   handleMemories,
   scoreFaithfulness,
   scoreJudge
-} from "../../chunk-VSK2RGUF.js";
+} from "../../chunk-TXF5VMNM.js";
 import "../../chunk-ECOYO7EX.js";
 import {
   TOOLS_REGISTRY,
@@ -411,7 +411,11 @@ ${c.text.slice(0, 1500)}` }
           context = typeof raw === "string" ? raw.trim().replace(/^["\']|[\"']$/g, "").slice(0, 400) : "";
           if (!context) {
             console.log("enrich raw keys:", Object.keys(res ?? {}), "sample:", JSON.stringify(res).slice(0, 300));
-            return { id: c.id, ok: false, error: "empty enrichment" };
+            if (contextOnly || abMode) return { id: c.id, ok: false, error: "empty enrichment" };
+            const rawText = typeof c.metadata.chunk_text === "string" && c.metadata.chunk_text ? c.metadata.chunk_text : c.text;
+            const rawVector = await embed(portModelRunner(env), MODELS.embed, rawText.slice(0, 6e3));
+            await env.VECTORIZE.upsert([{ id: c.id, values: rawVector, metadata: { ...c.metadata, chunk_text: rawText } }]);
+            return { id: c.id, ok: true, raw: true, cached: false, context: "" };
           }
           if (res?.usage) {
             usage.prompt_tokens += Number(res.usage.prompt_tokens ?? 0);
@@ -1107,7 +1111,7 @@ async function callToolOnce(env, ctx, _req, tier, key, name, args, t0) {
       const r = await runTool({ ...env, DB: env.DB }, { name, args }, "mcp");
       payload = r ? { tool: r.name, query: r.query, result: r.output } : { error: { message: `tool ${name} returned nothing for the given arguments` } };
     } else {
-      const res = name === "ask" ? await (await import("../../ask-LP6M4QNS.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-GAU5SEZI.js")).handleSearch(env, ctx, inner, tier, key);
+      const res = name === "ask" ? await (await import("../../ask-MRVXR7CY.js")).handleAsk(env, ctx, inner, tier, key) : await (await import("../../search-GAU5SEZI.js")).handleSearch(env, ctx, inner, tier, key);
       payload = await res.json().catch(() => ({ error: { message: "tool transport failed", status: res.status } }));
     }
     telemetry(env, ctx, tier, `mcp:${name}`, null, !payload?.error, JSON.stringify(payload).length, await sha256Hex(`${name}:${JSON.stringify(args ?? {})}`), void 0, void 0, { durationMs: Date.now() - t0 });

package/docs/AGENT-MODE-STREAM-FIRST.md

@@ -0,0 +1,84 @@
+# The agent-mode stream-first architecture (the designed next build)
+
+## The demand (owner directive, 2026-10-15): SOTA agent bots 2026 —
+users see EVERY call as it runs. The current shape: the ask handler
+computes the ENTIRE pipeline (understanding → retrieval → register →
+nameplate vision → the agent loop) BEFORE the SSE response opens —
+the user waits minutes in silence, then receives the buffered steps +
+the answer tokens.
+
+## The target shape
+1. The SSE opens at the top of the streamed branch (right after the
+   cache check): the controller is captured; `live.send(ev)` works from
+   that moment.
+2. The pipeline runs ONCE, inside the streamed branch, emitting live:
+   - mark() sends `{type:"agent", step}` immediately (no agentSteps
+     buffer + flush).
+   - The vision/question-understanding/certificate-lookup steps each
+     send their start (and result) events — the owner's step order.
+   - The short-circuits (register count/latest, verdict) send their
+     events (citations/tokens/blocks/done) through the same channel.
+   - The generation streams tokens as today (the 0.2.148 head-buffer +
+     narration restart ride along).
+3. The JSON lane becomes a CLIENT of the same stream: run the stream,
+   aggregate {answer, citations, blocks, quota, context} from the
+   events, return json. ONE pipeline body, two delivery modes — no
+   duplication. (The done event gains the contextOut fields — additive.)
+
+## The mechanical plan
+- The block (understanding → the generation, ~610-1905 in ask.ts)
+  moves into the streamed branch inside start().
+- The exits convert: the 3 err()s → the graceful token + done; the
+  json returns inside the streamed branch → the aggregator return;
+  sseResponse(...) → live.send per event + close.
+- The json lane below the branch → the aggregator (~40 lines).
+- The event-shape additions are additive (context in done; the error
+  token convention).
+
+## The safe path
+1. The engine PR: merge safely (no deploy).
+2. Publish → the ai scratch worktree pins 0.2.15x → `npm run dev:public`
+   (the LOCAL worker, remote bindings) → the probes: the streamed
+   Chomsky refusal, the photo flow's step order, a JSON MPE ask, the
+   long question.
+3. Only after the probes: the ai pin bump PR → auto-deploy → the
+   production probes.
+
+## WHAT LANDED (0.2.151, probes green)
+
+One pipeline body, TWO DELIVERIES — but the delivery is chosen by the
+CHANNEL PARAMETER, not the request's stream preference:
+`pipeline(channel, qq)` where channel is the live SSE writer or null.
+The dispatch: `if (liveResponse) { void pipeline(live, q); return
+liveResponse; } return await pipeline(null, q);`.
+
+Laws the build adds to the serving doctrine:
+
+1. **THE CHANNEL DECIDES THE LANE.** Inside the pipeline, every lane
+   branch keys off `live` (the channel) — never off `wantsStream` (the
+   request preference). The two are coupled by the hoist/dispatch, but
+   the channel is the authority: a preference-guarded branch is reachable
+   with a null channel (the first probe build 500'd every json ask in
+   exactly that else).
+2. **THE HOIST PRECEDES EVERY STEP.** The SSE opens before the vision
+   step, the understanding, the register bridge — each mark() streams at
+   the moment it runs (the owner's step order), never replayed from a
+   buffer. The agentSteps buffer survives only for the json lane's
+   single response.
+3. **ONE READER, ONE LOOKUP (the photo flow).** The nameplate bridge
+   (vision → extract → certificates.search) is the reader on a cert-photo
+   turn; the agent loop stands down there (`!nameplate?.manufacturer`).
+   The loop's image-bearing probe remains the reader on every OTHER
+   image turn. The user watches: Reading the nameplate photograph →
+   Nameplate read: … → certificates.search — … → the answer.
+4. **THE CFA BUDGET.** A ~1400-line closure drops TypeScript's flow
+   narrowing mid-function (values see `string | null` inside their own
+   guards). The 24 carried sites are guard-backed `!` assertions — the
+   guards are the runtime proof; a reduced repro for the narrowing loss
+   is a follow-up.
+
+Probes (local --remote dev against production bindings): JSON MPE ask
+(7-10 citations, table block), streamed Chomsky refusal (pinned
+sentence, no follow_up chips), streamed knowledge (read → citations →
+tokens → quota → done), text cert question (the loop streams), the
+photo flow in the owner's order.

package/package.json

@@ -27,7 +27,7 @@
     "playwright": "^1.62.1",
     "yaml": "^2.9.1"
   },
-  "version": "0.2.152",
+  "version": "0.2.155",
   "description": "The Konneal engine: the publisher-agnostic build pipeline and API plane for standards intelligence (retrieval, answer contract, verdicts, evaluation).",
   "license": "BSD-3-Clause",
   "type": "module",

package/workers/worker_public/src/admin.ts

@@ -78,7 +78,20 @@ export async function handleEnrich(env: Env, ctx: ExecutionContext, req: Request
           context = typeof raw === "string" ? raw.trim().replace(/^["\']|[\"']$/g, "").slice(0, 400) : "";
           if (!context) {
             console.log("enrich raw keys:", Object.keys(res ?? {}), "sample:", JSON.stringify(res).slice(0, 300));
-            return { id: c.id, ok: false, error: "empty enrichment" };
+            // The deterministic-empty class (observed 2026-10-20 on B 18's
+            // thin terms sections and two R 134-1 clauses — empty under
+            // BOTH the default and the alternate enrichment model): the
+            // chunk's own text is real corpus content, so the production
+            // flow serves it RAW rather than leaving a hole in the index
+            // — embed the original text without the context band, upsert
+            // without the ctx marker; a later forced re-enrich overwrites
+            // the vector in place. mode:"context" and "ab" keep failing:
+            // their builders want the signal, not a side-effecting write.
+            if (contextOnly || abMode) return { id: c.id, ok: false, error: "empty enrichment" };
+            const rawText = typeof c.metadata.chunk_text === "string" && c.metadata.chunk_text ? c.metadata.chunk_text : c.text;
+            const rawVector = await embed(portModelRunner(env), MODELS.embed, rawText.slice(0, 6000));
+            await env.VECTORIZE.upsert([{ id: c.id, values: rawVector, metadata: { ...c.metadata, chunk_text: rawText } }]);
+            return { id: c.id, ok: true, raw: true, cached: false, context: "" };
           }
           if (res?.usage) {
             usage.prompt_tokens += Number(res.usage.prompt_tokens ?? 0);

package/workers/worker_public/src/answerGuards.ts

@@ -0,0 +1,36 @@
+// The answer-contract's text guards, dependency-free so plain node can
+// load them for unit tests (ask.ts imports .md prompts that only the
+// bundler resolves — the guards were module-local there and rode e2e
+// alone). Both lanes share them: the JSON lane's contract retry and the
+// streamed lane's 80-char head ruling.
+
+// The tool-narration leak (2026-10-14, the R 134-1 probe): the answer
+// model sometimes NARRATES the agent loop's call in prose — 'The
+// db.find tool returned, for the query "…": {…json…}' — instead of
+// answering. The TOOL-line scrub cannot catch prose. The JSON lane
+// regenerates through the contract retry; the streamed lane buffers
+// the head and sends the retry sentinel (the blind-answer guard's
+// client contract) before streaming the fresh answer. One bounded
+// restart per lane.
+export function toolNarration(t: string): boolean {
+  return /^(?:the\s+)?[a-z][a-z_.]*\.[a-z_]+ tool returned\b/i.test(t.slice(0, 200)) ||
+    /tool returned,? for the query\b/i.test(t.slice(0, 300));
+}
+export const TOOL_NARRATION_NOTICE =
+  "Correction notice: your draft narrated an internal tool call ('the … tool returned …') instead of answering. Rewrite: answer the question directly from the retrieved passages, cite the clauses, and never mention tools, queries, wire formats, or JSON.";
+
+// The intent preamble (2026-10-19, the ~200-word technical-file
+// question): the draft is a PLAN, not an answer — "I'll look up the R
+// 76-1 MPE clause and classification details in the corpus." — shipped
+// while ten citations rode the same response. Narrow by construction:
+// it must OPEN with a first-person intent verb AND carry no substance —
+// short, no clause citation, no normative numbers (a real answer's
+// opening names values or clauses).
+export function intentPreamble(t: string): boolean {
+  const s = (t ?? "").trim();
+  if (s.length > 240) return false;
+  if (!/^(?:i'll|i will|let me|let's|i'm going to|i am going to)\b/i.test(s)) return false;
+  return !/\[\[u:|\[\^?\d+\]|\b\d+\.\d+\b/.test(s);
+}
+export const INTENT_PREAMBLE_NOTICE =
+  "Correction notice: your draft announced a plan ('I'll look up …') instead of answering. Do not narrate intent — answer the question NOW from the retrieved passages: give the values, clause references and citations the question asks for.";