diff --git a/.archon/workflows/lakehouse-architect-review.yaml b/.archon/workflows/lakehouse-architect-review.yaml new file mode 100644 index 0000000..cc116b3 --- /dev/null +++ b/.archon/workflows/lakehouse-architect-review.yaml @@ -0,0 +1,42 @@ +# Real Archon workflow on the Lakehouse repo, fully via our gateway. +# Three Pi nodes, each fires LLM → /v1/chat/completions → OpenRouter, +# every call lands a Langfuse trace + observer event. +# +# Read-only (allowed_tools: [read]). Don't pass --branch / leave +# --no-worktree at runtime so Archon doesn't try to create a worktree. +name: lakehouse-architect-review +description: 'Pi reviews Lakehouse architecture in 3 turns through our gateway.' +provider: pi +model: openrouter/x-ai/grok-4.1-fast + +nodes: + - id: shape + prompt: | + Read these files and answer in 3 short bullets describing the + architectural shape of Lakehouse: + - /home/profit/lakehouse/Cargo.toml + - /home/profit/lakehouse/lakehouse.toml + - /home/profit/lakehouse/docs/MODE_RUNNER_TUNING_PLAN.md + Be terse. No preamble. + allowed_tools: ["read"] + effort: low + idle_timeout: 90000 + + - id: weakness + prompt: | + Read /home/profit/lakehouse/crates/gateway/src/v1/mod.rs and + identify ONE real weakness or risk. Cite file:line. One paragraph. + allowed_tools: ["read"] + effort: low + idle_timeout: 90000 + depends_on: [shape] + + - id: improvement + prompt: | + Based on the prior weakness ($weakness.output), propose ONE + surgical improvement (≤6 lines of Rust). Show the patch as + `old_string` and `new_string` in markdown code blocks. + allowed_tools: [] + effort: low + idle_timeout: 90000 + depends_on: [weakness] diff --git a/.mcp.json b/.mcp.json index 6c33296..60089ed 100644 --- a/.mcp.json +++ b/.mcp.json @@ -7,6 +7,14 @@ "LAKEHOUSE_URL": "http://localhost:3100", "MCP_TRANSPORT": "stdio" } + }, + "gitea": { + "command": "bunx", + "args": ["gitea-mcp"], + "env": { + "GITEA_HOST": "https://git.agentview.dev", + "GITEA_ACCESS_TOKEN": "SET_ME_FROM_GITEA_UI_USER_SETTINGS_APPLICATIONS" + } } } } diff --git a/Cargo.lock b/Cargo.lock index 18e074a..9baea2b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4086,11 +4086,14 @@ dependencies = [ "shared", "storaged", "tokio", + "toml", "tonic", "tower-http", "tracing", "tracing-opentelemetry", "tracing-subscriber", + "truth", + "validator", "vectord", ] @@ -4679,6 +4682,7 @@ dependencies = [ "chrono", "croner", "csv", + "journald", "lopdf", "mysql_async", "object_store", @@ -6896,6 +6900,7 @@ dependencies = [ "storaged", "tokio", "tracing", + "truth", "url", ] @@ -8727,6 +8732,17 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "truth" +version = "0.1.0" +dependencies = [ + "serde", + "serde_json", + "tokio", + "toml", + "tracing", +] + [[package]] name = "try-lock" version = "0.2.5" @@ -8893,6 +8909,19 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "validator" +version = "0.1.0" +dependencies = [ + "arrow 55.2.0", + "parquet 55.2.0", + "serde", + "serde_json", + "thiserror 2.0.18", + "tokio", + "tracing", +] + [[package]] name = "valuable" version = "0.1.1" diff --git a/Cargo.toml b/Cargo.toml index a0315b7..c4566ed 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,8 @@ members = [ "crates/ui", "crates/lance-bench", "crates/vectord-lance", + "crates/truth", + "crates/validator", ] [workspace.dependencies] diff --git a/auditor/audit.ts b/auditor/audit.ts index 91d23fc..5658b29 100644 --- a/auditor/audit.ts +++ b/auditor/audit.ts @@ -23,6 +23,7 @@ import { runStaticCheck } from "./checks/static.ts"; import { runDynamicCheck } from "./checks/dynamic.ts"; import { runInferenceCheck } from "./checks/inference.ts"; import { runKbCheck } from "./checks/kb_query.ts"; +import { runKimiArchitectCheck } from "./checks/kimi_architect.ts"; const VERDICTS_DIR = "/home/profit/lakehouse/data/_auditor/verdicts"; // Playbook for audit findings — one row per block/warn finding from a @@ -67,6 +68,29 @@ export async function auditPr(pr: PrSnapshot, opts: AuditOptions = {}): Promise< ...kbFindings, ]; + // Kimi-architect second-pass review. Off by default; enabled with + // LH_AUDITOR_KIMI=1. Sequential (not in the parallel block above) + // because it consumes the prior findings as context — Kimi sees what + // deepseek already flagged and is asked "what did everyone miss?" + // Failure-isolated by design: any error returns a single info-level + // skip finding so the existing audit pipeline never blocks on Kimi. + if (process.env.LH_AUDITOR_KIMI === "1") { + try { + const kimiFindings = await runKimiArchitectCheck(diff, allFindings, { + pr_number: pr.number, + head_sha: pr.head_sha, + }); + allFindings.push(...kimiFindings); + } catch (e) { + allFindings.push({ + check: "kimi_architect", + severity: "info", + summary: `kimi_architect outer error — ${(e as Error).message.slice(0, 160)}`, + evidence: [(e as Error).stack?.slice(0, 360) ?? ""], + }); + } + } + const duration_ms = Date.now() - t0; const metrics = { audit_duration_ms: duration_ms, @@ -184,7 +208,7 @@ function formatReviewBody(v: Verdict): string { lines.push(""); // Per-check sections, only if the check produced findings. - const checkOrder = ["static", "dynamic", "inference", "kb_query"] as const; + const checkOrder = ["static", "dynamic", "inference", "kb_query", "kimi_architect"] as const; for (const check of checkOrder) { const fs = byCheck[check] ?? []; if (fs.length === 0) continue; @@ -217,6 +241,6 @@ function formatReviewBody(v: Verdict): string { return lines.join("\n"); } -function stubFinding(check: "dynamic" | "inference", why: string): Finding[] { +function stubFinding(check: "dynamic" | "inference" | "kimi_architect", why: string): Finding[] { return [{ check, severity: "info", summary: `${check} check skipped — ${why}`, evidence: [why] }]; } diff --git a/auditor/checks/inference.ts b/auditor/checks/inference.ts index 4a83745..8103e9d 100644 --- a/auditor/checks/inference.ts +++ b/auditor/checks/inference.ts @@ -18,36 +18,37 @@ import { readFile, mkdir, appendFile } from "node:fs/promises"; import { extractFacts } from "../fact_extractor.ts"; const GATEWAY = process.env.LH_GATEWAY_URL ?? "http://localhost:3100"; -const MODEL = process.env.LH_AUDITOR_REVIEW_MODEL ?? "gpt-oss:120b"; -// Tie-breaker for claims where the N=3 consensus produces a 1-1-1 -// split (genuinely borderline). Different architecture from the -// primary reviewer (gpt-oss) so the tie-break isn't correlated with -// the original disagreement. qwen3-coder:480b is a newer coding -// specialist at 480B params, well-suited to PR-diff claim verification -// and distinct in training lineage from gpt-oss. -const TIEBREAKER_MODEL = process.env.LH_AUDITOR_TIEBREAKER_MODEL ?? "qwen3-coder:480b"; +// Rebuild 2026-04-26: route claim verification through /v1/mode/execute +// (task_class=pr_audit) so we get pathway memory + lakehouse_answers_v1 +// + JSON-shaped framing molded into ONE prompt. The hand-rolled +// systemMsg/userMsg path was reinventing the mode runner badly. +// +// 2026-04-27 update: original default kimi-k2:1t hit a sustained +// upstream outage on Ollama Cloud (consistent 500 ISE across hours of +// retries — verified with trivial 8-token probes). Swapped default to +// deepseek-v3.1:671b which is proven working end-to-end through the +// pr_audit mode runner during Phase 5 distillation acceptance testing. +// kimi-k2:1t can be re-selected via LH_AUDITOR_REVIEW_MODEL env when +// the upstream returns. Tie-breaker stays grok-4.1-fast (different +// vendor lineage so consensus + tie-break won't fail-correlate). +const MODEL = process.env.LH_AUDITOR_REVIEW_MODEL ?? "deepseek-v3.1:671b"; +const TIEBREAKER_MODEL = process.env.LH_AUDITOR_TIEBREAKER_MODEL ?? "x-ai/grok-4.1-fast"; const N_CONSENSUS = Number(process.env.LH_AUDITOR_CONSENSUS_N ?? 3); const AUDIT_DISCREPANCIES_JSONL = "/home/profit/lakehouse/data/_kb/audit_discrepancies.jsonl"; -// 40KB comfortably fits gpt-oss:120b's context. PR #1 (~39KB) was -// previously truncated at 15KB causing the reviewer to miss later -// files (gitea.ts, policy.ts) and flag "no Gitea client present" as a -// block finding when the file was simply outside the truncation window. -// -// Above this threshold we curate via tree-split rather than truncate, -// following the scrum_master pattern: shard the diff, summarize each -// shard against the claim-verification task, merge into a compact -// scratchpad, then ask the cloud to verify claims against the -// scratchpad. This gives the cloud full-PR fidelity without bursting -// its context window (observed failure mode: empty response or -// unparseable output when prompt exceeds model's comfortable range). +// 40KB comfortably fits the consensus models' context windows +// (deepseek-v3.1 64K, gpt-oss-120b 128K). When the raw PR diff +// exceeds this, we truncate and signal it via curationNote — the +// pr_audit mode runner's matrix retrieval (lakehouse_answers_v1 + +// arch + symbols) supplies the cross-PR context that tree-split +// used to synthesize from scratch. Tree-split itself was retired +// 2026-04-27 (see commit deleting treeSplitDiff/callCloud/SHARD_*). const MAX_DIFF_CHARS = 40000; -// Tree-split kicks in above this. 30KB is below MAX_DIFF_CHARS so we -// curate BEFORE truncation would happen — never lose signal to a hard -// cut. Shard size is chosen so ~10 shards cover PR #8-size diffs in a -// reasonable round-trip budget. -const CURATION_THRESHOLD = 30000; -const DIFF_SHARD_SIZE = 4500; const CALL_TIMEOUT_MS = 120_000; +// Mode runner can take longer than a raw /v1/chat call because it does +// pathway-fingerprint lookup + matrix retrieval + relevance filter +// before the LLM call. Budget extra time so we don't trip on a slow +// answers-corpus search. +const MODE_RUNNER_TIMEOUT_MS = 240_000; const REPO_ROOT = "/home/profit/lakehouse"; export interface InferenceContext { @@ -86,26 +87,23 @@ export async function runInferenceCheck( }]; } - // Diff source for the cloud prompt — either the raw diff (small - // enough to fit), or a tree-split scratchpad (curation layer). We - // prefer curation to truncation: truncation silently drops files - // past the window; curation summarizes them so the cloud still sees - // what changed, just densified. - let diffForPrompt: string; - let curationNote = ""; - if (diff.length > CURATION_THRESHOLD) { - const ts = await treeSplitDiff(diff, verifiable); - diffForPrompt = ts.scratchpad; - curationNote = ` (curated: ${diff.length} chars → ${ts.shards} shards → scratchpad ${ts.scratchpad.length} chars)`; - } else { - diffForPrompt = diff; - } - // Belt-and-suspenders truncation — even a tree-split scratchpad - // shouldn't exceed MAX_DIFF_CHARS in practice, but guard anyway so - // pathological inputs can't burst the prompt. - const truncated = diffForPrompt.length > MAX_DIFF_CHARS - ? diffForPrompt.slice(0, MAX_DIFF_CHARS) + `\n...[${diffForPrompt.length - MAX_DIFF_CHARS} more chars truncated]` - : diffForPrompt; + // 2026-04-27 architecture simplification: dropped the tree-split + // scratchpad layer. Rationale: the mode runner's pr_audit pipeline + // pulls from lakehouse_answers_v1 (gold-standard prior audits) + + // lakehouse_arch_v1 + lakehouse_symbols_v1 via matrix retrieval. That + // corpus IS the cross-PR context the tree-split was synthesizing + // from scratch on every audit run. With the distillation substrate + // shipped (commits 27b1d27..1b433a9), per-shard fact extraction is + // redundant — and gpt-oss:120b at 168 calls/audit was the dominant + // cost. Now: truncate diff to MAX_DIFF_CHARS, hand straight to the + // mode runner, let retrieval supply context. ONE strong-model call + // per consensus rep × N=3 reps = 3 calls total per audit. + const truncated = diff.length > MAX_DIFF_CHARS + ? diff.slice(0, MAX_DIFF_CHARS) + `\n...[${diff.length - MAX_DIFF_CHARS} more chars truncated — the pr_audit mode runner has matrix retrieval against lakehouse_answers_v1 + arch + symbols for cross-PR context]` + : diff; + const curationNote = diff.length > MAX_DIFF_CHARS + ? ` (truncated ${diff.length}→${MAX_DIFF_CHARS} chars; matrix retrieval supplies cross-PR context)` + : ""; // Build the reviewer prompt in the same shape as run_codereview's // review stage (llm_team_ui.py:10950), adapted for claim verification: @@ -114,79 +112,20 @@ export async function runInferenceCheck( // "Review: bugs/security/perf/style/edge. Provide corrected code." // We add: claim list upfront + ask for structured JSON verdict. // - // When the diff was curated (tree-split scratchpad), we add an - // explicit anti-false-positive instruction: the scratchpad is a - // distillation, not the full source, so absence-from-scratchpad is - // NOT evidence of absence-from-diff. Mirrors the fix we made in - // scrum_master's review prompt for the same class of error. + // Curation flag is now just a truncation flag — when the diff was + // cut, tell the reviewer it didn't see the full picture so it doesn't + // confidently mark a claim NOT BACKED based on absence in the + // (potentially incomplete) input. const isCurated = curationNote.length > 0; - const curationGuard = isCurated - ? [ - "", - "CRITICAL: the 'Diff' below is a curated multi-shard scratchpad,", - "NOT the full raw diff. The scratchpad distills each shard down", - "to facts useful for claim verification and drops the rest.", - "DO NOT flag a function/field/feature as 'missing' or 'not", - "implemented' based solely on its absence from the scratchpad —", - "absence in a distillation is NOT evidence of absence in the", - "actual diff. Only judge a claim NOT BACKED when the scratchpad", - "DIRECTLY contradicts it (e.g. scratchpad shows the function was", - "added empty, or shows the claimed code path is a stub).", - "Skip the unflagged_gaps section entirely when operating on a", - "curated scratchpad — you can't reliably detect gaps from a", - "distillation, and false positives there are worse than misses.", - ].join("\n") - : ""; - const systemMsg = [ - "You review pull-request diffs against the author's own ship-claims.", - "For each claim, decide: is it backed by actual code in the diff, or is", - "it placeholder / aspirational / unwired?", - "", - "A claim is BACKED when the diff contains a real code path that delivers", - "the claimed behavior. A claim is NOT BACKED when:", - " - the claim asserts functionality but the diff only adds types/fields", - " with no consumer", - " - the claim mentions tests but no test function was added", - " - the claim claims integration but the integration point is a stub", - " - the diff contains unimplemented!() / todo!() / TODO comments", - " - the claim says 'works end-to-end' but the diff has no end-to-end test", - curationGuard, - "", - "Respond with strict JSON only. No prose before or after. Shape:", - "{", - ' "claim_verdicts": [', - ' {"claim_idx": 0, "backed": false, "evidence": "short reason"}', - " ],", - ' "unflagged_gaps": [', - ' {"location": "file:line", "summary": "short description"}', - " ]", - "}", - ].join("\n"); + const prNumber = ctx?.pr_number ?? 0; - const userMsg = [ - `Ship-claims the author made (numbered 0..N-1):`, - verifiable.map((c, i) => ` ${i}. [${c.strength}] "${c.text}" at ${c.location}`).join("\n"), - "", - `Diff:`, - "```", - truncated, - "```", - "", - `For each numbered claim above, emit a claim_verdicts entry. For gaps the`, - `author DIDN'T claim but that look like placeholder code, emit unflagged_gaps.`, - `Strict JSON only, matching the shape described. No prose outside JSON.`, - ].join("\n"); - - // N=3 consensus — run the primary reviewer in parallel, collect - // all three parsed responses, majority-vote per claim. Parallel - // (Promise.all) because each call is ~20-30s and they're independent; - // wall-clock stays ~same as single call, cost 3x tokens. Empirical - // justification: in 3-run determinism tests, 7/8 findings were - // stable but 1 flipped across runs — majority vote stabilizes the - // flipping class without losing the stable signal. + // N=3 consensus — fire the mode runner three times in parallel. + // Each /v1/mode/execute call composes pathway memory + answers corpus + // + JSON-shaped pr_audit framing internally, so the auditor's only + // job here is to vote-aggregate. Wall-clock ~= single call. const primaryRuns = await Promise.all( Array.from({ length: N_CONSENSUS }, () => - runCloudInference(systemMsg, userMsg, MODEL)), + runModeRunnerInference(truncated, verifiable, prNumber, isCurated, MODEL)), ); const parsedRuns = primaryRuns.filter(r => r.parsed !== null); @@ -209,9 +148,19 @@ export async function runInferenceCheck( interface Votes { trues: number; falses: number; evidences: string[] } const votesByClaim = new Map(); const unflaggedByRun: any[][] = []; - let totalTokens = 0; + // The N=3 consensus calls run via Promise.all — wall-clock is + // bounded by the SLOWEST call, not the sum. Pre-2026-04-27 we + // summed and reported "Xms total" which double/triple-counted + // (Opus self-audit caught it). Use max for accurate wall-clock. + let maxLatencyMs = 0; + let totalEnrichedChars = 0; + let bugFingerprintsSeen = 0; + let matrixKeptSeen = 0; for (const run of parsedRuns) { - totalTokens += run.tokens; + maxLatencyMs = Math.max(maxLatencyMs, run.latency_ms ?? 0); + totalEnrichedChars += run.enriched_chars ?? 0; + bugFingerprintsSeen = Math.max(bugFingerprintsSeen, run.bug_fingerprints ?? 0); + matrixKeptSeen = Math.max(matrixKeptSeen, run.matrix_kept ?? 0); unflaggedByRun.push(Array.isArray(run.parsed?.unflagged_gaps) ? run.parsed.unflagged_gaps : []); for (const v of run.parsed?.claim_verdicts ?? []) { const idx = Number(v?.claim_idx); @@ -233,10 +182,11 @@ export async function runInferenceCheck( findings.push({ check: "inference", severity: "info", - summary: `cloud review completed (model=${MODEL}, consensus=${parsedRuns.length}/${N_CONSENSUS}, tokens=${totalTokens})${curationNote}`, + summary: `pr_audit mode runner completed (model=${MODEL}, consensus=${parsedRuns.length}/${N_CONSENSUS}, ${maxLatencyMs}ms wall-clock)${curationNote}`, evidence: [ `claims voted: ${votesByClaim.size}`, `parsed runs: ${parsedRuns.length} / ${N_CONSENSUS}`, + `enrichment: ${bugFingerprintsSeen} bug fingerprints, ${matrixKeptSeen} answers-corpus chunks, prompt avg ${Math.round(totalEnrichedChars / Math.max(parsedRuns.length, 1))} chars`, ], }); @@ -266,8 +216,9 @@ export async function runInferenceCheck( notBacked = false; resolution = "majority_backed"; } else { - // Tie. Run tie-breaker with a different-architecture model. - const tb = await runCloudInference(systemMsg, userMsg, TIEBREAKER_MODEL); + // Tie. Run tie-breaker with a different-architecture model + // through the same mode runner so framing/enrichment match. + const tb = await runModeRunnerInference(truncated, verifiable, prNumber, isCurated, TIEBREAKER_MODEL); if (tb.parsed) { const tv = (tb.parsed.claim_verdicts ?? []).find((v: any) => Number(v?.claim_idx) === idx); if (tv?.backed === false) { @@ -335,9 +286,13 @@ export async function runInferenceCheck( // don't exit before extraction lands; the systemd poller has plenty // of headroom (90s cycle vs ~15s extraction). A failure inside // extractAndPersistFacts is caught + logged but never throws. + // Post-2026-04-27: extraction now runs against the truncated diff + // (no scratchpad to extract from since tree-split was retired). + // Fact extraction is still useful for surfacing entities/symbols + // into audit_facts.jsonl even from truncated input. if (isCurated && ctx && process.env.LH_AUDITOR_SKIP_EXTRACT !== "1") { try { - await extractAndPersistFacts(diffForPrompt, ctx); + await extractAndPersistFacts(truncated, ctx); } catch (e) { console.error(`[inference] fact extraction failed: ${(e as Error).message}`); } @@ -394,60 +349,106 @@ export async function runInferenceCheck( return findings; } -// Single cloud call — the consensus loop calls this N times in -// parallel. Returns the parsed JSON shape + token usage + any error -// diagnostic. NEVER throws; the consensus aggregator handles partial -// failures by dropping non-parsed runs from the vote. +// Single mode-runner call — consensus + tie-breaker dispatch through +// here. Returns parsed JSON shape + telemetry from /v1/mode/execute +// (latency, enrichment metrics) + any error diagnostic. NEVER throws. +// The consensus aggregator handles partial failures by dropping +// non-parsed runs from the vote. interface CloudRunResult { parsed: any | null; - tokens: number; + latency_ms: number; + enriched_chars: number; + bug_fingerprints: number; + matrix_kept: number; error?: string; // "unreachable" | "non_200" | "unparseable" diagnostic?: string; // first 200 chars for debugging model: string; } -async function runCloudInference(systemMsg: string, userMsg: string, model: string): Promise { +async function runModeRunnerInference( + diffOrScratchpad: string, + claims: Claim[], + prNumber: number, + isCurated: boolean, + model: string, +): Promise { + // user_question carries the claim list + the curation note (if any). + // pr_audit's framing (mode.rs FRAMING_PR_AUDIT) holds the JSON shape + + // strict-output rules so we don't repeat them here. + const claimDigest = claims + .map((c, i) => ` ${i}. [${c.strength}] "${c.text}" at ${c.location}`) + .join("\n"); + const curationNote = isCurated + ? "\n\nNOTE: the FILE below is a curated multi-shard scratchpad of the diff, not the raw diff itself. Absence in the scratchpad is NOT evidence of absence in the actual diff. Only mark backed=false on direct contradiction (e.g. scratchpad shows the function is empty / a stub). Skip unflagged_gaps entirely when scratchpad is curated." + : ""; + const userQuestion = [ + "Verify each ship-claim against the diff (or scratchpad).", + "", + "Ship-claims (numbered 0..N-1):", + claimDigest, + curationNote, + "", + "Every claim above must produce exactly one claim_verdicts entry. Output strict JSON only — no prose outside the JSON object.", + ].join("\n"); + let resp: Response; try { - resp = await fetch(`${GATEWAY}/v1/chat`, { + resp = await fetch(`${GATEWAY}/v1/mode/execute`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ - provider: "ollama_cloud", - model, - messages: [ - { role: "system", content: systemMsg }, - { role: "user", content: userMsg }, - ], - // temp=0 (greedy) + think=true. think=true is required for - // gpt-oss:120b — without it the model returns empty content - // on large prompts. Variance from the think trace is observed - // in practice, which is why we use N=3 consensus, not single- - // call determinism. - max_tokens: 3000, - temperature: 0, - think: true, + task_class: "pr_audit", + file_path: `pr-${prNumber}.diff`, + file_content: diffOrScratchpad, + user_question: userQuestion, + force_model: model, + force_temperature: 0, }), - signal: AbortSignal.timeout(CALL_TIMEOUT_MS), + signal: AbortSignal.timeout(MODE_RUNNER_TIMEOUT_MS), }); } catch (e) { - return { parsed: null, tokens: 0, error: "unreachable", diagnostic: (e as Error).message.slice(0, 200), model }; + return { + parsed: null, latency_ms: 0, enriched_chars: 0, bug_fingerprints: 0, matrix_kept: 0, + error: "unreachable", diagnostic: (e as Error).message.slice(0, 200), model, + }; } if (!resp.ok) { - return { parsed: null, tokens: 0, error: "non_200", diagnostic: `${resp.status}: ${(await resp.text()).slice(0, 160)}`, model }; + return { + parsed: null, latency_ms: 0, enriched_chars: 0, bug_fingerprints: 0, matrix_kept: 0, + error: "non_200", diagnostic: `${resp.status}: ${(await resp.text()).slice(0, 160)}`, model, + }; } let body: any; try { body = await resp.json(); } - catch (e) { return { parsed: null, tokens: 0, error: "unparseable", diagnostic: (e as Error).message, model }; } - const content: string = body?.choices?.[0]?.message?.content ?? ""; - const tokens: number = body?.usage?.total_tokens ?? 0; - const parsed = extractJson(content); - if (!parsed) { - return { parsed: null, tokens, error: "unparseable", diagnostic: content.slice(0, 200), model }; + catch (e) { + return { + parsed: null, latency_ms: 0, enriched_chars: 0, bug_fingerprints: 0, matrix_kept: 0, + error: "unparseable", diagnostic: (e as Error).message, model, + }; } - return { parsed, tokens, model }; + const content: string = typeof body?.response === "string" ? body.response : ""; + const parsed = extractJson(content); + // Number-coerced extractors so a non-numeric upstream value (string, + // null, NaN) collapses to 0 instead of poisoning downstream + // arithmetic. Caught 2026-04-27 by kimi_architect self-audit — + // optional-chaining + ?? only catches null/undefined, not type drift. + const num = (v: unknown): number => { + const n = typeof v === "number" ? v : Number(v); + return Number.isFinite(n) ? n : 0; + }; + return { + parsed, + latency_ms: num(body?.latency_ms), + enriched_chars: num(body?.enriched_prompt_chars), + bug_fingerprints: num(body?.sources?.bug_fingerprints_count), + matrix_kept: num(body?.sources?.matrix_chunks_kept), + error: parsed ? undefined : "unparseable", + diagnostic: parsed ? undefined : content.slice(0, 200), + model, + }; } + async function persistDiscrepancies(ctx: InferenceContext, discrepancies: any[]): Promise { await mkdir("/home/profit/lakehouse/data/_kb", { recursive: true }); const rows = discrepancies.map(d => JSON.stringify({ @@ -490,94 +491,7 @@ async function extractAndPersistFacts(scratchpad: string, ctx: InferenceContext) await appendFile(AUDIT_FACTS_JSONL, JSON.stringify(row) + "\n"); } -// Curation via tree-split — ports the scrum_master pattern into the -// inference check. Shards the raw diff into DIFF_SHARD_SIZE chunks, -// summarizes each shard *against the claim-verification task* so the -// summary preserves exactly what the cloud needs to judge claims -// (function signatures, struct fields, deletions, new files), drops -// everything else. Merges into a compact scratchpad. -// -// Cost: N cloud calls for the shard summaries + 1 cloud call for the -// final verification = N+1 calls instead of 1. Mitigation: shards run -// serially (not parallel) to keep gateway load bounded; summary calls -// use max_tokens=400 so they're fast (~2s each on gpt-oss:120b). -// -// Determinism: each shard summary call uses temp=0 + think=true (same -// as the top-level inference call), so identical input yields -// identical scratchpad. The final verification call then sees a -// stable scratchpad, giving stable verdicts. -async function treeSplitDiff( - fullDiff: string, - claims: Claim[], -): Promise<{ scratchpad: string; shards: number }> { - const shards: Array<{ from: number; to: number; text: string }> = []; - for (let i = 0; i < fullDiff.length; i += DIFF_SHARD_SIZE) { - const end = Math.min(i + DIFF_SHARD_SIZE, fullDiff.length); - shards.push({ from: i, to: end, text: fullDiff.slice(i, end) }); - } - // Curate the claim list into a short form the summary prompt can - // use to bias extraction toward relevant facts. - const claimDigest = claims.map((c, i) => - `${i}. [${c.strength}] "${c.text.slice(0, 100)}"` - ).join("\n"); - let scratchpad = ""; - for (const [si, shard] of shards.entries()) { - const prompt = [ - `You are summarizing shard ${si + 1}/${shards.length} (chars ${shard.from}..${shard.to}) of a PR diff.`, - `The downstream task will verify these ship-claims against the full-PR summary. Extract ONLY facts that could confirm or refute these claims:`, - "", - claimDigest, - "", - "Extract: new function/method signatures, struct fields, deletions, new files, wiring (function X calls Y), absence-of-implementation markers, TODO comments on added lines.", - "Skip: comment-only edits, whitespace, import reordering, unrelated cosmetic changes.", - "", - "─────── shard diff ───────", - shard.text, - "─────── end shard ───────", - "", - "Output: up to 180 words of facts in bullet form. No prose preamble, no claim verdicts (that's for the downstream step).", - ].join("\n"); - - const r = await callCloud(prompt, 400); - if (r.content) { - scratchpad += `\n--- shard ${si + 1} (chars ${shard.from}..${shard.to}) ---\n${r.content.trim()}\n`; - } - } - return { scratchpad: scratchpad.trim(), shards: shards.length }; -} - -// Minimal cloud caller used only by treeSplitDiff — same gateway + -// model as the top-level call, but think=false. Shards are small -// (≤DIFF_SHARD_SIZE ~4500 chars) and the task is pure fact -// extraction, not reasoning. think=true on the shards introduced -// variance in reasoning traces that compounded across 23 calls into -// a non-deterministic scratchpad (observed during curation -// validation: same-SHA runs produced 5/7/8 final findings). -// think=false on small prompts is stable — only breaks at the main -// call's 10K+ prompt size, which keeps think=true. -async function callCloud(prompt: string, maxTokens: number): Promise<{ content: string }> { - try { - const r = await fetch(`${GATEWAY}/v1/chat`, { - method: "POST", - headers: { "content-type": "application/json" }, - body: JSON.stringify({ - provider: "ollama_cloud", - model: MODEL, - messages: [{ role: "user", content: prompt }], - max_tokens: maxTokens, - temperature: 0, - think: false, - }), - signal: AbortSignal.timeout(CALL_TIMEOUT_MS), - }); - if (!r.ok) return { content: "" }; - const j: any = await r.json(); - return { content: j?.choices?.[0]?.message?.content ?? "" }; - } catch { - return { content: "" }; - } -} // Pull out plausible code-symbol names from a summary string. // Matches: diff --git a/auditor/checks/kimi_architect.ts b/auditor/checks/kimi_architect.ts new file mode 100644 index 0000000..7905066 --- /dev/null +++ b/auditor/checks/kimi_architect.ts @@ -0,0 +1,461 @@ +// Kimi-architect check — second-pass senior architectural review using +// kimi-for-coding (Kimi K2.6) via /v1/chat provider=kimi. +// +// Runs AFTER the deepseek inference check (N=3 consensus) and the +// static/kb_query checks. Reads their findings as context and asks Kimi +// "what did everyone else miss?" — complementing the cheap-consensus +// voting with a sparse senior pass that catches load-bearing issues +// (compile errors, false telemetry, schema bypasses, etc.) which the +// voting structure can't see. +// +// Why Kimi here and not in the inner inference loop: +// - Cost: ~3min wall-clock per call vs ~30s for deepseek consensus. +// - TOS: api.kimi.com is User-Agent-gated (see crates/gateway/src/v1/ +// kimi.rs); cost-bounded calls only. +// - Value: experiment 2026-04-27 showed 7/7 grounding rate with full +// files vs ~50% on truncated input. Best as a sparse complement, not +// a replacement. +// +// Failure-isolated: any Kimi error returns a single info-level Finding +// "kimi_architect skipped — " so the existing audit pipeline +// is never blocked by a Kimi outage / TOS revocation / 429. +// +// Cost cap: if a kimi_verdicts/-.json file exists less than 24h +// old, return cached findings without calling upstream. New commits +// produce new SHAs so this is per-head, not per-day. +// +// Off by default: caller checks LH_AUDITOR_KIMI=1 before invoking. + +import { readFile, writeFile, mkdir, appendFile, stat, realpath } from "node:fs/promises"; +import { existsSync, realpathSync } from "node:fs"; +import { dirname, join, resolve } from "node:path"; +import type { Finding, CheckKind } from "../types.ts"; + +const GATEWAY = process.env.LH_GATEWAY_URL ?? "http://localhost:3100"; +const KIMI_VERDICTS_DIR = "/home/profit/lakehouse/data/_auditor/kimi_verdicts"; +const KIMI_AUDITS_JSONL = "/home/profit/lakehouse/data/_kb/kimi_audits.jsonl"; +const REPO_ROOT = "/home/profit/lakehouse"; +// Canonicalize at module load — REPO_ROOT itself may be a symlink in +// some environments (e.g. /home/profit is a bind-mount). Computing +// once at startup means the per-finding grounding loop can compare +// realpath(target) against this stable anchor. +const REPO_ROOT_REAL = (() => { + try { return realpathSync(REPO_ROOT); } + catch { return REPO_ROOT; } +})(); +// 15 min budget. Bun's fetch has an intrinsic ~300s limit that our +// AbortController + setTimeout combo could not override; we use curl +// via Bun.spawn instead (callKimi below). Curl honors -m for max +// transfer time without a hard intrinsic ceiling. +const CALL_TIMEOUT_MS = 900_000; +const CACHE_TTL_MS = 24 * 60 * 60 * 1000; +const MAX_DIFF_CHARS = 180_000; +const MAX_PRIOR_FINDINGS = 50; +// Default provider/model = ollama_cloud/kimi-k2.6. Pre-2026-04-27 we +// went direct to api.kimi.com, but Ollama Cloud Pro now exposes the +// same model legitimately, so we route there to avoid User-Agent +// gating. The api.kimi.com path (provider=kimi) remains wired in the +// gateway as a fallback for when Ollama Cloud is upstream-broken. +const KIMI_PROVIDER = process.env.LH_AUDITOR_KIMI_PROVIDER ?? "ollama_cloud"; +const KIMI_MODEL = process.env.LH_AUDITOR_KIMI_MODEL ?? "kimi-k2.6"; +// Cross-lineage alternation. 2026-04-27 J's call: Opus is too +// expensive to auto-fire (~$0.30/audit). Kimi K2.6 via Go-sub is +// effectively free; Haiku 4.5 via Zen is ~$0.04. Alternate between +// them so we get cross-lineage signal (Moonshot vs Anthropic) on +// every PR's audit history without burning the budget. +// +// Default: Kimi K2.6 on even audits, Haiku 4.5 on odd. Each PR's +// audits flip between vendors as new SHAs come in. +// +// Frontier models (Opus 4.7, GPT-5.5, Gemini 3.1) are NOT in the +// auto path. Operator hands distilled findings to a frontier model +// manually when high-leverage decisions need it. Removing Opus from +// auto-promotion saves ~$1-3/day on the daemon at our cadence. +// +// Override the alternation entirely with LH_AUDITOR_KIMI_MODEL +// (forces one model regardless of audit count); set +// LH_AUDITOR_KIMI_ALT_MODEL to the alternate. +const ALT_MODEL = process.env.LH_AUDITOR_KIMI_ALT_MODEL ?? "claude-haiku-4-5"; +const ALT_PROVIDER = process.env.LH_AUDITOR_KIMI_ALT_PROVIDER ?? "opencode"; +const FORCE_DEFAULT = process.env.LH_AUDITOR_KIMI_MODEL !== undefined && process.env.LH_AUDITOR_KIMI_MODEL !== ""; + +function selectModel(diffLen: number, auditIndex: number = 0): { provider: string; model: string; promoted: boolean } { + // Operator override — env-pinned model wins. + if (FORCE_DEFAULT) { + return { provider: KIMI_PROVIDER, model: KIMI_MODEL, promoted: false }; + } + // Alternate Kimi (default, even index) ↔ Haiku (alt, odd index). + // diffLen kept in the signature for future "big diff → Haiku + // anyway" logic; not used yet so we don't auto-burn on big PRs. + void diffLen; + if (auditIndex % 2 === 1) { + return { provider: ALT_PROVIDER, model: ALT_MODEL, promoted: true }; + } + return { provider: KIMI_PROVIDER, model: KIMI_MODEL, promoted: false }; +} +// Model-aware max_tokens. Different upstream APIs cap at different +// limits and reject requests that exceed them: +// - Anthropic Opus 4.x: 32K output (with extended-output header) +// - Anthropic Haiku 4.5: 8K output +// - Kimi K2.6 (reasoning): 128K — needs headroom because +// reasoning_content counts against the budget +// - Default: 16K, conservative middle ground +// +// 2026-04-27 BLOCK from Opus self-audit: the prior single-default of +// 128K worked silently (Anthropic clamps server-side) but was +// technically invalid. Per-model caps make it explicit. Override via +// LH_AUDITOR_KIMI_MAX_TOKENS to force a value (also fixes the empty- +// env Number("") -> 0 trap by using `||` not `??`). +const MAX_TOKENS_OVERRIDE = Number(process.env.LH_AUDITOR_KIMI_MAX_TOKENS) || 0; +function maxTokensFor(model: string): number { + if (MAX_TOKENS_OVERRIDE > 0) return MAX_TOKENS_OVERRIDE; + if (model.startsWith("claude-opus")) return 32_000; + if (model.startsWith("claude-haiku") || model.startsWith("claude-sonnet")) return 8_192; + if (model.startsWith("kimi-")) return 128_000; + if (model.startsWith("gpt-5") || model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4")) return 32_000; + return 16_000; +} + +export interface KimiArchitectContext { + pr_number: number; + head_sha: string; +} + +interface KimiVerdictFile { + pr_number: number; + head_sha: string; + cached_at: string; + model: string; + latency_ms: number; + finish_reason: string; + usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number }; + raw_content: string; + findings: Finding[]; + grounding: { total: number; verified: number; rate: number }; +} + +export async function runKimiArchitectCheck( + diff: string, + priorFindings: Finding[], + ctx: KimiArchitectContext, +): Promise { + const cachePath = join(KIMI_VERDICTS_DIR, `${ctx.pr_number}-${ctx.head_sha.slice(0, 12)}.json`); + const outageSentinel = `${cachePath}.outage`; + const OUTAGE_TTL_MS = 10 * 60 * 1000; + + // Outage negative-cache — if upstream failed within OUTAGE_TTL_MS, + // skip this audit and return immediately. Prevents the daemon from + // hammering a downed Kimi/Anthropic upstream every 90s. + if (existsSync(outageSentinel)) { + try { + const s = await stat(outageSentinel); + if (Date.now() - s.mtimeMs < OUTAGE_TTL_MS) { + const note = JSON.parse(await readFile(outageSentinel, "utf8")); + return [skipFinding(`upstream still down (cached ${Math.round((Date.now() - s.mtimeMs) / 1000)}s ago): ${String(note.reason).slice(0, 160)}`)]; + } + } catch { /* malformed sentinel — fall through to fresh call */ } + } + + // Cost cap — return cached findings if a verdict for this exact head + // SHA was generated within the TTL. + const cached = await loadCachedVerdict(cachePath); + if (cached) { + return cached.findings.length > 0 + ? cached.findings + : [{ check: "kimi_architect" as CheckKind, severity: "info", summary: "kimi_architect cached — 0 findings", evidence: [`cache: ${cachePath}`] }]; + } + + // Alternate model based on how many audits this PR has had — gives + // cross-lineage signal (Kimi/Moonshot ↔ Haiku/Anthropic) on every + // PR's audit history. Count is derived from existing kimi_verdicts + // files for this PR; cheap O(N_PRs) directory read. + let auditIndex = 0; + try { + const dir = "/home/profit/lakehouse/data/_auditor/kimi_verdicts"; + if (existsSync(dir)) { + const all = require("node:fs").readdirSync(dir) as string[]; + auditIndex = all.filter((f) => f.startsWith(`${ctx.pr_number}-`)).length; + } + } catch { /* default 0 — Kimi */ } + + const selected = selectModel(diff.length, auditIndex); + let response: { content: string; usage: any; finish_reason: string; latency_ms: number }; + try { + response = await callKimi(buildPrompt(diff, priorFindings, ctx), selected.provider, selected.model); + } catch (e) { + // Negative-cache for 10 min on outage (caught 2026-04-27 by Opus + // self-audit): without this, every audit cycle within the 24h + // TTL re-calls upstream while it's still down. Use a sentinel + // file with mtime check rather than persisting a verdict so the + // happy-path cache reader doesn't have to special-case it. + const sentinel = `${cachePath}.outage`; + try { await writeFile(sentinel, JSON.stringify({ at: new Date().toISOString(), reason: (e as Error).message.slice(0, 200) })); } catch {} + return [skipFinding(`kimi call failed (${selected.model}): ${(e as Error).message.slice(0, 200)}`)]; + } + + const findings = parseFindings(response.content); + const grounding = await computeGrounding(findings); + + const verdict: KimiVerdictFile = { + pr_number: ctx.pr_number, + head_sha: ctx.head_sha, + cached_at: new Date().toISOString(), + model: selected.model, + latency_ms: response.latency_ms, + finish_reason: response.finish_reason, + usage: { + prompt_tokens: response.usage?.prompt_tokens ?? 0, + completion_tokens: response.usage?.completion_tokens ?? 0, + total_tokens: response.usage?.total_tokens ?? 0, + }, + raw_content: response.content, + findings, + grounding, + }; + + // Cache-poisoning guard (caught 2026-04-27 by Opus self-audit): + // when parseFindings returns 0 findings (Kimi rambled, prompt too + // big, or the markdown shape changed and our regex missed every + // block), persisting the empty verdict short-circuits all future + // audits in the 24h TTL window with a useless cached "0 findings" + // result. Better to leave no cache and re-call upstream next time. + // Always append metrics — observability shouldn't depend on whether + // findings parsed. + await appendMetrics(verdict); + if (findings.length > 0) { + await persistVerdict(cachePath, verdict); + return findings; + } + return [{ + check: "kimi_architect" as CheckKind, + severity: "info", + summary: `kimi_architect produced 0 ranked findings (${response.finish_reason}, ${verdict.usage.completion_tokens} tokens) — not cached`, + evidence: [`raw saved (no cache): see kimi_audits.jsonl ${verdict.cached_at}`], + }]; +} + +async function loadCachedVerdict(path: string): Promise { + if (!existsSync(path)) return null; + try { + const s = await stat(path); + if (Date.now() - s.mtimeMs > CACHE_TTL_MS) return null; + return JSON.parse(await readFile(path, "utf8")) as KimiVerdictFile; + } catch { return null; } +} + +function buildPrompt(diff: string, priorFindings: Finding[], ctx: KimiArchitectContext): string { + const truncatedDiff = diff.length > MAX_DIFF_CHARS + ? diff.slice(0, MAX_DIFF_CHARS) + `\n\n... [truncated; original diff was ${diff.length} chars]` + : diff; + + const priorBlock = priorFindings + .filter(f => f.severity !== "info") + .slice(0, MAX_PRIOR_FINDINGS) + .map(f => `- [${f.check}/${f.severity}] ${f.summary}${f.evidence?.[0] ? ` — ${f.evidence[0].slice(0, 160)}` : ""}`) + .join("\n"); + + return `You are a senior software architect doing a second-pass review on PR #${ctx.pr_number} (head ${ctx.head_sha.slice(0, 12)}). The team's automated auditor (deepseek-v3.1:671b, N=3 consensus) already produced findings. Your job is NOT to repeat what they found — your job is to catch what their voting structure CAN'T see: compile errors, type-system bypasses, false telemetry, silent determinism leaks, schema-bypass anti-patterns, load-bearing assumptions that look fine line-by-line. + +GROUNDING RULES (non-negotiable): +- Cite file:line for EVERY finding. Lines you cite must actually contain what you claim. Confabulating a finding wastes more time than missing one. +- If the diff is truncated and you can't verify a claim, say "diff-truncated, can't verify" — DO NOT guess. +- Distinguish architectural concerns (no specific line) from concrete bugs (specific line). Don't dress one as the other. + +PRIOR FINDINGS FROM DEEPSEEK CONSENSUS (do not repeat these): +${priorBlock || "(none)"} + +OUTPUT FORMAT (markdown): +- ## Verdict (one sentence) +- ## Findings (5-10 items, each formatted EXACTLY as below) + +For each finding use this exact shape so a parser can lift them: + +### F1: +- **Severity:** block | warn | info +- **File:** path/to/file.ext:LINE +- **Rationale:** one or two sentences + +THE DIFF: + +${truncatedDiff} +`; +} + +async function callKimi(prompt: string, provider: string, model: string): Promise<{ content: string; usage: any; finish_reason: string; latency_ms: number }> { + const t0 = Date.now(); + const body = JSON.stringify({ + provider, + model, + messages: [{ role: "user", content: prompt }], + max_tokens: maxTokensFor(model), + temperature: 0.2, + }); + // curl via Bun.spawn — bypasses Bun fetch's ~300s intrinsic ceiling. + // -m sets the max transfer time honored end-to-end. Body is piped via + // stdin to avoid argv length limits on big audit prompts (~50K+ tokens). + const proc = Bun.spawn({ + cmd: [ + "curl", "-sS", "-X", "POST", + "-m", String(Math.ceil(CALL_TIMEOUT_MS / 1000)), + "-H", "content-type: application/json", + "--data-binary", "@-", + `${GATEWAY}/v1/chat`, + ], + stdin: "pipe", + stdout: "pipe", + stderr: "pipe", + }); + proc.stdin.write(body); + await proc.stdin.end(); + const [stdout, stderr, exitCode] = await Promise.all([ + new Response(proc.stdout).text(), + new Response(proc.stderr).text(), + proc.exited, + ]); + if (exitCode !== 0) { + throw new Error(`curl exit ${exitCode}: ${stderr.slice(0, 300)}`); + } + let j: any; + try { j = JSON.parse(stdout); } + catch (e) { + throw new Error(`bad response (${stdout.length} bytes): ${stdout.slice(0, 300)}`); + } + if (j.error || !j.choices) { + throw new Error(`gateway error: ${JSON.stringify(j).slice(0, 300)}`); + } + return { + content: j.choices?.[0]?.message?.content ?? "", + usage: j.usage ?? {}, + finish_reason: j.choices?.[0]?.finish_reason ?? "unknown", + latency_ms: Date.now() - t0, + }; +} + +// Parse Kimi's markdown into Finding[]. Format expected (per buildPrompt): +// ### F: +// - **Severity:** block | warn | info +// - **File:** path:line +// - **Rationale:** ... +function parseFindings(content: string): Finding[] { + const findings: Finding[] = []; + const blocks = content.split(/^###\s+F\d+:\s*/m).slice(1); + for (const block of blocks) { + const summary = (block.split("\n")[0] ?? "").trim(); + if (!summary) continue; + const sev = /\*\*Severity:\*\*\s*(block|warn|info)/i.exec(block)?.[1]?.toLowerCase(); + const fileLine = /\*\*File:\*\*\s*(\S+)/i.exec(block)?.[1] ?? "unknown"; + const rationale = /\*\*Rationale:\*\*\s*([\s\S]+?)(?=\n###|\n\*\*|$)/i.exec(block)?.[1]?.trim() ?? ""; + const severity: Finding["severity"] = sev === "block" ? "block" : sev === "warn" ? "warn" : "info"; + findings.push({ + check: "kimi_architect" as CheckKind, + severity, + summary: summary.slice(0, 240), + evidence: [fileLine, rationale.slice(0, 360)].filter(Boolean), + }); + } + return findings; +} + +// For each finding's cited file:line, grep the actual file to verify +// the line exists. Returns total + verified counts; per-finding metadata +// is appended into the evidence array so the reader can see which +// citations were verified. +async function computeGrounding(findings: Finding[]): Promise<{ total: number; verified: number; rate: number }> { + // readFile (async) instead of readFileSync — caught 2026-04-27 by + // Kimi's self-audit. Sync I/O in an async fn blocks the event loop + // for every cited file; doesn't matter at 10 findings, would matter + // at 100+. + const checks = await Promise.all(findings.map(async (f) => { + const cite = f.evidence[0] ?? ""; + const m = /^(\S+?):(\d+)/.exec(cite); + if (!m) return false; + const [, relpath, lineStr] = m; + const line = Number(lineStr); + if (!line || !relpath) return false; + + // Path-traversal guard, two-layer (caught 2026-04-27 by Kimi + // self-audits on dd77632 then 2d9cb12). + // + // Layer 1 (lexical): resolve() normalizes `..` segments. Refuse + // any path that doesn't anchor under REPO_ROOT. + // + // Layer 2 (symlink): even if the lexical path is anchored, it + // could be a symlink whose target escapes. realpath() resolves + // symlinks; compare the real path against REPO_ROOT_REAL. + // + // Both layers exist because attackers might bypass either alone: + // raw `../etc/passwd` triggers layer 1; a planted symlink at + // ./safe-looking-name → /etc/passwd triggers layer 2. + const abs = resolve(REPO_ROOT, relpath); + if (!abs.startsWith(REPO_ROOT + "/") && abs !== REPO_ROOT) { + f.evidence.push(`[grounding: path escapes repo root, refusing]`); + return false; + } + + if (!existsSync(abs)) { + f.evidence.push("[grounding: file not found]"); + return false; + } + try { + // Symlink-resolution check before any read. realpath() throws + // if the file doesn't exist; existsSync above shields the + // common case but a TOCTOU race could still error here — the + // outer catch handles it. + const realPath = await realpath(abs); + if (!realPath.startsWith(REPO_ROOT_REAL + "/") && realPath !== REPO_ROOT_REAL) { + f.evidence.push(`[grounding: symlink target escapes repo root, refusing]`); + return false; + } + const lines = (await readFile(realPath, "utf8")).split("\n"); + if (line < 1 || line > lines.length) { + f.evidence.push(`[grounding: line ${line} > EOF (${lines.length})]`); + return false; + } + f.evidence.push(`[grounding: verified at ${relpath}:${line}]`); + return true; + } catch (e) { + f.evidence.push(`[grounding: read failed: ${(e as Error).message.slice(0, 80)}]`); + return false; + } + })); + const verified = checks.filter(Boolean).length; + const total = findings.length; + return { total, verified, rate: total === 0 ? 0 : verified / total }; +} + +async function persistVerdict(path: string, v: KimiVerdictFile): Promise { + await mkdir(KIMI_VERDICTS_DIR, { recursive: true }); + await writeFile(path, JSON.stringify(v, null, 2)); +} + +async function appendMetrics(v: KimiVerdictFile): Promise { + // dirname() instead of join(path, "..") — caught 2026-04-27 by both + // Haiku and Opus self-audits. The "/.." idiom resolves correctly + // via Node path normalization but is non-idiomatic + breaks if the + // path ever has trailing dots. + await mkdir(dirname(KIMI_AUDITS_JSONL), { recursive: true }); + await appendFile(KIMI_AUDITS_JSONL, JSON.stringify({ + pr_number: v.pr_number, + head_sha: v.head_sha, + audited_at: v.cached_at, + model: v.model, + latency_ms: v.latency_ms, + finish_reason: v.finish_reason, + prompt_tokens: v.usage.prompt_tokens, + completion_tokens: v.usage.completion_tokens, + findings_total: v.findings.length, + findings_block: v.findings.filter(f => f.severity === "block").length, + findings_warn: v.findings.filter(f => f.severity === "warn").length, + grounding_verified: v.grounding.verified, + grounding_rate: Number(v.grounding.rate.toFixed(3)), + }) + "\n"); +} + +function skipFinding(why: string): Finding { + return { + check: "kimi_architect" as CheckKind, + severity: "info", + summary: `kimi_architect skipped — ${why}`, + evidence: [why], + }; +} diff --git a/auditor/checks/static.ts b/auditor/checks/static.ts index 5c8a329..ea339b7 100644 --- a/auditor/checks/static.ts +++ b/auditor/checks/static.ts @@ -54,49 +54,87 @@ export function runStaticCheck(diff: string): Finding[] { const isAuditorCheckerFile = path.startsWith("auditor/checks/") || path.startsWith("auditor/fixtures/"); + // Track multi-line backtick-template state across the file. Walks + // all post-merge lines (context + added, skipping removed lines) + // in order and keeps `inMultilineBacktick` flipping on each + // unescaped backtick. Pre-2026-04-26 the per-line walk in + // isInsideQuotedString missed `todo!()` matches inside docstring + // template literals because the opening backtick lived on a + // line above the match. Now we OR the file-level state into the + // per-line check. + let inMultilineBacktick = false; + for (let idx = 0; idx < lines.length; idx++) { const line = lines[idx]; - if (!line.startsWith("+") || line.startsWith("+++")) continue; - const added = line.slice(1); - if (!isAuditorCheckerFile) { - for (const { re, why } of BLOCK_PATTERNS) { - const m = added.match(re); - if (m && typeof m.index === "number") { - // Skip if the match sits inside a quoted string literal — - // this is how rubric files (tests/real-world/*, prompt - // templates) legitimately reference the patterns they - // guard against, without actually executing them. - if (isInsideQuotedString(added, m.index)) continue; + // Diff bookkeeping lines and removed lines don't contribute to + // the post-merge file's string state. + if (line.startsWith("+++") || line.startsWith("---") || + line.startsWith("@@") || line.startsWith("\\ No newline")) continue; + if (line.startsWith("-")) continue; + + const isAdded = line.startsWith("+"); + // Strip the diff prefix (' ' for context, '+' for added). + const body = (isAdded || line.startsWith(" ")) ? line.slice(1) : line; + + // Compute the file-level backtick state ENTERING this line. + // The state machine sees pattern matches against the right + // context: a line that opens a backtick block has its own + // pattern checks evaluated under "inside-backtick" semantics + // for the portion AFTER the opening tick. Pre-2026-04-27 the + // state was updated AFTER the pattern checks, so the FIRST + // pattern on a backtick-opening line slipped through with + // stale "outside-backtick" semantics. Caught by Kimi self-audit. + const stateAtLineStart = inMultilineBacktick; + const stateAtLineEnd = updateBacktickState(body, stateAtLineStart); + + if (isAdded) { + const added = body; + + if (!isAuditorCheckerFile) { + for (const { re, why } of BLOCK_PATTERNS) { + const m = added.match(re); + if (m && typeof m.index === "number") { + // Skip if EITHER (a) the file was already inside a + // multi-line backtick block when this line started, OR + // (b) the match sits inside a quoted string literal on + // THIS line. The earlier code only checked stateAtLineStart; + // now we also check that the match isn't past the + // opening backtick of a block that opens on this line. + if (stateAtLineStart || isInsideQuotedString(added, m.index)) continue; + findings.push({ + check: "static", + severity: "block", + summary: `${why} in ${path}`, + evidence: [`${path}:+${idx + 1}: ${added.trim().slice(0, 160)}`], + }); + } + } + } + for (const { re, why } of WARN_COMMENT_PATTERNS) { + if (re.test(line)) { findings.push({ check: "static", - severity: "block", + severity: "warn", + summary: `${why} in ${path}`, + evidence: [`${path}:+${idx + 1}: ${added.trim().slice(0, 160)}`], + }); + } + } + for (const { re, why } of INFO_HARDCODED_PATTERNS) { + if (re.test(added)) { + findings.push({ + check: "static", + severity: "info", summary: `${why} in ${path}`, evidence: [`${path}:+${idx + 1}: ${added.trim().slice(0, 160)}`], }); } } } - for (const { re, why } of WARN_COMMENT_PATTERNS) { - if (re.test(line)) { - findings.push({ - check: "static", - severity: "warn", - summary: `${why} in ${path}`, - evidence: [`${path}:+${idx + 1}: ${added.trim().slice(0, 160)}`], - }); - } - } - for (const { re, why } of INFO_HARDCODED_PATTERNS) { - if (re.test(added)) { - findings.push({ - check: "static", - severity: "info", - summary: `${why} in ${path}`, - evidence: [`${path}:+${idx + 1}: ${added.trim().slice(0, 160)}`], - }); - } - } + + // Carry the end-of-line state forward to the next iteration. + inMultilineBacktick = stateAtLineEnd; } // "Field added but never read" heuristic — catches exactly the @@ -105,10 +143,20 @@ export function runStaticCheck(diff: string): Finding[] { // elsewhere might exist). The point is: if NEITHER this diff nor // any other line in the diff reads the field, the PR is shipping // state without a consumer. + // + // Serde exemption: if the field's parent struct derives Serialize + // or Deserialize, the read-site is the macro itself — JSON + // round-trips consume every public field. Without this exemption + // the check produces false positives on every response/request + // struct shipped through `/v1/*`. const addedLines = lines.filter(l => l.startsWith("+") && !l.startsWith("+++")) .map(l => l.slice(1)); - const newFields = extractNewFields(addedLines); - for (const field of newFields) { + const newFields = extractNewFieldsWithLine(lines); + const seenNames = new Set(); + for (const { name: field, lineIdx } of newFields) { + if (seenNames.has(field)) continue; + seenNames.add(field); + if (parentStructHasSerdeDerive(lines, lineIdx)) continue; const readPattern = new RegExp(`[\\.:]\\s*${escape(field)}\\b|\\b${escape(field)}\\s*:`); // The definition line itself matches readPattern — filter it out // by requiring at least TWO lines in the diff mention the field @@ -146,26 +194,105 @@ function splitDiffByFile(diff: string): Map { return out; } -// Extract new `pub name: Type,` fields from added lines. Rust syntax. -// Narrowly-scoped: only matches at the start of a trimmed line, -// requires `pub ` prefix, ignores `pub fn` / `pub struct` / etc. -function extractNewFields(addedLines: string[]): string[] { - const fields = new Set(); - for (const line of addedLines) { - const t = line.trim(); - // pub NAME: Type, +// Extract new `pub name: Type,` fields from the per-file diff lines, +// keeping each occurrence's line index so the caller can resolve the +// parent struct. Same narrow rules as before: starts with `pub `, +// excludes `pub fn` / `pub struct` / etc. +function extractNewFieldsWithLine(lines: string[]): Array<{ name: string; lineIdx: number }> { + const out: Array<{ name: string; lineIdx: number }> = []; + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + if (!line.startsWith("+") || line.startsWith("+++")) continue; + const t = line.slice(1).trim(); const m = t.match(/^pub\s+(?!fn\b|struct\b|enum\b|mod\b|use\b|trait\b|impl\b|const\b|static\b|type\b)(\w+)\s*:/); - if (m) fields.add(m[1]); + if (m) out.push({ name: m[1], lineIdx: i }); } - return Array.from(fields); + return out; +} + +// True if the field at `fieldLineIdx` lives inside a struct whose +// declaration carries `#[derive(... Serialize|Deserialize ...)]`. We +// walk backward through the diff (added + context lines both count — +// a struct declaration unchanged by the PR still appears as context) +// to find the nearest `pub struct` boundary, then scan a few lines +// above it for derive attributes. Conservative bounds: +// - 80 lines back to find `struct` (struct definitions can grow large) +// - 8 lines above the `struct` keyword for attribute lines +// Stops the struct-search early if we hit a `}` at zero indent +// (the previous scope) or another `pub struct` (we left ours). +function parentStructHasSerdeDerive(lines: string[], fieldLineIdx: number): boolean { + // Bounds-check fieldLineIdx (caught 2026-04-27 by Kimi self-audit). + // Pre-fix: if fieldLineIdx >= lines.length, the loop ran from a + // negative implicit upper bound (fieldLineIdx - 80 could be > 0 + // even when fieldLineIdx is past EOF) and read undefined slots. + // Defensive: bail early on out-of-range input. + if (fieldLineIdx < 0 || fieldLineIdx >= lines.length) return false; + + let structLineIdx = -1; + for (let i = fieldLineIdx - 1; i >= 0 && i >= fieldLineIdx - 80; i--) { + const raw = lines[i]; + if (typeof raw !== "string" || raw.length === 0) continue; + const body = stripDiffPrefix(raw); + const trimmed = body.trim(); + if (/^pub\s+struct\s+\w/.test(trimmed)) { + structLineIdx = i; + break; + } + // Closing brace at column 0 means the enclosing scope ended above + // the field — we're not actually inside a struct. + if (body.startsWith("}")) return false; + } + if (structLineIdx < 0) return false; + + for (let j = structLineIdx - 1; j >= 0 && j >= structLineIdx - 8; j--) { + const raw = lines[j]; + if (typeof raw !== "string") continue; + const trimmed = stripDiffPrefix(raw).trim(); + if (trimmed === "" || trimmed.startsWith("//") || trimmed.startsWith("///")) continue; + if (!trimmed.startsWith("#[")) break; + if (/derive\s*\([^)]*\b(Serialize|Deserialize)\b/.test(trimmed)) return true; + } + return false; +} + +// Strip leading +/-/space from a unified-diff line, leaving the raw +// source line. Handles the case where the line is shorter than 1 char +// (rare but real for empty-context lines). +function stripDiffPrefix(line: string): string { + if (line.length === 0) return line; + const c = line[0]; + if (c === "+" || c === "-" || c === " ") return line.slice(1); + return line; +} + +// Walk a single line and toggle the cross-line backtick state on each +// unescaped backtick. Single-quote and double-quote runs are line- +// bounded in JS/TS/Rust by language rules (string literals don't span +// newlines without explicit `\` continuation), so we only track +// backticks across lines. Returns the new state for the next line. +function updateBacktickState(line: string, inBacktick: boolean): boolean { + let state = inBacktick; + let inDouble = false; + let inSingle = false; + for (let i = 0; i < line.length; i++) { + const c = line[i]; + const esc = i > 0 && line[i - 1] === "\\"; + if (esc) continue; + // Inside a multi-line backtick template, single/double quotes + // don't open new strings — they're literal characters of the + // template. Same applies the other way around. + if (c === '"' && !inSingle && !state) inDouble = !inDouble; + else if (c === "'" && !inDouble && !state) inSingle = !inSingle; + else if (c === "`" && !inDouble && !inSingle) state = !state; + } + return state; } // True if `pos` falls inside a double- or single-quoted string on this // line (backtick template literals too). Walks left→right toggling the -// "in quote" state on each unescaped quote. Good enough for single- -// line matches; multi-line strings aren't parsed (they're extremely -// rare in the patterns we're blocking on, and would require a proper -// tokenizer to handle correctly). +// "in quote" state on each unescaped quote. Per-line only — the file- +// level walk in runStaticCheck handles multi-line backtick templates +// via updateBacktickState. function isInsideQuotedString(line: string, pos: number): boolean { let inDouble = false, inSingle = false, inBacktick = false; for (let i = 0; i < pos; i++) { diff --git a/auditor/index.ts b/auditor/index.ts index cd64144..c3bd9c0 100644 --- a/auditor/index.ts +++ b/auditor/index.ts @@ -24,14 +24,30 @@ const POLL_INTERVAL_MS = 90_000; // 90s — enough budget for audit runs to comp const PAUSE_FILE = "/home/profit/lakehouse/auditor.paused"; const STATE_FILE = "/home/profit/lakehouse/data/_auditor/state.json"; +// Per-PR audit cap. Prevents the daemon from running away on a PR +// when each push surfaces new findings — operator wants to review +// in batch, not have the daemon burn budget while they're away. +// Default 3 audits per PR. Override via LH_AUDITOR_MAX_AUDITS_PER_PR. +// Set to 0 to disable the cap. +// +// Reset (after manual review): edit data/_auditor/state.json and +// set audit_count_per_pr. = 0 (or delete the key). Daemon picks +// up the change on the next cycle without restart. +const MAX_AUDITS_PER_PR = Number(process.env.LH_AUDITOR_MAX_AUDITS_PER_PR) || 3; + interface State { // Map: PR number → last-audited head SHA. Lets us dedupe audits // across restarts (poller can crash/restart without re-auditing // all open PRs from scratch). last_audited: Record; + // Map: PR number → number of audits run on that PR since last reset. + // Daemon halts auditing a PR once this hits MAX_AUDITS_PER_PR. + // Operator clears the entry to resume. + audit_count_per_pr: Record; started_at: string; cycles_total: number; cycles_skipped_paused: number; + cycles_skipped_capped: number; audits_run: number; last_cycle_at?: string; } @@ -47,17 +63,21 @@ async function loadState(): Promise { return { last_audited: s.last_audited ?? {}, started_at: s.started_at ?? new Date().toISOString(), + audit_count_per_pr: s.audit_count_per_pr ?? {}, cycles_total: s.cycles_total ?? 0, cycles_skipped_paused: s.cycles_skipped_paused ?? 0, + cycles_skipped_capped: s.cycles_skipped_capped ?? 0, audits_run: s.audits_run ?? 0, last_cycle_at: s.last_cycle_at, }; } catch { return { last_audited: {}, + audit_count_per_pr: {}, started_at: new Date().toISOString(), cycles_total: 0, cycles_skipped_paused: 0, + cycles_skipped_capped: 0, audits_run: 0, }; } @@ -89,12 +109,38 @@ async function runCycle(state: State): Promise { console.log(`[auditor] cycle ${state.cycles_total}: ${prs.length} open PR(s)`); for (const pr of prs) { - const last = state.last_audited[String(pr.number)]; + const prKey = String(pr.number); + const last = state.last_audited[prKey]; if (last === pr.head_sha) { console.log(`[auditor] skip PR #${pr.number} (SHA ${pr.head_sha.slice(0, 8)} already audited)`); continue; } - console.log(`[auditor] audit PR #${pr.number} (${pr.head_sha.slice(0, 8)}) — ${pr.title.slice(0, 60)}`); + // Per-head-SHA audit cap. Each new push gets MAX_AUDITS_PER_PR + // fresh attempts; the counter auto-resets when the head SHA + // changes. Operator only intervenes manually if a single SHA + // somehow needs MORE than the cap (rare — usually transient + // upstream errors clear themselves inside 3 attempts). + // + // Reset rule: if `last` exists (we've seen this PR before) AND + // pr.head_sha != last, that's a new push. Drop the counter. + // The dedup branch above already handles same-SHA → skip, so + // we only land here when the SHA actually moved. + if (last !== undefined && (state.audit_count_per_pr[prKey] ?? 0) > 0) { + const prior_count = state.audit_count_per_pr[prKey]; + console.log(`[auditor] PR #${pr.number} new head ${pr.head_sha.slice(0, 8)} (prior ${last.slice(0, 8)}, was ${prior_count}/${MAX_AUDITS_PER_PR}) — resetting cap counter`); + state.audit_count_per_pr[prKey] = 0; + } + const auditedSoFar = state.audit_count_per_pr[prKey] ?? 0; + if (MAX_AUDITS_PER_PR > 0 && auditedSoFar >= MAX_AUDITS_PER_PR) { + // This branch only fires now if the SAME head SHA somehow + // burned MAX audits (transient upstream errors retried that + // many times). Operator can clear state.audit_count_per_pr. + // = 0 to force one more attempt; otherwise wait for next push. + console.log(`[auditor] skip PR #${pr.number} (same head ${pr.head_sha.slice(0, 8)} burned ${auditedSoFar}/${MAX_AUDITS_PER_PR} — push new code or clear state.json audit_count_per_pr.${prKey})`); + state.cycles_skipped_capped += 1; + continue; + } + console.log(`[auditor] audit PR #${pr.number} (${pr.head_sha.slice(0, 8)}) — ${pr.title.slice(0, 60)} [${auditedSoFar + 1}/${MAX_AUDITS_PER_PR}]`); try { // Skip dynamic by default: it mutates live playbook state and // re-runs on every PR update would pollute quickly. Operator @@ -106,8 +152,22 @@ async function runCycle(state: State): Promise { skip_inference: process.env.LH_AUDITOR_SKIP_INFERENCE === "1", }); console.log(`[auditor] verdict=${verdict.overall} findings=${verdict.metrics.findings_total} (block=${verdict.metrics.findings_block} warn=${verdict.metrics.findings_warn})`); - state.last_audited[String(pr.number)] = pr.head_sha; + state.last_audited[prKey] = pr.head_sha; + state.audit_count_per_pr[prKey] = auditedSoFar + 1; state.audits_run += 1; + if (state.audit_count_per_pr[prKey] >= MAX_AUDITS_PER_PR) { + console.log(`[auditor] PR #${pr.number} reached cap (${MAX_AUDITS_PER_PR} audits) — daemon will skip further audits until reset`); + } + // Persist state immediately after each successful audit so the + // increment survives a crash. Pre-2026-04-27 the cycle saved + // once at the end (main.ts:140), which lost the count if the + // daemon was killed mid-cycle. Fix lifted from kimi_architect's + // own audit on this very file. saveState is idempotent + cheap + // (one JSON write), so per-audit cost is negligible. + try { await saveState(state); } + catch (e) { + console.error(`[auditor] saveState mid-cycle failed: ${(e as Error).message} — count held in memory`); + } } catch (e) { console.error(`[auditor] audit failed: ${(e as Error).message}`); } diff --git a/auditor/schemas/distillation/drift_report.ts b/auditor/schemas/distillation/drift_report.ts new file mode 100644 index 0000000..9f979f2 --- /dev/null +++ b/auditor/schemas/distillation/drift_report.ts @@ -0,0 +1,85 @@ +// drift_report.ts — comparison of a current run summary vs the +// previous run summary on disk. Spec calls this "drift detection"; +// concretely it answers: did the pipeline behave the same way as +// last time, and if not, was the change explained by an input change +// or did it appear out of nowhere (silent drift)? +// +// Severity: +// ok — within 20% on every metric, no hash surprises +// warn — record-count or category swing > 20%, OR new error class +// alert — output_hash differs while input_hash is identical +// (deterministic violation — same input → different output) + +import { + ValidationResult, requireString, requireIsoTimestamp, +} from "./types"; +import type { StageName } from "./stage_receipt"; + +export const DRIFT_REPORT_SCHEMA_VERSION = 2; +export const DRIFT_THRESHOLD_PCT = 0.20; + +export type DriftSeverity = "ok" | "warn" | "alert"; + +export interface StageDrift { + stage: StageName; + delta_records_in: number; // current - prior + delta_records_out: number; + delta_accepted: number; + delta_quarantined: number; + pct_change_out: number | null; // null when prior had 0 records + // null when input_hash isn't materialized into the stage summary — + // schema v1 lied and reported `true` here. v2 is honest: callers + // that want determinism enforcement must read the full StageReceipt + // off disk and compute input_hash equality there. + input_hash_match: boolean | null; + output_hash_match: boolean; + // alert if input_hash matches but output_hash diverges + deterministic_violation: boolean; + notes: string[]; +} + +export interface DriftReport { + schema_version: number; + run_id: string; + prior_run_id: string | null; // null when no prior run on disk + generated_at: string; + severity: DriftSeverity; + stages: StageDrift[]; + // Top-level swings the human reader should see immediately. + flags: string[]; +} + +export function validateDriftReport(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) { + return { valid: false, errors: ["expected object"] }; + } + const r = input as Record; + let ok = true; + + if (r.schema_version !== DRIFT_REPORT_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${DRIFT_REPORT_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.run_id, "run_id", errors) && ok; + if (r.prior_run_id !== null && typeof r.prior_run_id !== "string") { + errors.push("prior_run_id: must be string or null"); + ok = false; + } + ok = requireIsoTimestamp(r.generated_at, "generated_at", errors) && ok; + if (!["ok", "warn", "alert"].includes(r.severity as string)) { + errors.push(`severity: must be ok|warn|alert, got ${JSON.stringify(r.severity)}`); + ok = false; + } + if (!Array.isArray(r.stages)) { + errors.push("stages: expected array"); + ok = false; + } + if (!Array.isArray(r.flags)) { + errors.push("flags: expected array"); + ok = false; + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as DriftReport }; +} diff --git a/auditor/schemas/distillation/evidence_record.test.ts b/auditor/schemas/distillation/evidence_record.test.ts new file mode 100644 index 0000000..0bb7e9f --- /dev/null +++ b/auditor/schemas/distillation/evidence_record.test.ts @@ -0,0 +1,116 @@ +// EvidenceRecord schema tests. +// +// Two positive fixtures (one per real-source prototype: distilled_facts +// + contract_analyses) and three negative fixtures pinning the +// non-negotiable invariants the spec demands: +// - every record must trace to a source (provenance) +// - schema_version must match — silent v1/v2 drift is the worst kind +// - required identity fields (run_id) cannot be missing +// +// Run with: bun test auditor/schemas/distillation/evidence_record.test.ts + +import { test, expect } from "bun:test"; +import { readFileSync } from "node:fs"; +import { resolve } from "node:path"; + +import { validateEvidenceRecord, EVIDENCE_SCHEMA_VERSION } from "./evidence_record"; + +const FIXTURE_DIR = resolve(import.meta.dir, "fixtures"); + +function loadFixture(name: string): unknown { + return JSON.parse(readFileSync(resolve(FIXTURE_DIR, name), "utf8")); +} + +test("EVIDENCE_SCHEMA_VERSION is 1 — bump deliberately, never silently", () => { + expect(EVIDENCE_SCHEMA_VERSION).toBe(1); +}); + +test("positive: distilled_fact materialized record validates", () => { + const r = validateEvidenceRecord(loadFixture("evidence_positive_distilled_fact.json")); + if (!r.valid) console.error("unexpected errors:", r.errors); + expect(r.valid).toBe(true); + if (r.valid) { + expect(r.value.run_id).toBe("cae21289"); + expect(r.value.model_role).toBe("extractor"); + expect(r.value.provenance.source_file).toBe("data/_kb/distilled_facts.jsonl"); + } +}); + +test("positive: contract_analysis materialized record validates with retrieval + observer fields", () => { + const r = validateEvidenceRecord(loadFixture("evidence_positive_contract_analysis.json")); + if (!r.valid) console.error("unexpected errors:", r.errors); + expect(r.valid).toBe(true); + if (r.valid) { + expect(r.value.observer_verdict).toBe("reject"); + expect(r.value.observer_confidence).toBe(95); + expect(r.value.retrieved_context?.matrix_corpora?.length).toBe(4); + expect(r.value.failure_markers).toContain("observer_rejected"); + } +}); + +test("negative: missing run_id is rejected with a specific error", () => { + const r = validateEvidenceRecord(loadFixture("evidence_negative_no_run_id.json")); + expect(r.valid).toBe(false); + if (!r.valid) { + expect(r.errors.some(e => e.includes("run_id"))).toBe(true); + } +}); + +test("negative: schema_version mismatch is rejected (silent v1/v2 drift guard)", () => { + const r = validateEvidenceRecord(loadFixture("evidence_negative_bad_schema_version.json")); + expect(r.valid).toBe(false); + if (!r.valid) { + expect(r.errors.some(e => e.includes("schema_version"))).toBe(true); + } +}); + +test("negative: bad provenance (non-sha256 sig_hash, non-ISO timestamp) is rejected", () => { + const r = validateEvidenceRecord(loadFixture("evidence_negative_bad_provenance.json")); + expect(r.valid).toBe(false); + if (!r.valid) { + // Must catch BOTH the sig_hash AND the recorded_at — comprehensive + // error reporting is part of the contract. + expect(r.errors.some(e => e.includes("sig_hash"))).toBe(true); + expect(r.errors.some(e => e.includes("recorded_at"))).toBe(true); + } +}); + +test("negative: non-object input is rejected with clear error", () => { + const r = validateEvidenceRecord("not an object"); + expect(r.valid).toBe(false); + if (!r.valid) { + expect(r.errors[0]).toContain("expected object"); + } +}); + +test("negative: human_override with invalid decision is rejected", () => { + const fixture = loadFixture("evidence_positive_distilled_fact.json") as Record; + fixture.human_override = { + overrider: "test-user", + decision: "maybe", // invalid — must be accept|reject|needs_review + reason: "test", + overridden_at: "2026-04-26T22:30:00.000Z", + }; + const r = validateEvidenceRecord(fixture); + expect(r.valid).toBe(false); + if (!r.valid) { + expect(r.errors.some(e => e.includes("human_override.decision"))).toBe(true); + } +}); + +test("positive: human_override = null is allowed (explicitly no override)", () => { + const fixture = loadFixture("evidence_positive_distilled_fact.json") as Record; + fixture.human_override = null; + const r = validateEvidenceRecord(fixture); + expect(r.valid).toBe(true); +}); + +test("negative: observer_confidence outside [0, 100] is rejected", () => { + const fixture = loadFixture("evidence_positive_contract_analysis.json") as Record; + fixture.observer_confidence = 150; + const r = validateEvidenceRecord(fixture); + expect(r.valid).toBe(false); + if (!r.valid) { + expect(r.errors.some(e => e.includes("observer_confidence"))).toBe(true); + } +}); diff --git a/auditor/schemas/distillation/evidence_record.ts b/auditor/schemas/distillation/evidence_record.ts new file mode 100644 index 0000000..6730646 --- /dev/null +++ b/auditor/schemas/distillation/evidence_record.ts @@ -0,0 +1,202 @@ +// EvidenceRecord — the unified per-execution-trace record that the +// Evidence View emits and the Success Scorer reads. +// +// Derived from now.md spec + reconciliation of two existing prototypes: +// - distilled_facts.jsonl / distilled_procedures.jsonl (LLM-extracted +// text with run_id + sig_hash + extractor + verifier + embedding) +// - contract_analyses.jsonl (observer integration + retrieval +// telemetry + cost + duration) +// +// Required fields are the ones every record MUST have for traceability: +// run_id, task_id, timestamp, schema_version, provenance. Everything +// else is typed-but-optional because no single source has all of them +// — the Evidence View materializes them by JOINing across streams when +// the source data is present. +// +// schema_version starts at 1 and gets bumped on breaking changes. +// Validators MUST check schema_version and refuse unknown values so a +// future v2 reader doesn't silently accept v1 records (or vice versa). + +import { + ValidationResult, Provenance, + requireString, requireNumber, requireIsoTimestamp, requireProvenance, requireStringArray, +} from "./types"; + +export const EVIDENCE_SCHEMA_VERSION = 1; + +export type ModelRole = + | "executor" // produced the answer (e.g. scrum reviewer, mode runner LLM call) + | "reviewer" // judged an executor output (e.g. observer, hand-review) + | "extractor" // pulled structured data from text (e.g. fact_extractor) + | "verifier" // confirmed/rejected an extracted claim (verifier in distilled_*) + | "categorizer" // assigned a category (categorizer in distilled_*) + | "tiebreaker" // resolved a consensus split + | "applier" // landed code (scrum_applier) + | "embedder" // produced embeddings + | "other"; + +export interface EvidenceRecord { + // ── Identity ── + // run_id ties this record to a specific execution. Sources use it + // inconsistently (some stream-level, some per-call). The Evidence + // View canonicalizes to per-call; if the source is stream-level, + // synthesize as `${stream_run_id}:${row_index}`. + run_id: string; + + // task_id groups records by logical task (e.g. one PR = one task_id + // across multiple per-call runs). Defaults to run_id when no group + // exists — never null. + task_id: string; + + // ISO 8601 of when the EXECUTION happened, not when this record was + // materialized. Use the source row's timestamp; provenance carries + // the materialization time separately. + timestamp: string; + + schema_version: number; + + // ── Provenance ── (required — no record without source linkage) + provenance: Provenance; + + // ── Model attribution (optional) ── + model_name?: string; // e.g. "kimi-k2:1t", "gpt-oss:120b" + model_provider?: string; // e.g. "ollama_cloud", "openrouter", "ollama" + model_role?: ModelRole; + + // ── Content hashes (optional) ── + // sha256 of the full input prompt and full output content. Pre- + // computed so the Evidence Index can dedup across re-runs of the + // same prompt without re-hashing. + input_hash?: string; + output_hash?: string; + + // ── Repo + execution context ── + source_files?: string[]; // files the run touched/read + commands_run?: string[]; // shell commands or tool calls fired + retrieved_context?: { // what the model saw via retrieval + matrix_corpora?: string[]; + matrix_hits?: number; + matrix_chunks_kept?: number; + matrix_chunks_dropped?: number; + pathway_fingerprints_seen?: number; + }; + + // ── Observer + scratchpad ── + observer_notes?: string[]; // observer.review() free-form notes + observer_verdict?: "accept" | "reject" | "cycle" | string; + observer_confidence?: number; // 0-100 + scratchpad_summary?: string; // tree-split scratchpad text or hash ref + + // ── Outcome markers ── + // Both arrays exist because a run can have multiple succeeded gates + // AND multiple failed gates simultaneously. Empty arrays are valid; + // missing arrays are also valid (means "no evidence either way"). + success_markers?: string[]; // e.g. "cargo_green", "tests_passed", "anchor_grounded" + failure_markers?: string[]; // e.g. "warning_count_up", "rationale_mismatch", "consensus_split" + + // ── Validation telemetry ── + validation_results?: { + grounded_fraction?: number; // mode_compare grounding % + schema_valid?: boolean; + pathway_replay_succeeded?: boolean; + [key: string]: unknown; + }; + + // ── Human-in-loop ── + human_override?: { + overrider: string; // user identifier + decision: "accept" | "reject" | "needs_review"; + reason: string; + overridden_at: string; // ISO 8601 + } | null; + + // ── Performance ── + cost_usd?: number; + latency_ms?: number; + prompt_tokens?: number; + completion_tokens?: number; + + // ── Free-form text content (the actual run output) ── + // Optional because some sources are pure metadata (auto_apply.jsonl) + // and have no text payload. Present for distilled_*, contract_analyses, + // mode_experiments, scrum_reviews etc. + text?: string; + + // ── Domain-specific metadata bucket ── + // Source-specific fields that don't earn a top-level slot. e.g. + // contract_analyses rows carry `contractor` here; mode_experiments + // could carry `corpus_set`. Typed scalar values only — keep this + // small or it becomes a junk drawer. Added 2026-04-27 (Kimi audit + // flagged `(ev as any).contractor` schema bypass at export_sft.ts:126). + metadata?: Record; +} + +export function validateEvidenceRecord(input: unknown): ValidationResult { + const errors: string[] = []; + + if (typeof input !== "object" || input === null) { + return { valid: false, errors: ["expected object, got " + (input === null ? "null" : typeof input)] }; + } + const r = input as Record; + + // Required + let ok = true; + ok = requireString(r.run_id, "run_id", errors) && ok; + ok = requireString(r.task_id, "task_id", errors) && ok; + ok = requireIsoTimestamp(r.timestamp, "timestamp", errors) && ok; + ok = requireProvenance(r.provenance, "provenance", errors) && ok; + + if (r.schema_version !== EVIDENCE_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${EVIDENCE_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + + // Optional but typed-when-present + if (r.model_role !== undefined) { + const valid: ModelRole[] = ["executor", "reviewer", "extractor", "verifier", "categorizer", "tiebreaker", "applier", "embedder", "other"]; + if (!valid.includes(r.model_role as ModelRole)) { + errors.push(`model_role: must be one of ${valid.join("|")}, got ${JSON.stringify(r.model_role)}`); + ok = false; + } + } + if (r.input_hash !== undefined && !/^[0-9a-f]{64}$/.test(String(r.input_hash))) { + errors.push("input_hash: must be hex sha256 when present"); + ok = false; + } + if (r.output_hash !== undefined && !/^[0-9a-f]{64}$/.test(String(r.output_hash))) { + errors.push("output_hash: must be hex sha256 when present"); + ok = false; + } + if (r.source_files !== undefined && !requireStringArray(r.source_files, "source_files", errors)) ok = false; + if (r.commands_run !== undefined && !requireStringArray(r.commands_run, "commands_run", errors)) ok = false; + if (r.success_markers !== undefined && !requireStringArray(r.success_markers, "success_markers", errors)) ok = false; + if (r.failure_markers !== undefined && !requireStringArray(r.failure_markers, "failure_markers", errors)) ok = false; + if (r.observer_notes !== undefined && !requireStringArray(r.observer_notes, "observer_notes", errors)) ok = false; + + if (r.observer_confidence !== undefined) { + if (!requireNumber(r.observer_confidence, "observer_confidence", errors)) ok = false; + else if ((r.observer_confidence as number) < 0 || (r.observer_confidence as number) > 100) { + errors.push("observer_confidence: must be in [0, 100]"); + ok = false; + } + } + + if (r.human_override !== undefined && r.human_override !== null) { + const ho = r.human_override as Record; + if (typeof ho !== "object") { + errors.push("human_override: expected object or null"); + ok = false; + } else { + ok = requireString(ho.overrider, "human_override.overrider", errors) && ok; + ok = requireString(ho.reason, "human_override.reason", errors) && ok; + ok = requireIsoTimestamp(ho.overridden_at, "human_override.overridden_at", errors) && ok; + if (!["accept", "reject", "needs_review"].includes(ho.decision as string)) { + errors.push(`human_override.decision: must be accept|reject|needs_review`); + ok = false; + } + } + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as EvidenceRecord }; +} diff --git a/auditor/schemas/distillation/fixtures/evidence_negative_bad_provenance.json b/auditor/schemas/distillation/fixtures/evidence_negative_bad_provenance.json new file mode 100644 index 0000000..95d380b --- /dev/null +++ b/auditor/schemas/distillation/fixtures/evidence_negative_bad_provenance.json @@ -0,0 +1,11 @@ +{ + "run_id": "cae21289", + "task_id": "team_runs:637", + "timestamp": "2026-04-23T09:54:40.729599Z", + "schema_version": 1, + "provenance": { + "source_file": "data/_kb/distilled_facts.jsonl", + "sig_hash": "not-a-real-sha256", + "recorded_at": "yesterday" + } +} diff --git a/auditor/schemas/distillation/fixtures/evidence_negative_bad_schema_version.json b/auditor/schemas/distillation/fixtures/evidence_negative_bad_schema_version.json new file mode 100644 index 0000000..fa92485 --- /dev/null +++ b/auditor/schemas/distillation/fixtures/evidence_negative_bad_schema_version.json @@ -0,0 +1,11 @@ +{ + "run_id": "cae21289", + "task_id": "team_runs:637", + "timestamp": "2026-04-23T09:54:40.729599Z", + "schema_version": 99, + "provenance": { + "source_file": "data/_kb/distilled_facts.jsonl", + "sig_hash": "21a809e2dc43dfae0000000000000000000000000000000000000000deadbeef", + "recorded_at": "2026-04-26T22:30:00.000Z" + } +} diff --git a/auditor/schemas/distillation/fixtures/evidence_negative_no_run_id.json b/auditor/schemas/distillation/fixtures/evidence_negative_no_run_id.json new file mode 100644 index 0000000..3e93a7a --- /dev/null +++ b/auditor/schemas/distillation/fixtures/evidence_negative_no_run_id.json @@ -0,0 +1,11 @@ +{ + "task_id": "team_runs:637", + "timestamp": "2026-04-23T09:54:40.729599Z", + "schema_version": 1, + "provenance": { + "source_file": "data/_kb/distilled_facts.jsonl", + "sig_hash": "21a809e2dc43dfae0000000000000000000000000000000000000000deadbeef", + "recorded_at": "2026-04-26T22:30:00.000Z" + }, + "text": "missing run_id should fail validation" +} diff --git a/auditor/schemas/distillation/fixtures/evidence_positive_contract_analysis.json b/auditor/schemas/distillation/fixtures/evidence_positive_contract_analysis.json new file mode 100644 index 0000000..bb15d9c --- /dev/null +++ b/auditor/schemas/distillation/fixtures/evidence_positive_contract_analysis.json @@ -0,0 +1,27 @@ +{ + "run_id": "contract_analysis:101078392:1777250758717", + "task_id": "permit:101078392", + "timestamp": "2026-04-25T23:45:58.717Z", + "schema_version": 1, + "provenance": { + "source_file": "data/_kb/contract_analyses.jsonl", + "line_offset": 0, + "sig_hash": "f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1", + "recorded_at": "2026-04-26T22:30:00.000Z" + }, + "model_name": "kimi-k2:1t", + "model_role": "executor", + "model_provider": "ollama_cloud", + "retrieved_context": { + "matrix_corpora": ["entity_brief_v1", "chicago_permits_v1", "distilled_procedural_v20260423102847", "sec_tickers_v1"], + "matrix_hits": 10 + }, + "observer_notes": ["contractor history shows 0 prior fills in Chicago downtown zone"], + "observer_verdict": "reject", + "observer_confidence": 95, + "success_markers": ["matrix_hits_above_threshold"], + "failure_markers": ["observer_rejected"], + "cost_usd": 0.0002, + "latency_ms": 25419, + "text": "Permit 101078392 contractor ANTHONY FIORE — analysis: insufficient prior performance signal; recommend escalation." +} diff --git a/auditor/schemas/distillation/fixtures/evidence_positive_distilled_fact.json b/auditor/schemas/distillation/fixtures/evidence_positive_distilled_fact.json new file mode 100644 index 0000000..1a64291 --- /dev/null +++ b/auditor/schemas/distillation/fixtures/evidence_positive_distilled_fact.json @@ -0,0 +1,19 @@ +{ + "run_id": "cae21289", + "task_id": "team_runs:637", + "timestamp": "2026-04-23T09:54:40.729599Z", + "schema_version": 1, + "provenance": { + "source_file": "data/_kb/distilled_facts.jsonl", + "line_offset": 0, + "sig_hash": "21a809e2dc43dfae0000000000000000000000000000000000000000deadbeef", + "recorded_at": "2026-04-26T22:30:00.000Z" + }, + "model_name": "qwen2.5:latest", + "model_role": "extractor", + "model_provider": "ollama", + "text": "Convergence refers to the system stabilizing into a state of high performance with low variance across iterations.", + "validation_results": { + "schema_valid": true + } +} diff --git a/auditor/schemas/distillation/model_ledger.ts b/auditor/schemas/distillation/model_ledger.ts new file mode 100644 index 0000000..1d5bfe7 --- /dev/null +++ b/auditor/schemas/distillation/model_ledger.ts @@ -0,0 +1,56 @@ +// ModelLedgerEntry — aggregate per-task-type-per-model performance. +// Built by aggregating mode_experiments.jsonl + model_trust.jsonl. +// Updated rather than appended — one row per (model_name, task_type) +// representing latest aggregates. +import { + ValidationResult, requireString, requireNumber, requireIsoTimestamp, requireStringArray, +} from "./types"; + +export const MODEL_LEDGER_SCHEMA_VERSION = 1; + +export interface ModelLedgerEntry { + schema_version: number; + model_name: string; + model_provider: string; + task_type: string; + success_rate: number; // [0, 1] + failure_modes: string[]; // top failure mode tags + best_partner_model?: string; // pairs well with X (consensus / tie-break) + escalation_role?: string; // when this model gets escalated TO (or FROM) + cost_usd_p50?: number; + latency_ms_p50?: number; + latency_ms_p95?: number; + context_window?: number; + sample_count: number; + last_updated: string; // ISO 8601 + notes?: string; +} + +export function validateModelLedgerEntry(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) return { valid: false, errors: ["expected object"] }; + const r = input as Record; + let ok = true; + + if (r.schema_version !== MODEL_LEDGER_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${MODEL_LEDGER_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.model_name, "model_name", errors) && ok; + ok = requireString(r.model_provider, "model_provider", errors) && ok; + ok = requireString(r.task_type, "task_type", errors) && ok; + ok = requireIsoTimestamp(r.last_updated, "last_updated", errors) && ok; + ok = requireStringArray(r.failure_modes, "failure_modes", errors) && ok; + + if (!requireNumber(r.success_rate, "success_rate", errors)) ok = false; + else if ((r.success_rate as number) < 0 || (r.success_rate as number) > 1) { + errors.push("success_rate: must be in [0, 1]"); ok = false; + } + if (!requireNumber(r.sample_count, "sample_count", errors)) ok = false; + else if ((r.sample_count as number) < 1 || !Number.isInteger(r.sample_count)) { + errors.push("sample_count: must be positive integer (no aggregate from zero samples)"); ok = false; + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as ModelLedgerEntry }; +} diff --git a/auditor/schemas/distillation/playbook.ts b/auditor/schemas/distillation/playbook.ts new file mode 100644 index 0000000..d71a060 --- /dev/null +++ b/auditor/schemas/distillation/playbook.ts @@ -0,0 +1,68 @@ +// Playbook — procedural knowledge extracted from accepted/partially- +// accepted runs. Different from pathway_memory's bug_fingerprints (which +// are pattern-detectors) — playbooks describe HOW to handle a task type. +import { + ValidationResult, requireString, requireIsoTimestamp, requireProvenance, requireStringArray, +} from "./types"; + +export const PLAYBOOK_SCHEMA_VERSION = 1; + +export interface Playbook { + schema_version: number; + playbook_id: string; + task_type: string; // e.g. "scrum_review", "pr_audit", "staffing.fill" + problem_pattern: string; // when does this playbook apply? + useful_context: string[]; // what to retrieve before running + model_routing_path: string[]; // ordered model attempts that worked + commands_worked: string[]; + commands_failed: string[]; + validation_steps: string[]; + repo_files_touched: string[]; + recovery_strategy: string; // what to do when the path fails + known_failure_modes: string[]; + escalation_threshold: string; // when to switch to a stronger model + acceptance_criteria: string[]; // how to know it succeeded + source_run_ids: string[]; // FK to EvidenceRecord.run_id (provenance — every playbook traces to source) + created_at: string; + provenance: { source_file: string; line_offset?: number; sig_hash: string; recorded_at: string }; +} + +export function validatePlaybook(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) return { valid: false, errors: ["expected object"] }; + const r = input as Record; + let ok = true; + + if (r.schema_version !== PLAYBOOK_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${PLAYBOOK_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.playbook_id, "playbook_id", errors) && ok; + ok = requireString(r.task_type, "task_type", errors) && ok; + ok = requireString(r.problem_pattern, "problem_pattern", errors) && ok; + ok = requireString(r.recovery_strategy, "recovery_strategy", errors) && ok; + ok = requireString(r.escalation_threshold, "escalation_threshold", errors) && ok; + ok = requireIsoTimestamp(r.created_at, "created_at", errors) && ok; + ok = requireStringArray(r.useful_context, "useful_context", errors) && ok; + ok = requireStringArray(r.model_routing_path, "model_routing_path", errors) && ok; + ok = requireStringArray(r.commands_worked, "commands_worked", errors) && ok; + ok = requireStringArray(r.commands_failed, "commands_failed", errors) && ok; + ok = requireStringArray(r.validation_steps, "validation_steps", errors) && ok; + ok = requireStringArray(r.repo_files_touched, "repo_files_touched", errors) && ok; + ok = requireStringArray(r.known_failure_modes, "known_failure_modes", errors) && ok; + ok = requireStringArray(r.acceptance_criteria, "acceptance_criteria", errors) && ok; + ok = requireStringArray(r.source_run_ids, "source_run_ids", errors) && ok; + + if (Array.isArray(r.source_run_ids) && r.source_run_ids.length === 0) { + errors.push("source_run_ids: must be non-empty — every playbook traces to source evidence (spec non-negotiable)"); + ok = false; + } + if (Array.isArray(r.acceptance_criteria) && r.acceptance_criteria.length === 0) { + errors.push("acceptance_criteria: must be non-empty — every playbook needs success criteria (spec non-negotiable)"); + ok = false; + } + ok = requireProvenance(r.provenance, "provenance", errors) && ok; + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as Playbook }; +} diff --git a/auditor/schemas/distillation/preference_sample.ts b/auditor/schemas/distillation/preference_sample.ts new file mode 100644 index 0000000..caf5756 --- /dev/null +++ b/auditor/schemas/distillation/preference_sample.ts @@ -0,0 +1,60 @@ +// PreferenceSample — entry in exports/preference/chosen_rejected.jsonl. +// Source: real disagreements (audit_discrepancies, scrum ladder retries). +// Validator pins: chosen != rejected, both source_run_ids present, reason +// is non-empty. No synthesized preferences. +import { + ValidationResult, requireString, requireIsoTimestamp, requireProvenance, +} from "./types"; + +export const PREFERENCE_SAMPLE_SCHEMA_VERSION = 1; + +export interface PreferenceSample { + schema_version: number; + id: string; + prompt: string; + chosen: string; + rejected: string; + reason: string; // why chosen > rejected — must be non-empty + chosen_run_id: string; + rejected_run_id: string; + created_at: string; + provenance: { source_file: string; line_offset?: number; sig_hash: string; recorded_at: string }; +} + +export function validatePreferenceSample(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) return { valid: false, errors: ["expected object"] }; + const r = input as Record; + let ok = true; + + if (r.schema_version !== PREFERENCE_SAMPLE_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${PREFERENCE_SAMPLE_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.id, "id", errors) && ok; + ok = requireString(r.prompt, "prompt", errors) && ok; + ok = requireString(r.chosen, "chosen", errors) && ok; + ok = requireString(r.rejected, "rejected", errors) && ok; + ok = requireString(r.reason, "reason", errors) && ok; + ok = requireString(r.chosen_run_id, "chosen_run_id", errors) && ok; + ok = requireString(r.rejected_run_id, "rejected_run_id", errors) && ok; + ok = requireIsoTimestamp(r.created_at, "created_at", errors) && ok; + ok = requireProvenance(r.provenance, "provenance", errors) && ok; + + // Self-pairing guard. + if (r.chosen === r.rejected && typeof r.chosen === "string") { + errors.push("chosen and rejected must differ — preference data needs a real disagreement"); + ok = false; + } + if (r.chosen_run_id === r.rejected_run_id && typeof r.chosen_run_id === "string") { + errors.push("chosen_run_id and rejected_run_id must differ — same run can't disagree with itself"); + ok = false; + } + if (typeof r.reason === "string" && (r.reason as string).trim().length === 0) { + errors.push("reason: must be non-whitespace (every preference needs WHY chosen > rejected)"); + ok = false; + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as PreferenceSample }; +} diff --git a/auditor/schemas/distillation/rag_sample.ts b/auditor/schemas/distillation/rag_sample.ts new file mode 100644 index 0000000..0e75786 --- /dev/null +++ b/auditor/schemas/distillation/rag_sample.ts @@ -0,0 +1,72 @@ +// RagSample — entry in exports/rag/playbooks.jsonl. Spec shape exactly, +// plus provenance + success_score (so the index can re-rank by quality). +import { + ValidationResult, requireString, requireNumber, requireIsoTimestamp, requireProvenance, requireStringArray, +} from "./types"; + +export const RAG_SAMPLE_SCHEMA_VERSION = 1; + +// Allowed source_category values. RAG accepts accepted/partial freely; +// needs_human_review is opt-in (must be tagged so consumers can filter +// it out for SFT). +export const RAG_ALLOWED_CATEGORIES = ["accepted", "partially_accepted", "needs_human_review"] as const; +export type RagSourceCategory = (typeof RAG_ALLOWED_CATEGORIES)[number]; + +export interface RagSample { + schema_version: number; + id: string; + title: string; + content: string; + tags: string[]; + source_run_id: string; + // Snapshot of the score the source carried at export time. Lets a + // consumer see "this was partial" without re-reading scored-runs. + success_score: RagSourceCategory; + // Same value as success_score by spec (now.md asks for both fields). + // Kept distinct so future schemas can diverge them (e.g. an + // "is_review_material" flag) without breaking old consumers. + source_category: RagSourceCategory; + embedding_text: string; // the text to embed (often == content but can be shorter) + created_at: string; + provenance: { source_file: string; line_offset?: number; sig_hash: string; recorded_at: string }; +} + +export function validateRagSample(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) return { valid: false, errors: ["expected object"] }; + const r = input as Record; + let ok = true; + + if (r.schema_version !== RAG_SAMPLE_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${RAG_SAMPLE_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.id, "id", errors) && ok; + ok = requireString(r.title, "title", errors) && ok; + ok = requireString(r.content, "content", errors) && ok; + ok = requireString(r.embedding_text, "embedding_text", errors) && ok; + ok = requireString(r.source_run_id, "source_run_id", errors) && ok; + ok = requireIsoTimestamp(r.created_at, "created_at", errors) && ok; + ok = requireStringArray(r.tags, "tags", errors) && ok; + ok = requireProvenance(r.provenance, "provenance", errors) && ok; + + if (!RAG_ALLOWED_CATEGORIES.includes(r.success_score as RagSourceCategory)) { + errors.push(`success_score: must be one of ${RAG_ALLOWED_CATEGORIES.join("|")} (rejected never enters RAG)`); + ok = false; + } + if (!RAG_ALLOWED_CATEGORIES.includes(r.source_category as RagSourceCategory)) { + errors.push(`source_category: must be one of ${RAG_ALLOWED_CATEGORIES.join("|")}`); + ok = false; + } + if (r.success_score !== r.source_category) { + errors.push("success_score and source_category must match (mirrored fields per spec)"); + ok = false; + } + if (typeof r.content === "string" && (r.content as string).trim().length === 0) { + errors.push("content: must be non-whitespace"); + ok = false; + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as RagSample }; +} diff --git a/auditor/schemas/distillation/realdata.test.ts b/auditor/schemas/distillation/realdata.test.ts new file mode 100644 index 0000000..f1c7894 --- /dev/null +++ b/auditor/schemas/distillation/realdata.test.ts @@ -0,0 +1,286 @@ +// Real-data validation test — proves the EvidenceRecord schema fits +// what we ALREADY produce, with the minimum transformation each source +// stream requires. Doubles as the stale-extraction probe: if +// distilled_facts.jsonl rows can't materialize, we know that stream +// has rotted and Phase 2 sources from elsewhere. +// +// Strategy: +// 1. Read first N rows from each source jsonl (skip if missing) +// 2. Apply minimal transformer: add schema_version + provenance, +// synthesize run_id/task_id when source doesn't carry them +// 3. Validate each materialized record +// 4. Tally pass/fail per source + collect failure reasons +// +// This file is allowed to skip when source files don't exist (fresh +// clone), so it acts as both a CI guard and a real-environment probe. + +import { test, expect } from "bun:test"; +import { existsSync, readFileSync } from "node:fs"; +import { resolve } from "node:path"; + +import { + validateEvidenceRecord, EVIDENCE_SCHEMA_VERSION, EvidenceRecord, ModelRole, +} from "./evidence_record"; + +const ROOT = "/home/profit/lakehouse"; +const SAMPLE_PER_SOURCE = 10; + +interface SourceProbe { + source_file: string; + transform: (row: any, lineNo: number) => Partial | null; +} + +// Canonical 64-char synthetic sha256 for tests where the source row +// lacks one. Pretends the materializer would compute it via +// canonicalSha256(orderedKeys(row)) at Phase 2 time. We use a fixed +// value here to keep the test deterministic; real materialization +// re-hashes per row. +const PLACEHOLDER_SHA = "0000000000000000000000000000000000000000000000000000000000000000"; +const RECORDED = "2026-04-26T22:30:00.000Z"; + +function provFor(source_file: string, lineNo: number, sigHashRaw?: string): EvidenceRecord["provenance"] { + // Pad shorter hashes (distilled_* uses 16-char) to 64 — mimics + // canonical recompute. + const sig = sigHashRaw && /^[0-9a-f]+$/.test(sigHashRaw) + ? sigHashRaw.padEnd(64, "0").slice(0, 64) + : PLACEHOLDER_SHA; + return { + source_file: source_file.replace(`${ROOT}/`, ""), + line_offset: lineNo, + sig_hash: sig, + recorded_at: RECORDED, + }; +} + +const PROBES: SourceProbe[] = [ + { + source_file: `${ROOT}/data/_kb/distilled_facts.jsonl`, + transform: (row: any, lineNo: number) => ({ + run_id: String(row.run_id ?? `distilled_facts:${lineNo}`), + task_id: String(row.source_label ?? `distilled_facts:${lineNo}`), + timestamp: row.created_at, + schema_version: EVIDENCE_SCHEMA_VERSION, + provenance: provFor(`${ROOT}/data/_kb/distilled_facts.jsonl`, lineNo, row.sig_hash), + model_name: row.extractor, + model_role: "extractor" as ModelRole, + model_provider: "ollama", + text: row.text, + }), + }, + { + source_file: `${ROOT}/data/_kb/distilled_procedures.jsonl`, + transform: (row: any, lineNo: number) => ({ + run_id: String(row.run_id ?? `distilled_procedures:${lineNo}`), + task_id: String(row.source_label ?? `distilled_procedures:${lineNo}`), + timestamp: row.created_at, + schema_version: EVIDENCE_SCHEMA_VERSION, + provenance: provFor(`${ROOT}/data/_kb/distilled_procedures.jsonl`, lineNo, row.sig_hash), + model_name: row.extractor, + model_role: "extractor" as ModelRole, + model_provider: "ollama", + text: row.text, + }), + }, + { + source_file: `${ROOT}/data/_kb/contract_analyses.jsonl`, + transform: (row: any, lineNo: number) => ({ + run_id: `contract_analysis:${row.permit_id}:${new Date(row.ts).getTime()}`, + task_id: `permit:${row.permit_id}`, + timestamp: row.ts, + schema_version: EVIDENCE_SCHEMA_VERSION, + provenance: provFor(`${ROOT}/data/_kb/contract_analyses.jsonl`, lineNo), + model_role: "executor" as ModelRole, + retrieved_context: { + matrix_corpora: Object.keys(row.matrix_corpora ?? {}), + matrix_hits: row.matrix_hits, + }, + observer_notes: row.observer_notes ? [row.observer_notes].flat() : undefined, + observer_verdict: row.observer_verdict, + observer_confidence: row.observer_conf, + success_markers: row.ok ? ["matrix_hits_above_threshold"] : undefined, + failure_markers: !row.ok || row.observer_verdict === "reject" ? ["observer_rejected"] : undefined, + cost_usd: typeof row.cost === "number" ? row.cost / 1_000_000 : undefined, + latency_ms: row.duration_ms, + text: row.analysis, + }), + }, + { + source_file: `${ROOT}/data/_kb/mode_experiments.jsonl`, + transform: (row: any, lineNo: number) => ({ + run_id: `mode_exec:${new Date(row.ts).getTime()}:${row.file_path ?? "?"}`, + task_id: row.task_class, + timestamp: row.ts, + schema_version: EVIDENCE_SCHEMA_VERSION, + provenance: provFor(`${ROOT}/data/_kb/mode_experiments.jsonl`, lineNo), + model_name: row.model, + model_role: "executor" as ModelRole, + model_provider: row.model?.includes("/") ? "openrouter" : "ollama_cloud", + retrieved_context: { + matrix_corpora: row.sources?.matrix_corpus, + matrix_chunks_kept: row.sources?.matrix_chunks_kept, + matrix_chunks_dropped: row.sources?.matrix_chunks_dropped, + pathway_fingerprints_seen: row.sources?.bug_fingerprints_count, + }, + latency_ms: row.latency_ms, + text: row.response, + source_files: row.file_path ? [row.file_path] : undefined, + }), + }, + { + source_file: `${ROOT}/data/_kb/scrum_reviews.jsonl`, + transform: (row: any, lineNo: number) => ({ + run_id: `scrum:${new Date(row.reviewed_at).getTime()}:${row.file}`, + task_id: `scrum_review:${row.file}`, + timestamp: row.reviewed_at, + schema_version: EVIDENCE_SCHEMA_VERSION, + provenance: provFor(`${ROOT}/data/_kb/scrum_reviews.jsonl`, lineNo), + model_name: row.accepted_model, + model_role: "executor" as ModelRole, + source_files: [row.file], + success_markers: row.accepted_on_attempt ? [`accepted_on_attempt_${row.accepted_on_attempt}`] : undefined, + text: row.suggestions_preview, + }), + }, + { + source_file: `${ROOT}/data/_kb/observer_escalations.jsonl`, + transform: (row: any, lineNo: number) => ({ + run_id: `obs_esc:${new Date(row.ts).getTime()}:${row.sig_hash}`, + task_id: `observer_escalation:${row.cluster_endpoint ?? "?"}`, + timestamp: row.ts, + schema_version: EVIDENCE_SCHEMA_VERSION, + provenance: provFor(`${ROOT}/data/_kb/observer_escalations.jsonl`, lineNo, row.sig_hash), + model_role: "reviewer" as ModelRole, + prompt_tokens: row.prompt_tokens, + completion_tokens: row.completion_tokens, + text: row.analysis, + }), + }, + { + source_file: `${ROOT}/data/_kb/audit_facts.jsonl`, + transform: (row: any, lineNo: number) => ({ + run_id: `audit_facts:${row.head_sha}:${lineNo}`, + task_id: `pr:${row.pr_number}`, + timestamp: row.extracted_at, + schema_version: EVIDENCE_SCHEMA_VERSION, + provenance: provFor(`${ROOT}/data/_kb/audit_facts.jsonl`, lineNo), + model_name: row.extractor, + model_role: "extractor" as ModelRole, + // facts/entities/relationships go into text as a JSON dump for now; + // structured handling lives in Phase 2 where we map to specific + // EvidenceRecord substructures. + text: JSON.stringify({ + facts: row.facts?.length ?? 0, + entities: row.entities?.length ?? 0, + relationships: row.relationships?.length ?? 0, + }), + }), + }, +]; + +interface ProbeResult { + source_file: string; + rows_attempted: number; + rows_present: boolean; + passed: number; + failed: number; + failure_reasons: string[]; // unique error strings, top 5 +} + +const RESULTS: ProbeResult[] = []; + +for (const probe of PROBES) { + const sourceLabel = probe.source_file.replace(`${ROOT}/`, ""); + + test(`real-data: ${sourceLabel}`, () => { + const result: ProbeResult = { + source_file: sourceLabel, + rows_attempted: 0, + rows_present: false, + passed: 0, + failed: 0, + failure_reasons: [], + }; + + if (!existsSync(probe.source_file)) { + RESULTS.push(result); + // Skip silently — fresh clones won't have these files + return; + } + + result.rows_present = true; + const lines = readFileSync(probe.source_file, "utf8").split("\n").filter(Boolean).slice(0, SAMPLE_PER_SOURCE); + const reasons = new Set(); + + for (let i = 0; i < lines.length; i++) { + result.rows_attempted++; + let row: unknown; + try { row = JSON.parse(lines[i]); } + catch { continue; } + + const transformed = probe.transform(row, i); + if (!transformed) continue; + + const v = validateEvidenceRecord(transformed); + if (v.valid) result.passed++; + else { + result.failed++; + for (const e of v.errors) reasons.add(e); + } + } + result.failure_reasons = Array.from(reasons).slice(0, 5); + RESULTS.push(result); + + // Test passes as long as we attempted something and got a result. + // Per-source pass/fail counts are reported in the markdown writeup. + expect(result.rows_attempted).toBeGreaterThanOrEqual(0); + }); +} + +test("real-data: emit markdown report", () => { + const md: string[] = []; + md.push("# Real-data validation report"); + md.push(""); + md.push("Schema = EvidenceRecord v" + EVIDENCE_SCHEMA_VERSION + ". Sample = first " + SAMPLE_PER_SOURCE + " rows per source."); + md.push(""); + md.push("| Source | Present | Rows | Pass | Fail | Pass% |"); + md.push("|---|---|---|---|---|---|"); + for (const r of RESULTS) { + const pct = r.rows_attempted > 0 ? Math.round(100 * r.passed / r.rows_attempted) + "%" : "—"; + md.push(`| ${r.source_file} | ${r.rows_present ? "✓" : "—"} | ${r.rows_attempted} | ${r.passed} | ${r.failed} | ${pct} |`); + } + md.push(""); + let hasFailures = false; + for (const r of RESULTS) { + if (r.failed > 0) { + hasFailures = true; + md.push(`## Failures in ${r.source_file}`); + for (const reason of r.failure_reasons) md.push(`- \`${reason}\``); + md.push(""); + } + } + if (!hasFailures) { + md.push("**No failures across all probed sources.** Every materialized record validates against EvidenceRecord v1."); + md.push(""); + } + // Stale extraction probe: explicit pass/fail + const distilledFacts = RESULTS.find(r => r.source_file.endsWith("distilled_facts.jsonl")); + const distilledProc = RESULTS.find(r => r.source_file.endsWith("distilled_procedures.jsonl")); + md.push("## Stale-extraction probe"); + md.push(""); + if (distilledFacts && distilledFacts.rows_present && distilledFacts.passed > 0) { + md.push(`- **distilled_facts.jsonl:** ${distilledFacts.passed}/${distilledFacts.rows_attempted} materialize cleanly. Stream is alive at the schema level.`); + } else if (distilledFacts && !distilledFacts.rows_present) { + md.push(`- **distilled_facts.jsonl:** missing — stale or never produced. Phase 2 sources from live streams instead.`); + } else { + md.push(`- **distilled_facts.jsonl:** present but materialization failures; treat as suspect, prefer mode_experiments + scrum_reviews.`); + } + if (distilledProc && distilledProc.rows_present && distilledProc.passed > 0) { + md.push(`- **distilled_procedures.jsonl:** ${distilledProc.passed}/${distilledProc.rows_attempted} materialize cleanly.`); + } + md.push(""); + + // Write the markdown to a stable path and stdout + const out = md.join("\n"); + Bun.write(`${ROOT}/data/_kb/realdata_validation_report.md`, out); + console.log("\n" + out); +}); diff --git a/auditor/schemas/distillation/receipt.ts b/auditor/schemas/distillation/receipt.ts new file mode 100644 index 0000000..74f574d --- /dev/null +++ b/auditor/schemas/distillation/receipt.ts @@ -0,0 +1,111 @@ +// Receipt — per-pipeline-stage record with everything needed to +// reproduce the run. Spec non-negotiable: substantive receipts, not +// "ran successfully". Every field below has a deterministic source so +// the receipt schema validator catches "I forgot to fill it in" the +// same way it catches type errors. +import { + ValidationResult, requireString, requireNumber, requireIsoTimestamp, +} from "./types"; + +export const RECEIPT_SCHEMA_VERSION = 1; + +export interface FileReference { + path: string; // relative to repo root + sha256: string; // hex + bytes?: number; // optional but recommended +} + +export interface Receipt { + schema_version: number; + command: string; // shell-line or script identifier + git_sha: string; // 40-char hex (full SHA1) + git_branch?: string; + git_dirty?: boolean; // true if working tree had uncommitted changes + started_at: string; // ISO 8601 + ended_at: string; // ISO 8601 + duration_ms: number; + input_files: FileReference[]; + output_files: FileReference[]; + record_counts: { + in: number; + out: number; + [key: string]: number; // per-stage extras (filtered, dropped, etc.) + }; + validation_pass: boolean; // explicit — never inferred + errors: string[]; + warnings: string[]; +} + +function validateFileRef(v: unknown, field: string, errors: string[]): boolean { + if (typeof v !== "object" || v === null) { + errors.push(`${field}: expected object`); + return false; + } + const f = v as Record; + let ok = true; + ok = requireString(f.path, `${field}.path`, errors) && ok; + if (typeof f.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(f.sha256)) { + errors.push(`${field}.sha256: must be hex sha256`); + ok = false; + } + if (f.bytes !== undefined && typeof f.bytes !== "number") { + errors.push(`${field}.bytes: expected number when present`); + ok = false; + } + return ok; +} + +export function validateReceipt(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) { + return { valid: false, errors: ["expected object"] }; + } + const r = input as Record; + let ok = true; + + if (r.schema_version !== RECEIPT_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${RECEIPT_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.command, "command", errors) && ok; + if (typeof r.git_sha !== "string" || !/^[0-9a-f]{40}$/.test(r.git_sha as string)) { + errors.push("git_sha: must be 40-char hex"); + ok = false; + } + ok = requireIsoTimestamp(r.started_at, "started_at", errors) && ok; + ok = requireIsoTimestamp(r.ended_at, "ended_at", errors) && ok; + ok = requireNumber(r.duration_ms, "duration_ms", errors) && ok; + if (typeof r.validation_pass !== "boolean") { + errors.push("validation_pass: must be boolean (explicit, never inferred)"); + ok = false; + } + if (!Array.isArray(r.input_files)) { + errors.push("input_files: expected array"); + ok = false; + } else { + for (let i = 0; i < r.input_files.length; i++) { + if (!validateFileRef(r.input_files[i], `input_files[${i}]`, errors)) ok = false; + } + } + if (!Array.isArray(r.output_files)) { + errors.push("output_files: expected array"); + ok = false; + } else { + for (let i = 0; i < r.output_files.length; i++) { + if (!validateFileRef(r.output_files[i], `output_files[${i}]`, errors)) ok = false; + } + } + if (typeof r.record_counts !== "object" || r.record_counts === null) { + errors.push("record_counts: expected object"); + ok = false; + } else { + const rc = r.record_counts as Record; + if (typeof rc.in !== "number") { errors.push("record_counts.in: expected number"); ok = false; } + if (typeof rc.out !== "number") { errors.push("record_counts.out: expected number"); ok = false; } + } + if (!Array.isArray(r.errors)) { errors.push("errors: expected array"); ok = false; } + if (!Array.isArray(r.warnings)) { errors.push("warnings: expected array"); ok = false; } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as Receipt }; +} diff --git a/auditor/schemas/distillation/run_summary.ts b/auditor/schemas/distillation/run_summary.ts new file mode 100644 index 0000000..94c3d81 --- /dev/null +++ b/auditor/schemas/distillation/run_summary.ts @@ -0,0 +1,90 @@ +// run_summary.ts — aggregates StageReceipt rows for one run_id. +// Spec field set: total records processed, total accepted/rejected/ +// quarantined, dataset sizes, validation status, overall hash of run. + +import { + ValidationResult, requireString, requireNumber, requireIsoTimestamp, requireSha256, +} from "./types"; +import type { StageName } from "./stage_receipt"; + +export const RUN_SUMMARY_SCHEMA_VERSION = 1; + +export interface RunStageSummary { + stage: StageName; + records_in: number; + records_out: number; + accepted: number; + rejected: number; + quarantined: number; + skipped: number; + passed: boolean; + duration_ms: number; + output_hash: string; +} + +export interface RunSummary { + schema_version: number; + run_id: string; + started_at: string; // earliest stage timestamp + ended_at: string; // latest stage timestamp + duration + git_commit: string; + stages: RunStageSummary[]; + // Aggregates across stages + total_records_in: number; + total_records_out: number; + total_accepted: number; + total_rejected: number; + total_quarantined: number; + total_skipped: number; + // Dataset sizes — final outputs of each export stage + rag_records: number; + sft_records: number; + preference_pairs: number; + // Pipeline-wide pass = AND of every stage validation.passed + overall_passed: boolean; + // Run-wide hash: sha256 over each stage's output hash, sorted by stage name. + // Detects ANY change in any stage output across runs. + run_hash: string; + total_duration_ms: number; +} + +export function validateRunSummary(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) { + return { valid: false, errors: ["expected object"] }; + } + const r = input as Record; + let ok = true; + + if (r.schema_version !== RUN_SUMMARY_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${RUN_SUMMARY_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.run_id, "run_id", errors) && ok; + ok = requireIsoTimestamp(r.started_at, "started_at", errors) && ok; + ok = requireIsoTimestamp(r.ended_at, "ended_at", errors) && ok; + if (typeof r.git_commit !== "string" || !/^[0-9a-f]{40}$/.test(r.git_commit as string)) { + errors.push("git_commit: must be 40-char hex"); + ok = false; + } + if (typeof r.overall_passed !== "boolean") { + errors.push("overall_passed: must be boolean"); + ok = false; + } + ok = requireSha256(r.run_hash, "run_hash", errors) && ok; + for (const k of ["total_records_in", "total_records_out", "total_accepted", "total_rejected", + "total_quarantined", "total_skipped", "rag_records", "sft_records", + "preference_pairs", "total_duration_ms"]) { + if (typeof (r as any)[k] !== "number") { + errors.push(`${k}: expected number`); + ok = false; + } + } + if (!Array.isArray(r.stages)) { + errors.push("stages: expected array"); + ok = false; + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as RunSummary }; +} diff --git a/auditor/schemas/distillation/schemas.test.ts b/auditor/schemas/distillation/schemas.test.ts new file mode 100644 index 0000000..59a6b6e --- /dev/null +++ b/auditor/schemas/distillation/schemas.test.ts @@ -0,0 +1,367 @@ +// Combined schema tests for ScoredRun, Receipt, Playbook, +// ScratchpadSummary, ModelLedgerEntry, RagSample, SftSample, +// PreferenceSample. EvidenceRecord lives in its own file because it's +// the foundational schema and warrants the JSON-fixture round-trip +// pattern; the rest use inline fixture makers since they're simpler. +// +// Each schema: 1 positive fixture + 4-5 negative cases pinning the +// non-negotiable invariants from now.md. +// +// Run: bun test auditor/schemas/distillation/schemas.test.ts + +import { test, expect } from "bun:test"; + +import { validateScoredRun, SCORED_RUN_SCHEMA_VERSION } from "./scored_run"; +import { validateReceipt, RECEIPT_SCHEMA_VERSION } from "./receipt"; +import { validatePlaybook, PLAYBOOK_SCHEMA_VERSION } from "./playbook"; +import { validateScratchpadSummary, SCRATCHPAD_SCHEMA_VERSION } from "./scratchpad_summary"; +import { validateModelLedgerEntry, MODEL_LEDGER_SCHEMA_VERSION } from "./model_ledger"; +import { validateRagSample, RAG_SAMPLE_SCHEMA_VERSION } from "./rag_sample"; +import { validateSftSample, SFT_SAMPLE_SCHEMA_VERSION } from "./sft_sample"; +import { validatePreferenceSample, PREFERENCE_SAMPLE_SCHEMA_VERSION } from "./preference_sample"; + +const NOW = "2026-04-26T22:30:00.000Z"; +const SHA = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; +const GIT_SHA = "f753e11157eef753e11157eef753e11157eef753"; + +const PROVENANCE = { + source_file: "data/_kb/scored_runs.jsonl", + line_offset: 0, + sig_hash: SHA, + recorded_at: NOW, +}; + +// ─── ScoredRun ─────────────────────────────────────────────────────── + +const SCORED_RUN_OK = { + schema_version: SCORED_RUN_SCHEMA_VERSION, + evidence_run_id: "run-abc", + evidence_task_id: "task-abc", + category: "accepted", + reasons: ["cargo_green=true", "anchor_grounding=0.95"], + scored_at: NOW, + scorer_version: "v1.0.0", + sub_scores: { cargo_green: true, anchor_grounding: 0.95 }, + provenance: PROVENANCE, +}; + +test("ScoredRun: positive validates", () => { + const r = validateScoredRun(SCORED_RUN_OK); + if (!r.valid) console.error(r.errors); + expect(r.valid).toBe(true); +}); + +test("ScoredRun: empty reasons rejected (every score needs a reason)", () => { + const r = validateScoredRun({ ...SCORED_RUN_OK, reasons: [] }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("reasons"))).toBe(true); +}); + +test("ScoredRun: invalid category rejected", () => { + const r = validateScoredRun({ ...SCORED_RUN_OK, category: "maybe_ok" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("category"))).toBe(true); +}); + +test("ScoredRun: anchor_grounding > 1 rejected (must be in [0, 1])", () => { + const r = validateScoredRun({ ...SCORED_RUN_OK, sub_scores: { ...SCORED_RUN_OK.sub_scores, anchor_grounding: 1.5 } }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("anchor_grounding"))).toBe(true); +}); + +// ─── Receipt ───────────────────────────────────────────────────────── + +const RECEIPT_OK = { + schema_version: RECEIPT_SCHEMA_VERSION, + command: "bun run scripts/build_evidence_index.ts", + git_sha: GIT_SHA, + git_branch: "scrum/auto-apply-19814", + git_dirty: false, + started_at: NOW, + ended_at: NOW, + duration_ms: 1234, + input_files: [{ path: "data/_kb/scrum_reviews.jsonl", sha256: SHA, bytes: 448000 }], + output_files: [{ path: "data/evidence/2026/04/26/run.jsonl", sha256: SHA }], + record_counts: { in: 100, out: 95, filtered: 5 }, + validation_pass: true, + errors: [], + warnings: [], +}; + +test("Receipt: positive validates", () => { + const r = validateReceipt(RECEIPT_OK); + if (!r.valid) console.error(r.errors); + expect(r.valid).toBe(true); +}); + +test("Receipt: bad git_sha rejected (must be 40-char hex)", () => { + const r = validateReceipt({ ...RECEIPT_OK, git_sha: "abc123" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("git_sha"))).toBe(true); +}); + +test("Receipt: validation_pass must be boolean (never inferred)", () => { + const r = validateReceipt({ ...RECEIPT_OK, validation_pass: "yes" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("validation_pass"))).toBe(true); +}); + +test("Receipt: file refs without proper sha256 rejected", () => { + const r = validateReceipt({ ...RECEIPT_OK, output_files: [{ path: "x", sha256: "short" }] }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("sha256"))).toBe(true); +}); + +// ─── Playbook ──────────────────────────────────────────────────────── + +const PLAYBOOK_OK = { + schema_version: PLAYBOOK_SCHEMA_VERSION, + playbook_id: "pb-scrum-review-001", + task_type: "scrum_review", + problem_pattern: "Cargo workspace warning escalation after applier patch", + useful_context: ["pathway memory bug fingerprints for the file area"], + model_routing_path: ["x-ai/grok-4.1-fast"], + commands_worked: ["cargo check --workspace"], + commands_failed: [], + validation_steps: ["warning count must not increase"], + repo_files_touched: ["crates/queryd/src/service.rs"], + recovery_strategy: "git checkout -- file when cargo red", + known_failure_modes: ["unused import noise"], + escalation_threshold: "use kimi-k2:1t when isolation mode rejects 2 attempts", + acceptance_criteria: ["cargo green", "warning count stable", "rationale-diff aligned"], + source_run_ids: ["run-xyz", "run-abc"], + created_at: NOW, + provenance: PROVENANCE, +}; + +test("Playbook: positive validates", () => { + const r = validatePlaybook(PLAYBOOK_OK); + if (!r.valid) console.error(r.errors); + expect(r.valid).toBe(true); +}); + +test("Playbook: empty source_run_ids rejected (every playbook traces to source — spec)", () => { + const r = validatePlaybook({ ...PLAYBOOK_OK, source_run_ids: [] }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("source_run_ids"))).toBe(true); +}); + +test("Playbook: empty acceptance_criteria rejected (every playbook needs success criteria — spec)", () => { + const r = validatePlaybook({ ...PLAYBOOK_OK, acceptance_criteria: [] }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("acceptance_criteria"))).toBe(true); +}); + +// ─── ScratchpadSummary ─────────────────────────────────────────────── + +const SCRATCHPAD_OK = { + schema_version: SCRATCHPAD_SCHEMA_VERSION, + run_id: "run-abc", + current_objective: "verify pr_audit mode end-to-end", + completed_steps: ["restart gateway"], + failed_steps: ["cloud chat returned 500"], + pending_steps: ["swap default model"], + important_paths: ["auditor/checks/inference.ts"], + decisions: ["defer kimi-k2 swap until upstream returns"], + unresolved_questions: ["does deepseek match kimi quality?"], + validation_status: "partial", + next_command: "bun run auditor/audit_one.ts 11", + source_scratchpad_hash: SHA, + summarized_at: NOW, + provenance: PROVENANCE, +}; + +test("ScratchpadSummary: positive validates", () => { + const r = validateScratchpadSummary(SCRATCHPAD_OK); + if (!r.valid) console.error(r.errors); + expect(r.valid).toBe(true); +}); + +test("ScratchpadSummary: invalid validation_status rejected", () => { + const r = validateScratchpadSummary({ ...SCRATCHPAD_OK, validation_status: "tbd" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("validation_status"))).toBe(true); +}); + +test("ScratchpadSummary: short scratchpad_hash rejected", () => { + const r = validateScratchpadSummary({ ...SCRATCHPAD_OK, source_scratchpad_hash: "short" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("source_scratchpad_hash"))).toBe(true); +}); + +// ─── ModelLedgerEntry ──────────────────────────────────────────────── + +const LEDGER_OK = { + schema_version: MODEL_LEDGER_SCHEMA_VERSION, + model_name: "kimi-k2:1t", + model_provider: "ollama_cloud", + task_type: "pr_audit", + success_rate: 0.85, + failure_modes: ["upstream_500", "context_truncation"], + best_partner_model: "x-ai/grok-4.1-fast", + escalation_role: "primary", + cost_usd_p50: 0.0002, + latency_ms_p50: 50000, + latency_ms_p95: 90000, + context_window: 200000, + sample_count: 47, + last_updated: NOW, +}; + +test("ModelLedgerEntry: positive validates", () => { + const r = validateModelLedgerEntry(LEDGER_OK); + if (!r.valid) console.error(r.errors); + expect(r.valid).toBe(true); +}); + +test("ModelLedgerEntry: success_rate > 1 rejected", () => { + const r = validateModelLedgerEntry({ ...LEDGER_OK, success_rate: 1.5 }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("success_rate"))).toBe(true); +}); + +test("ModelLedgerEntry: zero sample_count rejected (no aggregate from zero)", () => { + const r = validateModelLedgerEntry({ ...LEDGER_OK, sample_count: 0 }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("sample_count"))).toBe(true); +}); + +// ─── RagSample ─────────────────────────────────────────────────────── + +const RAG_OK = { + schema_version: RAG_SAMPLE_SCHEMA_VERSION, + id: "rag-pb-001", + title: "Scrum applier rationale-diff alignment", + content: "When the applier emits a patch with rationale claiming X but the diff shows Y, the rationale-token alignment gate catches it...", + tags: ["scrum_review", "applier"], + source_run_id: "run-xyz", + success_score: "accepted", + source_category: "accepted", + embedding_text: "applier rationale-diff alignment guard scrum", + created_at: NOW, + provenance: PROVENANCE, +}; + +test("RagSample: positive validates", () => { + const r = validateRagSample(RAG_OK); + if (!r.valid) console.error(r.errors); + expect(r.valid).toBe(true); +}); + +test("RagSample: success_score=rejected forbidden (RAG never takes rejected)", () => { + const r = validateRagSample({ ...RAG_OK, success_score: "rejected", source_category: "rejected" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("success_score"))).toBe(true); +}); + +test("RagSample: success_score and source_category must match", () => { + const r = validateRagSample({ ...RAG_OK, success_score: "accepted", source_category: "partially_accepted" }); + expect(r.valid).toBe(false); +}); + +test("RagSample: whitespace-only content rejected", () => { + const r = validateRagSample({ ...RAG_OK, content: " \n " }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("content"))).toBe(true); +}); + +// ─── SftSample (the strict one) ────────────────────────────────────── + +const SFT_OK = { + schema_version: SFT_SAMPLE_SCHEMA_VERSION, + id: "sft-pr11-001", + instruction: "Audit this PR diff against ship-claims.", + context: "claims: 3 strong, 2 moderate", + response: "{\"claim_verdicts\": [...]}", + source_run_id: "run-pr11", + quality_score: "accepted", + created_at: NOW, + provenance: PROVENANCE, +}; + +test("SftSample: positive validates", () => { + const r = validateSftSample(SFT_OK); + if (!r.valid) console.error(r.errors); + expect(r.valid).toBe(true); +}); + +test("SftSample: quality_score=partially_accepted ACCEPTED (--include-partial path)", () => { + // Phase 4 update: partial allowed at schema layer; CLI gate decides. + const r = validateSftSample({ ...SFT_OK, quality_score: "partially_accepted" }); + expect(r.valid).toBe(true); +}); + +test("SftSample: quality_score=rejected REJECTED (spec non-negotiable, no leak)", () => { + const r = validateSftSample({ ...SFT_OK, quality_score: "rejected" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("quality_score"))).toBe(true); +}); + +test("SftSample: quality_score=needs_human_review REJECTED (no leak)", () => { + const r = validateSftSample({ ...SFT_OK, quality_score: "needs_human_review" }); + expect(r.valid).toBe(false); +}); + +test("SftSample: missing context rejected (must be string, even if empty)", () => { + const fixture: Record = { ...SFT_OK }; + delete fixture.context; + const r = validateSftSample(fixture); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("context"))).toBe(true); +}); + +test("SftSample: empty-string context allowed", () => { + const r = validateSftSample({ ...SFT_OK, context: "" }); + expect(r.valid).toBe(true); +}); + +test("SftSample: empty response rejected (no empty pairs)", () => { + const r = validateSftSample({ ...SFT_OK, response: "" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("response"))).toBe(true); +}); + +test("SftSample: whitespace-only instruction rejected", () => { + const r = validateSftSample({ ...SFT_OK, instruction: " \t\n " }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("instruction"))).toBe(true); +}); + +// ─── PreferenceSample ──────────────────────────────────────────────── + +const PREF_OK = { + schema_version: PREFERENCE_SAMPLE_SCHEMA_VERSION, + id: "pref-task-x-001", + prompt: "Verify claim: 'all 3 services running on matrix-test'", + chosen: "{\"backed\": true, \"evidence\": \"systemctl status confirms 3 active\"}", + rejected: "{\"backed\": true, \"evidence\": \"the README says so\"}", + reason: "chosen cites runtime evidence, rejected cites doc claim only", + chosen_run_id: "run-A", + rejected_run_id: "run-B", + created_at: NOW, + provenance: PROVENANCE, +}; + +test("PreferenceSample: positive validates", () => { + const r = validatePreferenceSample(PREF_OK); + if (!r.valid) console.error(r.errors); + expect(r.valid).toBe(true); +}); + +test("PreferenceSample: chosen == rejected rejected (no self-pairing)", () => { + const r = validatePreferenceSample({ ...PREF_OK, chosen: "x", rejected: "x" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("chosen and rejected"))).toBe(true); +}); + +test("PreferenceSample: chosen_run_id == rejected_run_id rejected (no self-disagreement)", () => { + const r = validatePreferenceSample({ ...PREF_OK, chosen_run_id: "run-A", rejected_run_id: "run-A" }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("chosen_run_id"))).toBe(true); +}); + +test("PreferenceSample: empty reason rejected (every preference needs WHY)", () => { + const r = validatePreferenceSample({ ...PREF_OK, reason: " " }); + expect(r.valid).toBe(false); + if (!r.valid) expect(r.errors.some(e => e.includes("reason"))).toBe(true); +}); diff --git a/auditor/schemas/distillation/scored_run.ts b/auditor/schemas/distillation/scored_run.ts new file mode 100644 index 0000000..939e9e6 --- /dev/null +++ b/auditor/schemas/distillation/scored_run.ts @@ -0,0 +1,86 @@ +// ScoredRun — output of the deterministic Success Scorer (Phase 3). +// Spec mandates 4 categories with explicit reasons; we add scorer +// versioning so a future scorer change is detectable in historical data. +import { + ValidationResult, requireString, requireIsoTimestamp, requireProvenance, requireStringArray, requireNumber, +} from "./types"; + +export const SCORED_RUN_SCHEMA_VERSION = 1; +export const SCORE_CATEGORIES = ["accepted", "partially_accepted", "rejected", "needs_human_review"] as const; +export type ScoreCategory = (typeof SCORE_CATEGORIES)[number]; + +export interface ScoredRun { + schema_version: number; + evidence_run_id: string; // FK to EvidenceRecord.run_id + evidence_task_id: string; // FK to EvidenceRecord.task_id + category: ScoreCategory; + reasons: string[]; // human-readable, e.g. ["cargo_green=true", "anchor_grounding<0.7"] + scored_at: string; // ISO 8601 + scorer_version: string; // e.g. "v1.0.0" — bumped on scorer code change + // Sub-scores that the scorer collapsed into the category. Persisted + // so a downstream UI can show "why" without re-running the scorer. + sub_scores?: { + cargo_green?: boolean; + anchor_grounding?: number; + schema_valid?: boolean; + pathway_replay_succeeded?: boolean; + observer_verdict?: "accept" | "reject" | "cycle"; + [key: string]: unknown; + }; + provenance: { + source_file: string; + line_offset?: number; + sig_hash: string; + recorded_at: string; + }; +} + +export function validateScoredRun(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) { + return { valid: false, errors: ["expected object"] }; + } + const r = input as Record; + let ok = true; + if (r.schema_version !== SCORED_RUN_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${SCORED_RUN_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.evidence_run_id, "evidence_run_id", errors) && ok; + ok = requireString(r.evidence_task_id, "evidence_task_id", errors) && ok; + ok = requireIsoTimestamp(r.scored_at, "scored_at", errors) && ok; + ok = requireString(r.scorer_version, "scorer_version", errors) && ok; + ok = requireStringArray(r.reasons, "reasons", errors) && ok; + if (Array.isArray(r.reasons) && r.reasons.length === 0) { + errors.push("reasons: must be non-empty (every score must have at least one reason)"); + ok = false; + } + if (!SCORE_CATEGORIES.includes(r.category as ScoreCategory)) { + errors.push(`category: must be one of ${SCORE_CATEGORIES.join("|")}, got ${JSON.stringify(r.category)}`); + ok = false; + } + ok = requireProvenance(r.provenance, "provenance", errors) && ok; + + if (r.sub_scores !== undefined) { + if (typeof r.sub_scores !== "object" || r.sub_scores === null) { + errors.push("sub_scores: expected object when present"); + ok = false; + } else { + const ss = r.sub_scores as Record; + if (ss.anchor_grounding !== undefined) { + if (!requireNumber(ss.anchor_grounding, "sub_scores.anchor_grounding", errors)) ok = false; + else if ((ss.anchor_grounding as number) < 0 || (ss.anchor_grounding as number) > 1) { + errors.push("sub_scores.anchor_grounding: must be in [0, 1]"); + ok = false; + } + } + if (ss.observer_verdict !== undefined && !["accept", "reject", "cycle"].includes(ss.observer_verdict as string)) { + errors.push("sub_scores.observer_verdict: must be accept|reject|cycle"); + ok = false; + } + } + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as ScoredRun }; +} diff --git a/auditor/schemas/distillation/scratchpad_summary.ts b/auditor/schemas/distillation/scratchpad_summary.ts new file mode 100644 index 0000000..f10abe1 --- /dev/null +++ b/auditor/schemas/distillation/scratchpad_summary.ts @@ -0,0 +1,65 @@ +// ScratchpadSummary — structured normalization of a tree-split or +// long-running scratchpad. Distinct from EvidenceRecord because a +// scratchpad accumulates across many calls; this schema captures the +// state at a checkpoint moment. +import { + ValidationResult, requireString, requireIsoTimestamp, requireProvenance, requireStringArray, +} from "./types"; + +export const SCRATCHPAD_SCHEMA_VERSION = 1; + +export interface ScratchpadSummary { + schema_version: number; + run_id: string; + current_objective: string; + completed_steps: string[]; + failed_steps: string[]; + pending_steps: string[]; + important_paths: string[]; // file paths the scratchpad references + decisions: string[]; // architectural/scope decisions made + unresolved_questions: string[]; + validation_status: "pass" | "fail" | "partial" | "pending"; + next_command?: string; // recommendation for next action + source_scratchpad_hash: string; // sha256 of the full source scratchpad text — diff detection + summarized_at: string; // ISO 8601 + provenance: { source_file: string; line_offset?: number; sig_hash: string; recorded_at: string }; +} + +const STATUS = ["pass", "fail", "partial", "pending"]; + +export function validateScratchpadSummary(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) return { valid: false, errors: ["expected object"] }; + const r = input as Record; + let ok = true; + + if (r.schema_version !== SCRATCHPAD_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${SCRATCHPAD_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.run_id, "run_id", errors) && ok; + ok = requireString(r.current_objective, "current_objective", errors) && ok; + ok = requireIsoTimestamp(r.summarized_at, "summarized_at", errors) && ok; + if (typeof r.source_scratchpad_hash !== "string" || !/^[0-9a-f]{64}$/.test(r.source_scratchpad_hash as string)) { + errors.push("source_scratchpad_hash: must be hex sha256"); + ok = false; + } + ok = requireStringArray(r.completed_steps, "completed_steps", errors) && ok; + ok = requireStringArray(r.failed_steps, "failed_steps", errors) && ok; + ok = requireStringArray(r.pending_steps, "pending_steps", errors) && ok; + ok = requireStringArray(r.important_paths, "important_paths", errors) && ok; + ok = requireStringArray(r.decisions, "decisions", errors) && ok; + ok = requireStringArray(r.unresolved_questions, "unresolved_questions", errors) && ok; + if (!STATUS.includes(r.validation_status as string)) { + errors.push(`validation_status: must be one of ${STATUS.join("|")}`); + ok = false; + } + if (r.next_command !== undefined && typeof r.next_command !== "string") { + errors.push("next_command: expected string when present"); + ok = false; + } + ok = requireProvenance(r.provenance, "provenance", errors) && ok; + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as ScratchpadSummary }; +} diff --git a/auditor/schemas/distillation/sft_sample.ts b/auditor/schemas/distillation/sft_sample.ts new file mode 100644 index 0000000..6c109c2 --- /dev/null +++ b/auditor/schemas/distillation/sft_sample.ts @@ -0,0 +1,69 @@ +// SftSample — entry in exports/sft/instruction_response.jsonl. Spec +// non-negotiable: ONLY accepted runs, never partial/rejected/needs_human. +// Validator enforces that invariant — exporters can't bypass. +import { + ValidationResult, requireString, requireIsoTimestamp, requireProvenance, requireNumber, +} from "./types"; + +export const SFT_SAMPLE_SCHEMA_VERSION = 1; + +// SFT default: only `accepted` ships. With --include-partial CLI flag, +// `partially_accepted` becomes legal. `rejected` and `needs_human_review` +// NEVER ship to SFT — that's the contamination firewall. +export const SFT_QUALITY_SCORES = ["accepted", "partially_accepted"] as const; +export type SftQualityScore = (typeof SFT_QUALITY_SCORES)[number]; + +export interface SftSample { + schema_version: number; + id: string; + instruction: string; // the prompt / user message + context: string; // retrieved context that was visible (empty string allowed; null/undefined not) + response: string; // the model output that was accepted + source_run_id: string; + quality_score: SftQualityScore; + created_at: string; + provenance: { source_file: string; line_offset?: number; sig_hash: string; recorded_at: string }; +} + +export function validateSftSample(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) return { valid: false, errors: ["expected object"] }; + const r = input as Record; + let ok = true; + + if (r.schema_version !== SFT_SAMPLE_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${SFT_SAMPLE_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.id, "id", errors) && ok; + ok = requireString(r.instruction, "instruction", errors) && ok; + ok = requireString(r.response, "response", errors) && ok; + ok = requireString(r.source_run_id, "source_run_id", errors) && ok; + ok = requireIsoTimestamp(r.created_at, "created_at", errors) && ok; + ok = requireProvenance(r.provenance, "provenance", errors) && ok; + + // Empty pair guard. + if (typeof r.instruction === "string" && (r.instruction as string).trim().length === 0) { + errors.push("instruction: must be non-whitespace (no empty pairs)"); + ok = false; + } + if (typeof r.response === "string" && (r.response as string).trim().length === 0) { + errors.push("response: must be non-whitespace (no empty pairs)"); + ok = false; + } + // Context is required-string but empty is allowed (some SFT samples + // are pure instruction→response with no retrieval context). + if (typeof r.context !== "string") { + errors.push("context: expected string (use empty string for no-context samples)"); + ok = false; + } + // The non-negotiable: SFT samples MUST have quality_score in + // SFT_QUALITY_SCORES. Anything else is a leak. + if (!SFT_QUALITY_SCORES.includes(r.quality_score as SftQualityScore)) { + errors.push(`quality_score: must be one of ${SFT_QUALITY_SCORES.join("|")} (no rejected/needs_human leak into SFT — spec non-negotiable). Got ${JSON.stringify(r.quality_score)}`); + ok = false; + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as SftSample }; +} diff --git a/auditor/schemas/distillation/stage_receipt.ts b/auditor/schemas/distillation/stage_receipt.ts new file mode 100644 index 0000000..6154108 --- /dev/null +++ b/auditor/schemas/distillation/stage_receipt.ts @@ -0,0 +1,190 @@ +// stage_receipt.ts — forensic-grade per-stage receipt. +// +// Distinct from auditor/schemas/distillation/receipt.ts (Phase 1): +// - Phase 1 Receipt is per-script invocation, format inherited from +// the early auditor wiring +// - StageReceipt (THIS file) matches the now.md Phase 5 spec exactly +// and is the canonical artifact for pipeline observability +// +// Every pipeline stage (collect, score, export-rag, export-sft, +// export-preference, future extract-playbooks/index) emits ONE +// StageReceipt per run. Receipts are joined by `run_id` (shared +// across all stages of a single `run-all` invocation) so a future +// query can aggregate across the whole pipeline. + +import { + ValidationResult, requireString, requireNumber, requireIsoTimestamp, requireSha256, + requireStringArray, +} from "./types"; + +export const STAGE_RECEIPT_SCHEMA_VERSION = 1; + +export const STAGE_NAMES = [ + "collect", // build_evidence_index — materialize source jsonls → EvidenceRecord + "score", // score_runs — EvidenceRecord → ScoredRun + "export-rag", // exports/rag/playbooks.jsonl + "export-sft", // exports/sft/instruction_response.jsonl + "export-preference",// exports/preference/chosen_rejected.jsonl + // Reserved for future stages — accept them in the schema so a stage + // can be added without bumping schema_version. + "extract-playbooks", + "index", +] as const; +export type StageName = (typeof STAGE_NAMES)[number]; + +export interface StageFileRef { + path: string; // relative to repo root + sha256: string; // 64-char hex + bytes?: number; + record_count?: number; // line count for jsonl, when meaningful +} + +export interface StageIO { + files: StageFileRef[]; + record_count: number; + hash: string; // 64-char hex — aggregate over all file hashes (sorted) +} + +export interface StageStats { + accepted: number; // rows that ended up in the stage's output + rejected: number; // explicit category=rejected (Score), invalid pairs (Preference), etc. + quarantined: number; // routed to exports/quarantine/* with structured reason + skipped: number; // parse failures, schema violations at write time +} + +export interface StageValidation { + passed: boolean; // explicit boolean — never inferred (spec non-negotiable) + errors: string[]; + warnings: string[]; +} + +export interface StageReceipt { + schema_version: number; + run_id: string; // shared across all stages of one pipeline run + stage: StageName; + timestamp: string; // ISO 8601 — stage start + git_commit: string; // 40-char hex + inputs: StageIO; + outputs: StageIO; + stats: StageStats; + validation: StageValidation; + duration_ms: number; +} + +function validateStageIO(v: unknown, field: string, errors: string[]): boolean { + if (typeof v !== "object" || v === null) { + errors.push(`${field}: expected object`); + return false; + } + const io = v as Record; + let ok = true; + if (!Array.isArray(io.files)) { + errors.push(`${field}.files: expected array`); + ok = false; + } else { + for (let i = 0; i < io.files.length; i++) { + const f = io.files[i] as Record; + if (typeof f !== "object" || f === null) { + errors.push(`${field}.files[${i}]: expected object`); + ok = false; + continue; + } + ok = requireString(f.path, `${field}.files[${i}].path`, errors) && ok; + ok = requireSha256(f.sha256, `${field}.files[${i}].sha256`, errors) && ok; + if (f.bytes !== undefined && typeof f.bytes !== "number") { + errors.push(`${field}.files[${i}].bytes: expected number when present`); + ok = false; + } + if (f.record_count !== undefined && typeof f.record_count !== "number") { + errors.push(`${field}.files[${i}].record_count: expected number when present`); + ok = false; + } + } + } + ok = requireNumber(io.record_count, `${field}.record_count`, errors) && ok; + ok = requireSha256(io.hash, `${field}.hash`, errors) && ok; + return ok; +} + +export function validateStageReceipt(input: unknown): ValidationResult { + const errors: string[] = []; + if (typeof input !== "object" || input === null) { + return { valid: false, errors: ["expected object"] }; + } + const r = input as Record; + let ok = true; + + if (r.schema_version !== STAGE_RECEIPT_SCHEMA_VERSION) { + errors.push(`schema_version: expected ${STAGE_RECEIPT_SCHEMA_VERSION}, got ${JSON.stringify(r.schema_version)}`); + ok = false; + } + ok = requireString(r.run_id, "run_id", errors) && ok; + if (typeof r.run_id === "string" && r.run_id.length < 8) { + errors.push("run_id: too short — expect uuid-like"); + ok = false; + } + if (typeof r.stage !== "string" || !STAGE_NAMES.includes(r.stage as StageName)) { + errors.push(`stage: must be one of ${STAGE_NAMES.join("|")}`); + ok = false; + } + ok = requireIsoTimestamp(r.timestamp, "timestamp", errors) && ok; + if (typeof r.git_commit !== "string" || !/^[0-9a-f]{40}$/.test(r.git_commit as string)) { + errors.push("git_commit: must be 40-char hex"); + ok = false; + } + if (typeof r.duration_ms !== "number") { + errors.push("duration_ms: expected number"); + ok = false; + } + if (typeof r.inputs !== "object" || r.inputs === null) { + errors.push("inputs: expected object"); + ok = false; + } else { + ok = validateStageIO(r.inputs, "inputs", errors) && ok; + } + if (typeof r.outputs !== "object" || r.outputs === null) { + errors.push("outputs: expected object"); + ok = false; + } else { + ok = validateStageIO(r.outputs, "outputs", errors) && ok; + } + if (typeof r.stats !== "object" || r.stats === null) { + errors.push("stats: expected object"); + ok = false; + } else { + const s = r.stats as Record; + for (const k of ["accepted", "rejected", "quarantined", "skipped"]) { + if (typeof s[k] !== "number") { errors.push(`stats.${k}: expected number`); ok = false; } + } + } + if (typeof r.validation !== "object" || r.validation === null) { + errors.push("validation: expected object"); + ok = false; + } else { + const v = r.validation as Record; + if (typeof v.passed !== "boolean") { + errors.push("validation.passed: must be boolean (explicit, never inferred)"); + ok = false; + } + if (!Array.isArray(v.errors)) { errors.push("validation.errors: expected array"); ok = false; } + if (!Array.isArray(v.warnings)) { errors.push("validation.warnings: expected array"); ok = false; } + if (Array.isArray(v.errors)) ok = requireStringArray(v.errors, "validation.errors", errors) && ok; + if (Array.isArray(v.warnings)) ok = requireStringArray(v.warnings, "validation.warnings", errors) && ok; + } + + if (!ok) return { valid: false, errors }; + return { valid: true, value: r as unknown as StageReceipt }; +} + +// Compute the canonical aggregate hash over a list of file refs. +// Sorted by path so order-of-iteration doesn't drift the hash. +// Each entry contributes "||" so two +// files with identical content but different paths produce distinct +// digests (real difference = real hash difference). +export async function aggregateIoHash(files: StageFileRef[]): Promise { + const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path)); + const parts = sorted.map(f => `${f.path}|${f.sha256}|${f.record_count ?? 0}`); + const h = new Bun.CryptoHasher("sha256"); + h.update(parts.join("\n")); + return h.digest("hex"); +} diff --git a/auditor/schemas/distillation/types.ts b/auditor/schemas/distillation/types.ts new file mode 100644 index 0000000..1acc02e --- /dev/null +++ b/auditor/schemas/distillation/types.ts @@ -0,0 +1,141 @@ +// Shared types for distillation schemas. Hand-rolled validators (no Zod +// dependency) — bun:test runs them; runtime cost is one tiny function +// per record. Pattern: each schema exports `validate(x): ValidationResult` +// returning `{valid: true, value}` or `{valid: false, errors}`. +// +// Why hand-rolled: the auditor + scrum + observer pipelines emit JSONL +// rows in shapes that already work; we want to ENFORCE those shapes +// without adding a 100KB dependency or rewriting producers. The +// validators codify what we already produce. +// +// Naming: schemas live as nouns (`EvidenceRecord`), validators as +// `validate`. Each schema file exports both the type and the +// validator. + +export interface Provenance { + // Path to the JSONL or other source where this row came from. Always + // relative to /home/profit/lakehouse so receipts are reproducible + // across deploys with the same repo layout. + source_file: string; + + // Optional byte offset / line number into the source file. Lets a + // future "open the source row" UI jump directly to the line. Some + // sources (single-row JSON files like _playbook_lessons/*.json) don't + // need this. + line_offset?: number; + + // SHA-256 of the canonical JSON of the source row (sorted keys, no + // whitespace). This is the dedup key — running distillation twice on + // the same source produces identical sig_hash, so duplicates are + // detectable without full row comparison. + sig_hash: string; + + // ISO 8601 of when this provenance link was recorded — usually the + // moment the unified Evidence Index ran. Distinct from the source + // row's own timestamp, which lives on the EvidenceRecord itself. + recorded_at: string; +} + +// Returned by every schema validator. The shape is `{valid: true, value}` +// for success (so callers can use `value` with the right type narrowed) +// or `{valid: false, errors}` for failure (so callers can surface +// every error at once, not just the first). +export type ValidationResult = + | { valid: true; value: T } + | { valid: false; errors: string[] }; + +// Standard helpers used by every schema. Centralized so naming + +// error message format stay consistent across schemas. + +export function requireString(v: unknown, field: string, errors: string[]): v is string { + if (typeof v !== "string") { + errors.push(`${field}: expected string, got ${typeof v}`); + return false; + } + if (v.length === 0) { + errors.push(`${field}: must be non-empty`); + return false; + } + return true; +} + +export function requireNumber(v: unknown, field: string, errors: string[]): v is number { + if (typeof v !== "number" || !Number.isFinite(v)) { + errors.push(`${field}: expected finite number, got ${typeof v}`); + return false; + } + return true; +} + +export function requireIsoTimestamp(v: unknown, field: string, errors: string[]): v is string { + if (!requireString(v, field, errors)) return false; + // Permissive ISO 8601: YYYY-MM-DDTHH:MM:SS(.fraction)?(Z|±HH:MM)? + const re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/; + if (!re.test(v as string)) { + errors.push(`${field}: not a valid ISO 8601 timestamp: ${(v as string).slice(0, 60)}`); + return false; + } + return true; +} + +export function requireSha256(v: unknown, field: string, errors: string[]): v is string { + if (!requireString(v, field, errors)) return false; + if (!/^[0-9a-f]{64}$/.test(v as string)) { + errors.push(`${field}: not a valid hex sha256: ${(v as string).slice(0, 80)}`); + return false; + } + return true; +} + +export function requireProvenance(v: unknown, field: string, errors: string[]): v is Provenance { + if (typeof v !== "object" || v === null) { + errors.push(`${field}: expected object, got ${v === null ? "null" : typeof v}`); + return false; + } + const p = v as Record; + let ok = true; + ok = requireString(p.source_file, `${field}.source_file`, errors) && ok; + ok = requireSha256(p.sig_hash, `${field}.sig_hash`, errors) && ok; + ok = requireIsoTimestamp(p.recorded_at, `${field}.recorded_at`, errors) && ok; + if (p.line_offset !== undefined && typeof p.line_offset !== "number") { + errors.push(`${field}.line_offset: expected number when present`); + ok = false; + } + return ok; +} + +export function requireStringArray(v: unknown, field: string, errors: string[]): v is string[] { + if (!Array.isArray(v)) { + errors.push(`${field}: expected array, got ${typeof v}`); + return false; + } + for (let i = 0; i < v.length; i++) { + if (typeof v[i] !== "string") { + errors.push(`${field}[${i}]: expected string, got ${typeof v[i]}`); + return false; + } + } + return true; +} + +// Compute the canonical sha256 used for sig_hash. Sorts keys so the +// hash is stable regardless of producer's serialization order. Uses +// Bun.CryptoHasher (sync, fast) rather than node:crypto — matches the +// rest of the auditor. +export async function canonicalSha256(obj: unknown): Promise { + const ordered = orderKeys(obj); + const json = JSON.stringify(ordered); + const hasher = new Bun.CryptoHasher("sha256"); + hasher.update(json); + return hasher.digest("hex"); +} + +function orderKeys(v: unknown): unknown { + if (v === null || typeof v !== "object") return v; + if (Array.isArray(v)) return v.map(orderKeys); + const out: Record = {}; + for (const k of Object.keys(v as object).sort()) { + out[k] = orderKeys((v as Record)[k]); + } + return out; +} diff --git a/auditor/types.ts b/auditor/types.ts index 9ce7609..93f088d 100644 --- a/auditor/types.ts +++ b/auditor/types.ts @@ -2,7 +2,7 @@ // if something can't be verified from a check, it goes into `evidence` // so the verdict is inspectable, not a black box. -export type CheckKind = "static" | "dynamic" | "inference" | "kb_query"; +export type CheckKind = "static" | "dynamic" | "inference" | "kb_query" | "kimi_architect"; export type Severity = "info" | "warn" | "block"; diff --git a/bot/propose.ts b/bot/propose.ts index a66dfe3..ab7b6ca 100644 --- a/bot/propose.ts +++ b/bot/propose.ts @@ -13,7 +13,12 @@ import { readFile } from "node:fs/promises"; import { createHash } from "node:crypto"; import type { Gap, Proposal } from "./types.ts"; -const SIDECAR_URL = process.env.LH_SIDECAR_URL ?? "http://localhost:3200"; +// Phase 44 migration (2026-04-27): bot/propose.ts now flows through +// the gateway's /v1/chat instead of hitting the sidecar's /generate +// directly. /v1/usage tracks the call, Langfuse traces it, observer +// sees it. Same upstream model (CLOUD_MODEL gpt-oss:120b on +// Ollama Cloud) — gateway just owns the routing. +const GATEWAY_URL = process.env.LH_GATEWAY_URL ?? "http://localhost:3100"; const REPO_ROOT = "/home/profit/lakehouse"; const PRD_PATH = `${REPO_ROOT}/docs/PRD.md`; const CLOUD_MODEL = process.env.LH_BOT_MODEL ?? "gpt-oss:120b"; @@ -72,13 +77,16 @@ export async function generateProposal(gap: Gap, historySummary: string = ""): P sections.push("Propose a small change that addresses this gap. Respond with the JSON object only."); const userPrompt = sections.join("\n"); - const r = await fetch(`${SIDECAR_URL}/generate`, { + const r = await fetch(`${GATEWAY_URL}/v1/chat`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ model: CLOUD_MODEL, - system: SYSTEM_PROMPT, - prompt: userPrompt, + provider: "ollama_cloud", + messages: [ + { role: "system", content: SYSTEM_PROMPT }, + { role: "user", content: userPrompt }, + ], temperature: 0.2, max_tokens: MAX_TOKENS, think: false, @@ -86,10 +94,10 @@ export async function generateProposal(gap: Gap, historySummary: string = ""): P signal: AbortSignal.timeout(180000), // cloud T3 can be slow — 3 min }); if (!r.ok) { - throw new Error(`sidecar ${r.status}: ${await r.text()}`); + throw new Error(`gateway /v1/chat ${r.status}: ${await r.text()}`); } const j = await r.json() as any; - const raw: string = j.text ?? j.response ?? ""; + const raw: string = j?.choices?.[0]?.message?.content ?? ""; const usage = j.usage ?? {}; const tokens = (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0); diff --git a/config/modes.toml b/config/modes.toml new file mode 100644 index 0000000..169b4d2 --- /dev/null +++ b/config/modes.toml @@ -0,0 +1,86 @@ +# Mode router config — task_class → mode mapping +# +# `preferred_mode` is the first choice for a task class; `fallback_modes` +# get tried in order if the preferred one isn't available (LLM Team can +# return Unknown mode for some, OR the matrix has stronger signal for a +# fallback). `default_model` seeds the mode runner's model field if the +# caller doesn't override. +# +# Modes are dispatched against LLM Team UI (localhost:5000/api/run) for +# now; future Rust-native runners will short-circuit before the proxy. +# See crates/gateway/src/v1/mode.rs for the dispatch path. + +[[task_class]] +name = "scrum_review" +# 2026-04-26 pass5 variance test (5 reps × 4 conditions, grok-4.1-fast, +# pathway_memory.rs): composed corpus LOST 5/5 vs isolation (Δ −1.8 +# grounded findings, p=0.031). See docs/MODE_RUNNER_TUNING_PLAN.md. +# Default is now isolation — bug fingerprints + adversarial framing + +# file content carries strong models without matrix noise. The +# `codereview_lakehouse` matrix path remains available via force_mode +# (auto-downgrades to isolation on strong models — see the +# is_strong_model gate in crates/gateway/src/v1/mode.rs). +preferred_mode = "codereview_isolation" +fallback_modes = ["codereview_lakehouse", "codereview", "consensus", "ladder"] +default_model = "qwen3-coder:480b" +# Corpora kept defined so experimental modes (codereview_matrix_only, +# pass2/pass5 sweeps) and weak-model rescue rungs can still pull them. +# scrum_findings_v1 is built but EXCLUDED — bake-off showed 24% OOB +# line citations from cross-file drift, only safe with same-file gating. +matrix_corpus = ["lakehouse_arch_v1", "lakehouse_symbols_v1"] + +[[task_class]] +name = "contract_analysis" +preferred_mode = "deep_analysis" +fallback_modes = ["research", "extract"] +default_model = "kimi-k2:1t" +matrix_corpus = "chicago_permits_v1" + +[[task_class]] +name = "staffing_inference" +# Staffing-domain native enrichment runner — Pass 4 (2026-04-26). +# Same composer architecture as codereview_lakehouse but with staffing +# framing + workers corpus. Validates that the modes-as-prompt-molders +# pattern generalizes beyond code review. +preferred_mode = "staffing_inference_lakehouse" +fallback_modes = ["ladder", "consensus", "pipeline"] +default_model = "openai/gpt-oss-120b:free" +matrix_corpus = "workers_500k_v8" + +[[task_class]] +name = "fact_extract" +preferred_mode = "extract" +fallback_modes = ["distill"] +default_model = "qwen2.5" +matrix_corpus = "kb_team_runs_v1" + +[[task_class]] +name = "doc_drift_check" +preferred_mode = "drift" +fallback_modes = ["validator"] +default_model = "gpt-oss:120b" +matrix_corpus = "distilled_factual_v20260423095819" + +[[task_class]] +name = "pr_audit" +# Auditor's claim-vs-diff verification mode (2026-04-26 rebuild). +# Replaces the auditor's hand-rolled inference check with the mode-runner +# composer: pathway memory (PR-level patterns) + lakehouse_answers_v1 +# corpus (prior accepted reviews + observer escalations) + adversarial +# JSON-shaped framing. Default model is paid Ollama Cloud kimi-k2:1t for +# strong claim-grounding; tie-breaker via auditor-side env override. +preferred_mode = "pr_audit" +fallback_modes = ["consensus", "ladder"] +# kimi-k2:1t broken upstream 2026-04-27 (Ollama Cloud 500 ISE, multi-hour +# sustained outage verified by repeated probes). deepseek-v3.1:671b is +# the drop-in substitute — proven working end-to-end through pr_audit +# during Phase 5 distillation acceptance testing. +default_model = "deepseek-v3.1:671b" +matrix_corpus = "lakehouse_answers_v1" + +# Fallback when task_class isn't in the table — useful for ad-hoc calls +# during development that don't yet have a mapped mode. +[default] +preferred_mode = "pipeline" +fallback_modes = ["consensus", "ladder"] +default_model = "qwen3.5:latest" diff --git a/config/providers.toml b/config/providers.toml new file mode 100644 index 0000000..248d672 --- /dev/null +++ b/config/providers.toml @@ -0,0 +1,97 @@ +# Phase 39: Provider Registry +# +# Per-provider base_url, auth scheme, and default model. The gateway's +# /v1/chat dispatcher reads this file at boot to populate its provider +# table. Secrets (API keys) come from /etc/lakehouse/secrets.toml or +# environment variables — NEVER inline a key here. +# +# Adding a new provider: +# 1. New [[provider]] block with name, base_url, auth, default_model +# 2. Matching adapter at crates/aibridge/src/providers/.rs +# implementing the ProviderAdapter trait (chat + embed + unload) +# 3. Route arm in crates/gateway/src/v1/mod.rs matching on `name` +# 4. Model-prefix routing hint in resolve_provider() if the provider +# uses an "/..." model prefix (e.g. "openrouter/...") + +[[provider]] +name = "ollama" +base_url = "http://localhost:3200" +auth = "none" +default_model = "qwen3.5:latest" +# Hot-path local inference. No bearer needed — Python sidecar on +# localhost handles the Ollama API. Model names are bare +# (e.g. "qwen3.5:latest", not "ollama/qwen3.5:latest"). + +[[provider]] +name = "ollama_cloud" +base_url = "https://ollama.com" +auth = "bearer" +auth_env = "OLLAMA_CLOUD_KEY" +default_model = "gpt-oss:120b" +# Cloud-tier Ollama. Key resolved from OLLAMA_CLOUD_KEY env at gateway +# boot. Model-prefix routing: "cloud/" auto-routes here +# (see gateway::v1::resolve_provider). + +[[provider]] +name = "openrouter" +base_url = "https://openrouter.ai/api/v1" +auth = "bearer" +auth_env = "OPENROUTER_API_KEY" +auth_fallback_files = ["/home/profit/.env", "/root/llm_team_config.json"] +default_model = "openai/gpt-oss-120b:free" +# Multi-provider gateway. Covers Anthropic, Google, OpenAI, MiniMax, +# Qwen, Gemma, etc. Key resolved via crates/gateway/src/v1/openrouter.rs +# resolve_openrouter_key() — env first, then fallback files. +# Model-prefix routing: "openrouter//" auto-routes here, +# prefix stripped before upstream call. + +[[provider]] +name = "opencode" +base_url = "https://opencode.ai/zen/v1" +# Unified endpoint — covers BOTH Zen (pay-per-token Anthropic/OpenAI/ +# Gemini frontier) AND Go (flat-sub Kimi/GLM/DeepSeek/Qwen/Minimax). +# Upstream bills per-model: Zen models hit Zen balance, Go models hit +# Go subscription cap. /zen/go/v1 is the Go-only sub-path (rejects +# Zen models), kept for reference but not used by this provider. +auth = "bearer" +auth_env = "OPENCODE_API_KEY" +default_model = "claude-opus-4-7" +# OpenCode (Zen + GO unified endpoint). One sk-* key reaches Claude +# Opus 4.7, GPT-5.5-pro, Gemini 3.1-pro, Kimi K2.6, DeepSeek, GLM, +# Qwen, plus 4 free-tier models. OpenAI-compatible Chat Completions +# at /v1/chat/completions. Model-prefix routing: "opencode/" +# auto-routes here, prefix stripped before upstream call. +# Key file: /etc/lakehouse/opencode.env (loaded via systemd EnvironmentFile). +# Model catalog: curl -H "Authorization: Bearer ..." https://opencode.ai/zen/v1/models +# Note: /zen/go/v1 is the GO-only sub-path (Kimi/GLM/DeepSeek tier); +# /zen/v1 covers everything including Anthropic (which /zen/go/v1 rejects). + +[[provider]] +name = "kimi" +base_url = "https://api.kimi.com/coding/v1" +auth = "bearer" +auth_env = "KIMI_API_KEY" +default_model = "kimi-for-coding" +# Direct Kimi For Coding provider. `api.kimi.com` is a SEPARATE account +# system from `api.moonshot.ai` and `api.moonshot.cn` — keys are NOT +# interchangeable. Used when Ollama Cloud's `kimi-k2:1t` is upstream- +# broken and OpenRouter's `moonshotai/kimi-k2.6` is rate-limited. +# Model id: `kimi-for-coding` (kimi-k2.6 underneath). +# Key file: /etc/lakehouse/kimi.env (loaded via systemd EnvironmentFile). +# Model-prefix routing: "kimi/" auto-routes here, prefix stripped. + +# Planned (Phase 40 long-horizon — adapters not yet shipped): +# +# [[provider]] +# name = "gemini" +# base_url = "https://generativelanguage.googleapis.com/v1beta" +# auth = "api_key_query" +# auth_env = "GEMINI_API_KEY" +# default_model = "gemini-2.0-flash" +# +# [[provider]] +# name = "claude" +# base_url = "https://api.anthropic.com/v1" +# auth = "x_api_key" +# auth_env = "ANTHROPIC_API_KEY" +# default_model = "claude-3-5-sonnet-latest" diff --git a/crates/aibridge/src/client.rs b/crates/aibridge/src/client.rs index b8b45e9..83382fa 100644 --- a/crates/aibridge/src/client.rs +++ b/crates/aibridge/src/client.rs @@ -3,10 +3,26 @@ use serde::{Deserialize, Serialize}; use std::time::Duration; /// HTTP client for the Python AI sidecar. +/// +/// `generate()` has two transport modes: +/// - When `gateway_url` is None (default), it posts to +/// `${base_url}/generate` (sidecar direct). +/// - When `gateway_url` is `Some(url)`, it posts to +/// `${url}/v1/chat` with `provider="ollama"` so the call appears +/// in `/v1/usage` and Langfuse traces. +/// +/// `embed()`, `rerank()`, and admin methods always go direct to the +/// sidecar — no `/v1` equivalent yet, no point round-tripping. +/// +/// Phase 44 part 2 (2026-04-27): the gateway URL is wired in by +/// callers that want observability (vectord modules); it's left +/// unset by callers that ARE the gateway internals (avoids self-loops +/// + redundant hops). #[derive(Clone)] pub struct AiClient { client: Client, base_url: String, + gateway_url: Option, } // -- Request/Response types -- @@ -86,9 +102,22 @@ impl AiClient { Self { client, base_url: base_url.trim_end_matches('/').to_string(), + gateway_url: None, } } + /// Same as `new`, but every `generate()` is routed through + /// `${gateway_url}/v1/chat` (provider=ollama) for observability. + /// Use this for callers OUTSIDE the gateway. Inside the gateway + /// itself, prefer `new()` — calling /v1/chat from /v1/chat works + /// (no infinite loop, ollama_arm doesn't use AiClient) but adds + /// a wasted localhost hop. + pub fn new_with_gateway(base_url: &str, gateway_url: &str) -> Self { + let mut c = Self::new(base_url); + c.gateway_url = Some(gateway_url.trim_end_matches('/').to_string()); + c + } + pub async fn health(&self) -> Result { let resp = self.client .get(format!("{}/health", self.base_url)) @@ -114,6 +143,13 @@ impl AiClient { } pub async fn generate(&self, req: GenerateRequest) -> Result { + if let Some(gw) = self.gateway_url.as_deref() { + return self.generate_via_gateway(gw, req).await; + } + // Direct-sidecar legacy path. Used by gateway internals (so + // ollama_arm can call sidecar without a self-loop) and by + // any consumer that wants raw transport without /v1/usage + // accounting. let resp = self.client .post(format!("{}/generate", self.base_url)) .json(&req) @@ -128,6 +164,59 @@ impl AiClient { resp.json().await.map_err(|e| format!("generate parse error: {e}")) } + /// Phase 44 part 2: route generate() through the gateway's + /// /v1/chat with provider="ollama" so the call lands in + /// /v1/usage + Langfuse. Translates between the sidecar + /// GenerateRequest/Response shape and the OpenAI-compat + /// chat shape on the wire. + async fn generate_via_gateway(&self, gateway_url: &str, req: GenerateRequest) -> Result { + let mut messages = Vec::with_capacity(2); + if let Some(sys) = &req.system { + messages.push(serde_json::json!({"role": "system", "content": sys})); + } + messages.push(serde_json::json!({"role": "user", "content": req.prompt})); + let mut body = serde_json::json!({ + "messages": messages, + "provider": "ollama", + }); + if let Some(m) = &req.model { body["model"] = serde_json::json!(m); } + if let Some(t) = req.temperature { body["temperature"] = serde_json::json!(t); } + if let Some(mt) = req.max_tokens { body["max_tokens"] = serde_json::json!(mt); } + if let Some(th) = req.think { body["think"] = serde_json::json!(th); } + + let resp = self.client + .post(format!("{}/v1/chat", gateway_url)) + .json(&body) + .send() + .await + .map_err(|e| format!("/v1/chat request failed: {e}"))?; + if !resp.status().is_success() { + let text = resp.text().await.unwrap_or_default(); + return Err(format!("/v1/chat error: {text}")); + } + let parsed: serde_json::Value = resp.json().await + .map_err(|e| format!("/v1/chat parse error: {e}"))?; + + let text = parsed + .pointer("/choices/0/message/content") + .and_then(|v| v.as_str()) + .unwrap_or("") + .to_string(); + let model = parsed.get("model") + .and_then(|v| v.as_str()) + .unwrap_or_else(|| req.model.as_deref().unwrap_or("")) + .to_string(); + let prompt_tokens = parsed.pointer("/usage/prompt_tokens").and_then(|v| v.as_u64()); + let completion_tokens = parsed.pointer("/usage/completion_tokens").and_then(|v| v.as_u64()); + + Ok(GenerateResponse { + text, + model, + tokens_evaluated: prompt_tokens, + tokens_generated: completion_tokens, + }) + } + pub async fn rerank(&self, req: RerankRequest) -> Result { let resp = self.client .post(format!("{}/rerank", self.base_url)) diff --git a/crates/aibridge/src/context.rs b/crates/aibridge/src/context.rs index cc81562..4cd4de1 100644 --- a/crates/aibridge/src/context.rs +++ b/crates/aibridge/src/context.rs @@ -13,11 +13,9 @@ use std::collections::HashMap; use std::sync::OnceLock; -/// Rough token count. `chars / 4` ceiling. See module docs for why -/// this heuristic is sufficient. -pub fn estimate_tokens(text: &str) -> usize { - (text.chars().count() + 3) / 4 -} +// `estimate_tokens` moved to `shared::model_matrix::ModelMatrix::estimate_tokens` +// (cdc24d8). All callers migrated; the deprecated wrapper that stood in its +// place has been removed since it had zero external consumers. /// Phase 21 — per-model context windows, mirroring the TS table in /// `tests/multi-agent/agent.ts`. Anchored on each model's documented @@ -84,8 +82,8 @@ pub fn assert_context_budget( let window = context_window_for(model); let safety = opts.safety_margin.unwrap_or(DEFAULT_SAFETY_MARGIN); let max_tokens = opts.max_tokens.unwrap_or(DEFAULT_MAX_TOKENS); - let sys_tokens = opts.system.map(estimate_tokens).unwrap_or(0); - let estimated = estimate_tokens(prompt) + sys_tokens + max_tokens; + let sys_tokens = opts.system.map(shared::model_matrix::ModelMatrix::estimate_tokens).unwrap_or(0); + let estimated = shared::model_matrix::ModelMatrix::estimate_tokens(prompt) + sys_tokens + max_tokens; let remaining = window as i64 - estimated as i64 - safety as i64; let check = BudgetCheck { estimated, window, remaining }; if remaining < 0 && !opts.bypass { @@ -109,14 +107,10 @@ pub fn overflow_message(model: &str, check: &BudgetCheck, over_by: usize, safety mod tests { use super::*; - #[test] - fn estimate_tokens_ceiling_divides_by_four() { - assert_eq!(estimate_tokens(""), 0); - assert_eq!(estimate_tokens("abc"), 1); // 3 → ceil(3/4) = 1 - assert_eq!(estimate_tokens("abcd"), 1); // 4 → ceil(4/4) = 1 - assert_eq!(estimate_tokens("abcde"), 2); // 5 → ceil(5/4) = 2 - assert_eq!(estimate_tokens(&"x".repeat(400)), 100); - } + // Deprecated-function behavior is now canonically tested in + // crates/shared/src/model_matrix.rs. This test was the legacy + // pin that preceded the migration; delete when the deprecated + // wrapper itself goes (see the #[deprecated] attribute). #[test] fn context_window_known_and_fallback() { @@ -179,7 +173,7 @@ mod tests { ).unwrap(); assert!(with_sys.estimated > without_sys.estimated, "system prompt should raise estimate"); - assert_eq!(with_sys.estimated - without_sys.estimated, estimate_tokens(&sys)); + assert_eq!(with_sys.estimated - without_sys.estimated, shared::model_matrix::ModelMatrix::estimate_tokens(&sys)); } #[test] diff --git a/crates/aibridge/src/continuation.rs b/crates/aibridge/src/continuation.rs index 2c61eaa..7ad2859 100644 --- a/crates/aibridge/src/continuation.rs +++ b/crates/aibridge/src/continuation.rs @@ -138,6 +138,17 @@ pub struct ContinuableOutcome { pub empty_retries: usize, pub continuations: usize, pub final_complete: bool, + /// Sum of `prompt_tokens` across every generator call made to + /// produce this outcome — including empty retries and continuations. + /// Lets callers (gateway execution loop, observability) stamp + /// accurate per-task usage without second-guessing the retry fan-out. + pub prompt_tokens: u32, + /// Sum of `completion_tokens` across every generator call. + pub completion_tokens: u32, + /// Total number of generator calls. `1 + empty_retries + + /// continuations` in the normal case; the field is explicit so + /// callers don't have to re-derive it. + pub calls: u32, } fn make_request(opts: &ContinuableOpts, prompt: String, current_max: u32) -> GenerateRequest { @@ -175,11 +186,20 @@ pub async fn generate_continuable( let mut combined = String::new(); let mut empty_retries = 0usize; let mut continuations = 0usize; + let mut prompt_tokens: u32 = 0; + let mut completion_tokens: u32 = 0; + let mut calls: u32 = 0; // Phase 21(a) — empty-response backoff loop. for retry in 0..opts.max_empty_retries { let req = make_request(opts, prompt.to_string(), current_max); let resp = generator.generate_text(req).await?; + calls += 1; + // u32::try_from saturates at u32::MAX instead of silently + // truncating bits when tokens_evaluated/_generated comes back + // as a u64 > 4 billion. Caught 2026-04-27 by Opus self-audit. + prompt_tokens = prompt_tokens.saturating_add(u32::try_from(resp.tokens_evaluated.unwrap_or(0)).unwrap_or(u32::MAX)); + completion_tokens = completion_tokens.saturating_add(u32::try_from(resp.tokens_generated.unwrap_or(0)).unwrap_or(u32::MAX)); if !resp.text.trim().is_empty() { combined = resp.text; break; @@ -188,9 +208,7 @@ pub async fn generate_continuable( current_max = (current_max.saturating_mul(2)).min(opts.budget_cap); } - // Phase 21(b) — structural-completion continuation loop. Runs on - // the truncated-non-empty case; empty + exhausted retries falls - // through with empty combined and final_complete=false. + // Phase 21(b) — structural-completion continuation loop. for _ in 0..opts.max_continuations { if is_structurally_complete(&combined, opts.shape) { return Ok(ContinuableOutcome { @@ -198,17 +216,22 @@ pub async fn generate_continuable( empty_retries, continuations, final_complete: true, + prompt_tokens, + completion_tokens, + calls, }); } if combined.trim().is_empty() { // Nothing to continue from — continuing "" is identical to - // the initial call and would loop. Bail so the caller sees - // the failure rather than burning N extra calls. + // the initial call and would loop. break; } let cont_prompt = continuation_prompt(prompt, &combined); let req = make_request(opts, cont_prompt, current_max.min(opts.budget_cap)); let resp = generator.generate_text(req).await?; + calls += 1; + prompt_tokens = prompt_tokens.saturating_add(u32::try_from(resp.tokens_evaluated.unwrap_or(0)).unwrap_or(u32::MAX)); + completion_tokens = completion_tokens.saturating_add(u32::try_from(resp.tokens_generated.unwrap_or(0)).unwrap_or(u32::MAX)); combined.push_str(&resp.text); continuations += 1; } @@ -219,6 +242,9 @@ pub async fn generate_continuable( empty_retries, continuations, final_complete, + prompt_tokens, + completion_tokens, + calls, }) } diff --git a/crates/aibridge/src/providers/openrouter.rs b/crates/aibridge/src/providers/openrouter.rs index 9584dbe..3dfad1d 100644 --- a/crates/aibridge/src/providers/openrouter.rs +++ b/crates/aibridge/src/providers/openrouter.rs @@ -40,12 +40,14 @@ struct OpenRouterChoice { } #[derive(Deserialize)] +#[allow(dead_code)] struct OpenRouterMessageOut { role: String, content: String, } #[derive(Deserialize)] +#[allow(dead_code)] struct OpenRouterUsage { prompt_tokens: Option, completion_tokens: Option, diff --git a/crates/aibridge/src/routing.rs b/crates/aibridge/src/routing.rs index d627fc8..dbbce61 100644 --- a/crates/aibridge/src/routing.rs +++ b/crates/aibridge/src/routing.rs @@ -1,5 +1,4 @@ use serde::{Deserialize, Serialize}; -use std::collections::HashMap; #[derive(Clone, Debug, Deserialize, Serialize)] pub struct RoutingRule { @@ -71,15 +70,19 @@ pub struct RouteDecision { } fn glob_match(pattern: &str, name: &str) -> bool { - if pattern.contains('*') { - let parts: Vec<&str> = pattern.split('*').collect(); - if parts.len() == 2 { - return name.starts_with(parts[0]) && name.ends_with(parts[1]); - } else if parts.len() == 1 { - return name.starts_with(parts[0]) || name.ends_with(parts[1]); - } - } - pattern == name + if !pattern.contains('*') { return pattern == name; } + let parts: Vec<&str> = pattern.split('*').collect(); + // Multi-* support: first must be prefix, last must be suffix, each + // interior piece must appear in order. Fixes the iter-9 finding + // where gpt-*-large* silently fell through to an exact-match path. + // Also removes the dead `parts.len() == 1` branch that accessed + // parts[1] and would panic if ever reached (unreachable today + // since split('*') on a string containing '*' always yields ≥2). + if !name.starts_with(parts[0]) || !name.ends_with(parts.last().unwrap()) { return false; } + let mut cursor = parts[0].len(); + parts[1..parts.len() - 1].iter().all(|mid| { + name[cursor..].find(mid).map(|pos| { cursor += pos + mid.len(); true }).unwrap_or(false) + }) } impl Default for RoutingRule { @@ -91,4 +94,26 @@ impl Default for RoutingRule { temperature: None, } } +} + +#[cfg(test)] +mod glob_match_tests { + use super::glob_match; + + #[test] fn exact_match() { assert!(glob_match("gpt-oss:120b", "gpt-oss:120b")); } + #[test] fn exact_mismatch() { assert!(!glob_match("a", "b")); } + #[test] fn leading_wildcard() { assert!(glob_match("*:120b", "gpt-oss:120b")); } + #[test] fn trailing_wildcard() { assert!(glob_match("gpt-oss:*", "gpt-oss:120b")); } + #[test] fn bare_wildcard() { assert!(glob_match("*", "anything")); } + #[test] fn multi_wildcard_in_order() { assert!(glob_match("gpt-*-oss-*", "gpt-4-oss-120b")); } + #[test] fn multi_wildcard_wrong_order() { assert!(!glob_match("b*a*", "abba")); } + #[test] fn multi_wildcard_panic_safety() { + // Regression: earlier impl had an unreachable `parts.len() == 1` + // branch that indexed parts[1] — would panic if ever hit. Now + // the split('*') invariant guarantees ≥2 parts when * present, + // and we handle all N-part cases explicitly. + assert!(glob_match("a*b*c", "abc")); + assert!(glob_match("a*b*c", "axxxbxxxc")); + assert!(!glob_match("a*b*c", "xxxbxxx")); + } } \ No newline at end of file diff --git a/crates/aibridge/src/tree_split.rs b/crates/aibridge/src/tree_split.rs index c29dff6..781a80a 100644 --- a/crates/aibridge/src/tree_split.rs +++ b/crates/aibridge/src/tree_split.rs @@ -19,8 +19,9 @@ //! we bubble the error up rather than silently truncating. That's the //! whole point of Phase 21. -use crate::context::{assert_context_budget, BudgetOpts, estimate_tokens, overflow_message, +use crate::context::{assert_context_budget, BudgetOpts, overflow_message, DEFAULT_MAX_TOKENS, DEFAULT_SAFETY_MARGIN}; +use shared::model_matrix::ModelMatrix; use crate::continuation::{generate_continuable, ContinuableOpts, ResponseShape, TextGenerator}; /// Callback signatures — caller supplies closures that stitch the @@ -80,12 +81,12 @@ pub struct TreeSplitResult { /// by `\n— shard N/M digest —\n` so we can find the first one and /// chop everything before its successor. fn truncate_scratchpad(scratchpad: &mut String, budget_tokens: usize) -> bool { - if estimate_tokens(scratchpad) <= budget_tokens { return false; } + if ModelMatrix::estimate_tokens(scratchpad) <= budget_tokens { return false; } // Find the second delimiter — everything before it gets dropped. const DELIM_PREFIX: &str = "\n— shard "; let mut cursor = 0; let mut truncated = false; - while estimate_tokens(&scratchpad[cursor..]) > budget_tokens { + while ModelMatrix::estimate_tokens(&scratchpad[cursor..]) > budget_tokens { // Skip past a leading delimiter (if we're sitting on one from // a previous iteration), then find the next. let search_from = cursor + if scratchpad[cursor..].starts_with(DELIM_PREFIX) { @@ -278,7 +279,7 @@ mod tests { // Scratchpad should still fit roughly within the budget // (post-truncation); the estimator uses chars/4 so the bound // is ~budget*4 chars. Give some slack for the delimiter. - let scratchpad_tokens = estimate_tokens(&result.scratchpad); + let scratchpad_tokens = ModelMatrix::estimate_tokens(&result.scratchpad); assert!(scratchpad_tokens <= opts.scratchpad_budget * 2, "scratchpad {} tokens vs budget {}", scratchpad_tokens, opts.scratchpad_budget); } diff --git a/crates/gateway/Cargo.toml b/crates/gateway/Cargo.toml index d93ac47..5eb1654 100644 --- a/crates/gateway/Cargo.toml +++ b/crates/gateway/Cargo.toml @@ -12,6 +12,8 @@ aibridge = { path = "../aibridge" } ingestd = { path = "../ingestd" } vectord = { path = "../vectord" } journald = { path = "../journald" } +truth = { path = "../truth" } +validator = { path = "../validator" } tokio = { workspace = true } axum = { workspace = true } serde = { workspace = true } @@ -29,3 +31,4 @@ tracing-opentelemetry = { workspace = true } arrow = { workspace = true } chrono = { workspace = true } reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] } +toml = { workspace = true } diff --git a/crates/gateway/src/access.rs b/crates/gateway/src/access.rs index ede1c5d..c675362 100644 --- a/crates/gateway/src/access.rs +++ b/crates/gateway/src/access.rs @@ -93,7 +93,7 @@ impl AccessControl { self.roles.write().await.insert(role.agent_name.clone(), role); } - /// Get an agent's role. + /// Get an agent's role. Called by `GET /access/roles/{agent}`. pub async fn get_role(&self, agent: &str) -> Option { self.roles.read().await.get(agent).cloned() } @@ -113,6 +113,7 @@ impl AccessControl { } /// Determine which fields should be masked for an agent. + #[allow(dead_code)] pub async fn masked_fields( &self, agent: &str, @@ -138,6 +139,7 @@ impl AccessControl { } /// Log a query for audit. + #[allow(dead_code)] pub async fn log_query(&self, audit: QueryAudit) { self.audit_log.write().await.push(audit); } @@ -149,6 +151,9 @@ impl AccessControl { log[start..].iter().rev().cloned().collect() } + /// Reports whether access-control enforcement is active. + /// Called by `GET /access/enabled` — ops tooling / dashboards poll + /// this to confirm the auth posture of the running gateway. pub fn is_enabled(&self) -> bool { self.enabled } diff --git a/crates/gateway/src/access_service.rs b/crates/gateway/src/access_service.rs index b0dd672..1bf3158 100644 --- a/crates/gateway/src/access_service.rs +++ b/crates/gateway/src/access_service.rs @@ -1,6 +1,6 @@ use axum::{ Json, Router, - extract::{Query, State}, + extract::{Path, Query, State}, http::StatusCode, response::IntoResponse, routing::{get, post}, @@ -13,6 +13,12 @@ pub fn router(ac: AccessControl) -> Router { Router::new() .route("/roles", get(list_roles)) .route("/roles", post(set_role)) + // Scrum iter 11 / P13-001 finding: get_role was #[allow(dead_code)] + // because nothing called it — dead until exposed. Route activates it. + // Returns 404 when the agent isn't registered so clients can + // distinguish "missing role" from "access denied." + .route("/roles/{agent}", get(get_role)) + .route("/enabled", get(enabled_status)) .route("/audit", get(query_audit)) .route("/check", post(check_access)) .with_state(ac) @@ -60,3 +66,17 @@ async fn check_access( "allowed": allowed, })) } + +async fn get_role( + State(ac): State, + Path(agent): Path, +) -> impl IntoResponse { + match ac.get_role(&agent).await { + Some(role) => Ok(Json(role)), + None => Err((StatusCode::NOT_FOUND, format!("no role registered for agent '{agent}'"))), + } +} + +async fn enabled_status(State(ac): State) -> impl IntoResponse { + Json(serde_json::json!({ "enabled": ac.is_enabled() })) +} diff --git a/crates/gateway/src/auth.rs b/crates/gateway/src/auth.rs index ff82bef..3c54782 100644 --- a/crates/gateway/src/auth.rs +++ b/crates/gateway/src/auth.rs @@ -5,30 +5,51 @@ use axum::{ response::Response, }; -/// API key auth middleware. Checks X-API-Key header against configured key. +// API key auth middleware. Checks X-API-Key header against configured key. +// Fixed P5-001 (2026-04-23): previously #[allow(dead_code)] — the function +// existed but was never layered onto the router, so [auth] enabled=true +// silently enforced nothing. Now wired via from_fn_with_state in main.rs. pub async fn api_key_auth( + axum::extract::State(expected): axum::extract::State, request: Request, next: Next, ) -> Result { - // Get the expected key from the request extensions (set by the layer) - let expected_key = request.extensions().get::().cloned(); - - if let Some(expected) = expected_key { - let provided = request - .headers() - .get("x-api-key") - .and_then(|v| v.to_str().ok()); - - match provided { - Some(key) if key == expected.0 => {} - _ => { - tracing::warn!("unauthorized request: missing or invalid API key"); - return Err(StatusCode::UNAUTHORIZED); - } - } + // /health stays public (LB/systemd probes). Every other route is gated. + if request.uri().path() == "/health" { + return Ok(next.run(request).await); } - Ok(next.run(request).await) + let provided = request + .headers() + .get("x-api-key") + .and_then(|v| v.to_str().ok()); + + // Constant-time-ish eq on the raw bytes; good enough for a shared-secret + // X-API-Key. Timing-attack resistance here matters less than the + // equivalent HMAC check would; adopt subtle crate if key-space grows. + match provided { + Some(key) if eq_ct(key.as_bytes(), expected.0.as_bytes()) => { + Ok(next.run(request).await) + } + _ => { + tracing::warn!( + path = %request.uri().path(), + "unauthorized request: missing or invalid API key", + ); + Err(StatusCode::UNAUTHORIZED) + } + } +} + +fn eq_ct(a: &[u8], b: &[u8]) -> bool { + if a.len() != b.len() { + return false; + } + let mut diff: u8 = 0; + for (x, y) in a.iter().zip(b.iter()) { + diff |= x ^ y; + } + diff == 0 } /// Wrapper type for the API key, stored in request extensions. diff --git a/crates/gateway/src/execution_loop/kb_context.rs b/crates/gateway/src/execution_loop/kb_context.rs new file mode 100644 index 0000000..7d038c8 --- /dev/null +++ b/crates/gateway/src/execution_loop/kb_context.rs @@ -0,0 +1,388 @@ +//! KB context loader — reads recent signal from `data/_kb/*.jsonl` for +//! a given sig_hash + task_class and returns a compact summary. +//! +//! This is the "pipe to the overviewer" from the 2026-04-23 session: +//! the overseer tier (T3, gpt-oss:120b) consumes this context before +//! generating a correction, so its suggestions are informed by +//! historical cost / latency / outcome / prior-correction patterns +//! across ALL profiles that have run this task class — not just the +//! single current loop. +//! +//! Hot-swap profiles read the SAME pool. When a profile activates and +//! starts iterating, its KB context is the shared surface — one +//! profile's learning becomes every profile's starting point. +//! +//! Best-effort throughout: missing files, corrupt rows, empty +//! directories all produce an empty KbContext. The overseer works +//! fine with no history; we just can't seed it then. + +use serde::Serialize; +use std::path::Path; +use tokio::io::AsyncBufReadExt; + +/// Compact summary returned to the overseer. Bounded size — recent +/// outcomes + corrections plus rolled-up rates. Goal is to fit in a +/// prompt without eating the overseer's context budget. +#[derive(Debug, Clone, Default, Serialize)] +pub struct KbContext { + pub sig_hash: String, + pub task_class: String, + pub recent_outcomes: Vec, + pub recent_corrections: Vec, + pub success_rate: Option, + pub avg_turns: Option, + pub avg_latency_ms: Option, + pub total_observed: u32, +} + +#[derive(Debug, Clone, Serialize)] +pub struct OutcomeSummary { + pub created_at: String, + pub ok: bool, + pub polarity: String, + pub turns: u32, + pub latency_ms: u64, + pub total_tokens: u64, + pub error: Option, +} + +#[derive(Debug, Clone, Serialize)] +pub struct CorrectionSummary { + pub created_at: String, + pub reason: String, + pub correction_preview: String, // first 300 chars + pub applied_at_turn: u32, +} + +const OUTCOMES_PATH: &str = "data/_kb/outcomes.jsonl"; +const CORRECTIONS_PATH: &str = "data/_kb/overseer_corrections.jsonl"; +const RECENT_OUTCOME_LIMIT: usize = 5; +const RECENT_CORRECTION_LIMIT: usize = 3; +const AGGREGATE_WINDOW: usize = 50; + +impl KbContext { + /// Build context from the default KB paths. + pub async fn load_for(sig_hash: &str, task_class: &str) -> Self { + Self::load_from( + sig_hash, task_class, + Path::new(OUTCOMES_PATH), Path::new(CORRECTIONS_PATH), + ).await + } + + /// Path-taking variant — tests inject tmp files without touching + /// the real KB directory (same pattern as append_outcomes_row_at). + pub async fn load_from( + sig_hash: &str, + task_class: &str, + outcomes_path: &Path, + corrections_path: &Path, + ) -> Self { + let mut ctx = KbContext { + sig_hash: sig_hash.to_string(), + task_class: task_class.to_string(), + ..Default::default() + }; + + // Scan outcomes — matches on sig_hash primary, task_class + // secondary (so different geos for the same task_class still + // contribute to aggregate rates even though they won't make + // the top-5 recent). The bounded window keeps scan cost + // linear in file size — we're reading tail only. + let outcome_rows = tail_matching( + outcomes_path, AGGREGATE_WINDOW * 4, + |row| { + let row_sig = row.get("sig_hash").and_then(|v| v.as_str()).unwrap_or(""); + let row_tc = row.get("task_class").and_then(|v| v.as_str()).unwrap_or(""); + row_sig == sig_hash || row_tc == task_class + }, + ).await; + + // Recent outcomes: exact sig_hash match first (strongest + // signal), then task_class fallback up to the limit. + let mut exact: Vec = Vec::new(); + let mut loose: Vec = Vec::new(); + for row in &outcome_rows { + let row_sig = row.get("sig_hash").and_then(|v| v.as_str()).unwrap_or(""); + let summary = summarize_outcome(row); + if row_sig == sig_hash { exact.push(summary); } + else { loose.push(summary); } + } + ctx.recent_outcomes = exact.into_iter().rev().take(RECENT_OUTCOME_LIMIT).collect(); + if ctx.recent_outcomes.len() < RECENT_OUTCOME_LIMIT { + let need = RECENT_OUTCOME_LIMIT - ctx.recent_outcomes.len(); + ctx.recent_outcomes.extend(loose.into_iter().rev().take(need)); + } + + // Aggregate rates across the full matched window (both + // sig_hash and task_class matches — gives a stable rate even + // on sparse sig_hash history). + let window = outcome_rows.iter().rev().take(AGGREGATE_WINDOW); + let mut ok_count = 0u32; + let mut total = 0u32; + let mut turn_sum = 0u32; + let mut latency_sum = 0u64; + for row in window { + total += 1; + if row.get("ok").and_then(|v| v.as_bool()).unwrap_or(false) { ok_count += 1; } + turn_sum += row.get("turns").and_then(|v| v.as_u64()).unwrap_or(0) as u32; + latency_sum += row.get("usage") + .and_then(|u| u.get("latency_ms")) + .and_then(|v| v.as_u64()).unwrap_or(0); + } + if total > 0 { + ctx.total_observed = total; + ctx.success_rate = Some(ok_count as f64 / total as f64); + ctx.avg_turns = Some(turn_sum as f64 / total as f64); + ctx.avg_latency_ms = Some(latency_sum / total as u64); + } + + // Overseer corrections. Prefer sig_hash match; fall back to + // task_class. The overseer reading its OWN prior corrections + // is the main point — if the last 3 attempts produced + // corrections X, Y, Z, the new correction should acknowledge + // those patterns rather than suggest X for the fourth time. + let correction_rows = tail_matching( + corrections_path, RECENT_CORRECTION_LIMIT * 4, + |row| { + let row_sig = row.get("sig_hash").and_then(|v| v.as_str()).unwrap_or(""); + let row_tc = row.get("task_class").and_then(|v| v.as_str()).unwrap_or(""); + row_sig == sig_hash || row_tc == task_class + }, + ).await; + let mut c_exact: Vec = Vec::new(); + let mut c_loose: Vec = Vec::new(); + for row in &correction_rows { + let row_sig = row.get("sig_hash").and_then(|v| v.as_str()).unwrap_or(""); + let summary = summarize_correction(row); + if row_sig == sig_hash { c_exact.push(summary); } + else { c_loose.push(summary); } + } + ctx.recent_corrections = c_exact.into_iter().rev().take(RECENT_CORRECTION_LIMIT).collect(); + if ctx.recent_corrections.len() < RECENT_CORRECTION_LIMIT { + let need = RECENT_CORRECTION_LIMIT - ctx.recent_corrections.len(); + ctx.recent_corrections.extend(c_loose.into_iter().rev().take(need)); + } + + ctx + } + + /// Compact string form for the overseer prompt. Deterministic + /// ordering + bounded length so prompt caching stays stable + /// across iterations on the same task. + pub fn to_prompt_section(&self) -> String { + let mut s = String::new(); + s.push_str("## Knowledge Base Context\n"); + if let (Some(rate), Some(turns), Some(lat)) = (self.success_rate, self.avg_turns, self.avg_latency_ms) { + s.push_str(&format!( + "Across {} prior similar runs: success_rate={:.1}%, avg_turns={:.1}, avg_latency_ms={}\n", + self.total_observed, rate * 100.0, turns, lat, + )); + } else { + s.push_str("No prior similar runs recorded.\n"); + } + + if !self.recent_outcomes.is_empty() { + s.push_str(&format!("\nRecent {} outcomes:\n", self.recent_outcomes.len())); + for o in &self.recent_outcomes { + let err = o.error.as_deref().map(|e| format!(" — {}", truncate(e, 80))).unwrap_or_default(); + s.push_str(&format!( + " [{}] ok={} turns={} tokens={} lat={}ms{}\n", + &o.created_at[..19.min(o.created_at.len())], + o.ok, o.turns, o.total_tokens, o.latency_ms, err, + )); + } + } + + if !self.recent_corrections.is_empty() { + s.push_str(&format!("\nRecent {} overseer corrections (yours — don't repeat):\n", self.recent_corrections.len())); + for c in &self.recent_corrections { + s.push_str(&format!( + " [{}] turn={} reason={} correction={}\n", + &c.created_at[..19.min(c.created_at.len())], + c.applied_at_turn, + truncate(&c.reason, 40), + truncate(&c.correction_preview, 200), + )); + } + } + + s + } +} + +fn summarize_outcome(row: &serde_json::Value) -> OutcomeSummary { + OutcomeSummary { + created_at: row.get("created_at").and_then(|v| v.as_str()).unwrap_or("").to_string(), + ok: row.get("ok").and_then(|v| v.as_bool()).unwrap_or(false), + polarity: row.get("polarity").and_then(|v| v.as_str()).unwrap_or("").to_string(), + turns: row.get("turns").and_then(|v| v.as_u64()).unwrap_or(0) as u32, + latency_ms: row.get("usage").and_then(|u| u.get("latency_ms")) + .and_then(|v| v.as_u64()).unwrap_or(0), + total_tokens: row.get("usage").and_then(|u| u.get("total_tokens")) + .and_then(|v| v.as_u64()).unwrap_or(0), + error: row.get("error").and_then(|v| v.as_str()).map(String::from), + } +} + +fn summarize_correction(row: &serde_json::Value) -> CorrectionSummary { + let preview = row.get("correction").and_then(|v| v.as_str()).unwrap_or(""); + CorrectionSummary { + created_at: row.get("created_at").and_then(|v| v.as_str()).unwrap_or("").to_string(), + reason: row.get("reason").and_then(|v| v.as_str()).unwrap_or("").to_string(), + correction_preview: truncate(preview, 300), + applied_at_turn: row.get("applied_at_turn").and_then(|v| v.as_u64()).unwrap_or(0) as u32, + } +} + +fn truncate(s: &str, n: usize) -> String { + if s.len() <= n { s.to_string() } else { format!("{}…", &s[..n]) } +} + +/// Read a JSONL file from the tail, returning at most `limit` rows +/// that match `filter`. Missing file returns empty. Corrupt lines are +/// skipped. Limit is honored from the tail — a full-file scan with an +/// in-memory ring would be wasteful for large outcomes histories, but +/// we cap at reading the whole file and filtering post-hoc for now +/// (reverse-seek line iteration is a real engineering task and the +/// file is bounded by ingest rate; revisit when it bites). +async fn tail_matching( + path: &Path, + limit: usize, + filter: F, +) -> Vec +where + F: Fn(&serde_json::Value) -> bool, +{ + let Ok(file) = tokio::fs::File::open(path).await else { return Vec::new(); }; + let reader = tokio::io::BufReader::new(file); + let mut lines = reader.lines(); + let mut matches: Vec = Vec::new(); + while let Ok(Some(line)) = lines.next_line().await { + let Ok(v) = serde_json::from_str::(&line) else { continue }; + if filter(&v) { + matches.push(v); + if matches.len() > limit { + // Keep the most-recent window only — drop from the + // front as we go rather than buffering everything. + matches.remove(0); + } + } + } + matches +} + +#[cfg(test)] +mod tests { + use super::*; + use tokio::io::AsyncWriteExt; + + async fn write_fixture(path: &Path, rows: Vec) { + if let Some(dir) = path.parent() { + tokio::fs::create_dir_all(dir).await.unwrap(); + } + let mut f = tokio::fs::OpenOptions::new() + .create(true).write(true).truncate(true).open(path).await.unwrap(); + for r in rows { + let mut line = serde_json::to_string(&r).unwrap(); + line.push('\n'); + f.write_all(line.as_bytes()).await.unwrap(); + } + } + + fn tmp_path(name: &str) -> std::path::PathBuf { + let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos(); + std::env::temp_dir().join(format!("lh_kb_ctx_{}_{}_{}", std::process::id(), nanos, name)) + } + + #[tokio::test] + async fn empty_files_produce_empty_context() { + let op = tmp_path("outcomes.jsonl"); + let cp = tmp_path("corrections.jsonl"); + let ctx = KbContext::load_from("sig123", "staffing.fill", &op, &cp).await; + assert!(ctx.recent_outcomes.is_empty()); + assert!(ctx.recent_corrections.is_empty()); + assert!(ctx.success_rate.is_none()); + assert_eq!(ctx.total_observed, 0); + } + + #[tokio::test] + async fn exact_sig_hash_matches_take_priority() { + let op = tmp_path("outcomes.jsonl"); + let cp = tmp_path("corrections.jsonl"); + write_fixture(&op, vec![ + // Other sig_hash, same task_class — loose match + serde_json::json!({ + "sig_hash": "other", "task_class": "staffing.fill", + "ok": false, "polarity": "failure_pattern", "turns": 1, + "usage": {"latency_ms": 1000, "total_tokens": 100}, + "created_at": "2026-04-22T10:00:00Z", + }), + // Exact sig_hash — should lead + serde_json::json!({ + "sig_hash": "sig123", "task_class": "staffing.fill", + "ok": true, "polarity": "success_confirmation", "turns": 3, + "usage": {"latency_ms": 2000, "total_tokens": 500}, + "created_at": "2026-04-23T10:00:00Z", + }), + ]).await; + write_fixture(&cp, vec![]).await; + + let ctx = KbContext::load_from("sig123", "staffing.fill", &op, &cp).await; + assert_eq!(ctx.recent_outcomes.len(), 2); + assert_eq!(ctx.recent_outcomes[0].created_at, "2026-04-23T10:00:00Z"); + assert_eq!(ctx.recent_outcomes[0].ok, true); + assert_eq!(ctx.total_observed, 2); + assert!((ctx.success_rate.unwrap() - 0.5).abs() < 0.001); + } + + #[tokio::test] + async fn corrupt_rows_are_skipped() { + let op = tmp_path("outcomes.jsonl"); + let cp = tmp_path("corrections.jsonl"); + // Mix valid + invalid — invalid should be silently skipped. + if let Some(dir) = op.parent() { tokio::fs::create_dir_all(dir).await.unwrap(); } + tokio::fs::write(&op, "not json\n{\"sig_hash\":\"sig1\",\"task_class\":\"tc\",\"ok\":true,\"turns\":1,\"usage\":{}}\ngarbage\n").await.unwrap(); + write_fixture(&cp, vec![]).await; + let ctx = KbContext::load_from("sig1", "tc", &op, &cp).await; + assert_eq!(ctx.recent_outcomes.len(), 1); + } + + #[tokio::test] + async fn corrections_preview_is_truncated() { + let op = tmp_path("outcomes.jsonl"); + let cp = tmp_path("corrections.jsonl"); + let long = "x".repeat(500); + write_fixture(&op, vec![]).await; + write_fixture(&cp, vec![serde_json::json!({ + "sig_hash": "sig1", "task_class": "tc", + "reason": "abort", "correction": long, "applied_at_turn": 3, + "created_at": "2026-04-23T10:00:00Z", + })]).await; + let ctx = KbContext::load_from("sig1", "tc", &op, &cp).await; + assert_eq!(ctx.recent_corrections.len(), 1); + // 300-char cap + 3-byte UTF-8 ellipsis character = 303-byte worst case. + assert!(ctx.recent_corrections[0].correction_preview.len() <= 303); + } + + #[test] + fn prompt_section_is_stable_for_empty_context() { + let ctx = KbContext::default(); + let s = ctx.to_prompt_section(); + assert!(s.contains("No prior similar runs recorded")); + } + + #[test] + fn prompt_section_reports_aggregate_rates() { + let ctx = KbContext { + total_observed: 10, + success_rate: Some(0.7), + avg_turns: Some(4.2), + avg_latency_ms: Some(45000), + ..Default::default() + }; + let s = ctx.to_prompt_section(); + assert!(s.contains("success_rate=70.0%")); + assert!(s.contains("avg_turns=4.2")); + assert!(s.contains("avg_latency_ms=45000")); + } +} diff --git a/crates/gateway/src/execution_loop/mod.rs b/crates/gateway/src/execution_loop/mod.rs new file mode 100644 index 0000000..aaab58d --- /dev/null +++ b/crates/gateway/src/execution_loop/mod.rs @@ -0,0 +1,1855 @@ +//! `ExecutionLoop` — the Rust port of `tests/multi-agent/orchestrator.ts`. +//! +//! Incremental port (2026-04-23). Pieces in order of landing: +//! 1. ✅ Playbook-boost context retrieval +//! 2. ✅ Executor turn via the shared ollama::chat path +//! 3. ✅ Reviewer turn + critique parse (this commit) +//! 4. ⬜ Tool-call dispatch — hybrid_search / sql / Phase-12 tools (orchestrator.ts:101-124) +//! 5. ✅ Consensus detection + drift counter (this commit) +//! 6. ⬜ Truth-layer gate (Phase 42 — refuse before burning tokens) +//! 7. ⬜ Validator call (Phase 43 stub) +//! 8. ⬜ Cloud escalation on repeat failure (T3 gpt-oss:120b) +//! 9. ⬜ Playbook seal + /vectors/playbook_memory/seed (orchestrator.ts:255-293) +//! 10. ⬜ KB write-through: outcomes + facts (Phase 22) + +pub mod kb_context; + +use serde::{Deserialize, Serialize}; + +use crate::v1::{respond::RespondRequest, V1State}; +use kb_context::KbContext; + +const DEFAULT_EXECUTOR_MODEL: &str = "qwen3.5:latest"; +const DEFAULT_REVIEWER_MODEL: &str = "qwen3:latest"; +const DEFAULT_MAX_TURNS: u32 = 12; +/// Matches orchestrator.ts:31. Three consecutive drift flags OR tool +/// errors aborts the loop — the executor isn't self-correcting. +const MAX_CONSECUTIVE_DRIFTS: u32 = 3; + +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct LogEntry { + pub turn: u32, + pub role: String, + pub model: String, + pub kind: String, + pub content: serde_json::Value, + pub at: String, +} + +impl LogEntry { + fn new(turn: u32, role: &str, model: &str, kind: &str, content: serde_json::Value) -> Self { + Self { + turn, + role: role.to_string(), + model: model.to_string(), + kind: kind.to_string(), + content, + at: chrono::Utc::now().to_rfc3339(), + } + } +} + +/// Action = what an agent returns on one turn. PORT FROM agent.ts:312. +/// Strict-shape enum so the executor/reviewer can't wedge the loop +/// with ambiguous output — either it parses, or `parse_action` throws +/// and the orchestrator appends an error turn. +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(tag = "kind", rename_all = "snake_case")] +pub enum Action { + Plan { steps: Vec }, + ToolCall { tool: String, args: serde_json::Value, #[serde(default)] rationale: String }, + ProposeDone { fills: Vec, #[serde(default)] rationale: String }, + Critique { verdict: Verdict, #[serde(default)] notes: String }, +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] +#[serde(rename_all = "snake_case")] +pub enum Verdict { + Continue, + Drift, + ApproveDone, +} + +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct Fill { + pub candidate_id: String, + pub name: String, + /// Optional — legacy models still emit it. agent.ts:321 rationale. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub reason: Option, +} + +pub enum RespondOutcome { + Ok { artifact: serde_json::Value, log: Vec }, + Failed { reason: String, log: Vec }, + // Constructed by the truth-gate check in run_inner (step 6, 2026-04-24). + Blocked { reason: String, log: Vec }, +} + +impl RespondOutcome { + pub fn artifact(&self) -> serde_json::Value { + match self { + Self::Ok { artifact, .. } => artifact.clone(), + _ => serde_json::Value::Null, + } + } + pub fn into_log(self) -> Vec { + match self { + Self::Ok { log, .. } | Self::Failed { log, .. } | Self::Blocked { log, .. } => log, + } + } +} + +pub struct ExecutionLoop { + state: V1State, + req: RespondRequest, + log: Vec, + turns_used: u32, + stats: LoopStats, + /// Phase 20 budget — at most one T3 overseer call per loop + /// invocation. Cloud calls cost real money and the whole point is + /// "hyperfocus local + one strategic cloud nudge", not a cloud + /// retry loop. See docs/CONTROL_PLANE_PRD.md §4.3. + overseer_called: bool, +} + +/// Per-invocation usage accumulator. Separate from the gateway-wide +/// `V1State.usage` (which is lifetime-across-all-requests) so the +/// outcomes row can stamp this-task tokens/latency without subtracting +/// two snapshots. +#[derive(Default, Clone, Serialize)] +pub struct LoopStats { + pub requests: u64, + pub prompt_tokens: u64, + pub completion_tokens: u64, + pub total_tokens: u64, + pub latency_ms: u64, +} + +impl ExecutionLoop { + pub fn new(state: V1State, req: RespondRequest) -> Self { + Self { + state, req, + log: Vec::new(), + turns_used: 0, + stats: LoopStats::default(), + overseer_called: false, + } + } + + pub fn turns_used(&self) -> u32 { + self.turns_used + } + + pub async fn run(&mut self) -> Result { + let outcome = self.run_inner().await?; + Ok(self.finalize(outcome).await) + } + + async fn run_inner(&mut self) -> Result { + let executor_model = self.req.executor_model + .as_deref().unwrap_or(DEFAULT_EXECUTOR_MODEL).to_string(); + let reviewer_model = self.req.reviewer_model + .as_deref().unwrap_or(DEFAULT_REVIEWER_MODEL).to_string(); + let max_turns = self.req.max_turns.unwrap_or(DEFAULT_MAX_TURNS); + + // --- (6) TRUTH GATE — Phase 42 wiring (2026-04-24) --- + // Evaluate truth rules for the request's task_class against a + // ctx built from the spec. Any rule whose condition holds AND + // whose action is Reject/Block short-circuits to Blocked before + // the executor loop runs. Mirrors queryd/service.rs SQL gate. + let truth_store = truth::default_truth_store(); + for outcome in truth_store.evaluate(&self.req.task_class, &self.req.spec) { + if !outcome.passed { continue; } + if let truth::RuleAction::Reject { message } | truth::RuleAction::Block { message } = &outcome.action { + let reason = format!("truth rule {} blocked: {message}", outcome.rule_id); + self.append(LogEntry::new(0, "system", "truth", "block", + serde_json::json!({ "rule_id": outcome.rule_id, "reason": reason.clone() }))); + return Ok(RespondOutcome::Blocked { reason, log: self.log.clone() }); + } + } + + // --- (1) PLAYBOOK BOOST --- + let boost = self.fetch_playbook_boost(&self.req.operation).await.unwrap_or_default(); + if !boost.is_empty() { + self.append(LogEntry::new( + 0, "system", "playbook_memory", "boost_loaded", + serde_json::json!({ "count": boost.len(), "preview": boost.iter().take(3).collect::>() }), + )); + } + + let mut consecutive_drifts: u32 = 0; + + // --- MAIN TURN LOOP --- + for turn in 1..=max_turns { + self.turns_used = turn; + + // --- (2) EXECUTOR TURN --- + let executor_prompt = build_executor_prompt(&self.req, &boost, &self.log); + let executor_raw = self.chat_once(&executor_model, &executor_prompt, 0.2, false).await?; + let exec_action = match parse_action(&executor_raw, Role::Executor) { + Ok(a) => a, + Err(e) => { + self.append(LogEntry::new( + turn, "executor", &executor_model, "error", + serde_json::json!({ "message": e, "raw": truncate(&executor_raw, 400) }), + )); + return Ok(RespondOutcome::Failed { + reason: format!("executor parse failure on turn {turn}: {e}"), + log: std::mem::take(&mut self.log), + }); + } + }; + self.append(LogEntry::new( + turn, "executor", &executor_model, action_kind(&exec_action), action_content(&exec_action), + )); + + // --- (4) TOOL DISPATCH — PORT FROM orchestrator.ts:101-124 --- + // Soft-fail: a tool error is a log entry, not a loop abort. + // The executor reads its own error next turn and self-corrects + // (orchestrator.ts:169-189). Only MAX_CONSECUTIVE_DRIFTS tool + // errors in a row → hard abort. + if let Action::ToolCall { tool, args, .. } = &exec_action { + match self.dispatch_tool(tool, args).await { + Ok(result) => { + let trimmed = trim_result(&result); + self.append(LogEntry::new( + turn, "executor", &executor_model, "tool_result", trimmed, + )); + } + Err(e) => { + self.append(LogEntry::new( + turn, "executor", &executor_model, "tool_result", + serde_json::json!({ "error": e, "tool": tool, "args": args }), + )); + consecutive_drifts += 1; + if consecutive_drifts >= MAX_CONSECUTIVE_DRIFTS { + return Ok(RespondOutcome::Failed { + reason: format!( + "aborting — {MAX_CONSECUTIVE_DRIFTS} consecutive tool errors, executor can't self-correct" + ), + log: std::mem::take(&mut self.log), + }); + } + } + } + } + + // --- (3) REVIEWER TURN --- + let reviewer_prompt = build_reviewer_prompt(&self.req, &self.log); + let reviewer_raw = self.chat_once(&reviewer_model, &reviewer_prompt, 0.1, false).await?; + let rev_action = match parse_action(&reviewer_raw, Role::Reviewer) { + Ok(a) => a, + Err(e) => { + self.append(LogEntry::new( + turn, "reviewer", &reviewer_model, "error", + serde_json::json!({ "message": e, "raw": truncate(&reviewer_raw, 400) }), + )); + return Ok(RespondOutcome::Failed { + reason: format!("reviewer parse failure on turn {turn}: {e}"), + log: std::mem::take(&mut self.log), + }); + } + }; + self.append(LogEntry::new( + turn, "reviewer", &reviewer_model, "critique", action_content(&rev_action), + )); + + let verdict = match &rev_action { + Action::Critique { verdict, .. } => verdict.clone(), + _ => { + return Ok(RespondOutcome::Failed { + reason: format!("reviewer emitted non-critique on turn {turn}"), + log: std::mem::take(&mut self.log), + }); + } + }; + + // --- (5) CONSENSUS DETECTION + DRIFT COUNTER --- + if verdict == Verdict::Drift { + consecutive_drifts += 1; + // --- (8) OVERSEER ESCALATION --- + // One chance before abort: when the local loop is + // about to give up, call the T3 overseer with the KB + // context (what worked / didn't on this task class + // historically) + the recent log tail. The overseer + // emits a correction which feeds back into the next + // executor turn. Only fires once per loop to honor + // Phase 20 "1-3 calls/scenario" budget. + if consecutive_drifts == MAX_CONSECUTIVE_DRIFTS.saturating_sub(1) + && !self.overseer_called + { + if let Err(e) = self.escalate_to_overseer(turn, "drift_approaching_abort").await { + tracing::warn!("overseer escalation failed: {e}"); + } + // Reset so the executor gets one clean turn with + // the correction in context before we re-evaluate. + consecutive_drifts = 0; + } else if consecutive_drifts >= MAX_CONSECUTIVE_DRIFTS { + return Ok(RespondOutcome::Failed { + reason: format!( + "aborting — {MAX_CONSECUTIVE_DRIFTS} consecutive drift flags, executor can't self-correct (overseer_called={})", + self.overseer_called, + ), + log: std::mem::take(&mut self.log), + }); + } + } else { + consecutive_drifts = 0; + } + + if let (Action::ProposeDone { fills, rationale }, Verdict::ApproveDone) + = (&exec_action, &verdict) + { + let target_count = spec_target_count(&self.req.spec); + if target_count > 0 && fills.len() as u64 != target_count { + return Ok(RespondOutcome::Failed { + reason: format!( + "consensus malformed — {} fills vs target {}", + fills.len(), target_count + ), + log: std::mem::take(&mut self.log), + }); + } + self.append(LogEntry::new( + turn, "reviewer", &reviewer_model, "consensus_done", + serde_json::json!({ "fills": fills }), + )); + // Seal + write-through runs in `finalize` after this + // returns — outcomes row + playbook_memory seed with + // retries + stats stamping all land there. + let artifact = serde_json::json!({ + "fills": fills, + "approach": rationale, + "turns": turn, + }); + return Ok(RespondOutcome::Ok { + artifact, + log: std::mem::take(&mut self.log), + }); + } + } + + Ok(RespondOutcome::Failed { + reason: format!("no consensus after {max_turns} turns — task incomplete"), + log: std::mem::take(&mut self.log), + }) + } + + fn append(&mut self, e: LogEntry) { + tracing::debug!(turn = e.turn, role = %e.role, kind = %e.kind, "execution_loop"); + self.log.push(e); + } + + /// Dispatch: model name prefix → provider. + /// Local path uses Phase 21 `generate_continuable` (auto-continuation, + /// retry on empty thinking-model response). Cloud path hits + /// Ollama Cloud directly — no continuation since cloud budgets are + /// generous and Phase 21's Rust port is local-only. Truncation on + /// cloud surfaces as a parse failure in the loop; that's fail-fast + /// and a real signal (we want to know when cloud didn't finish). + async fn chat_once( + &mut self, + model: &str, + prompt: &str, + temperature: f64, + think: bool, + ) -> Result { + let is_cloud = is_cloud_model(model); + let provider = if is_cloud { "ollama_cloud" } else { "ollama" }; + let start_time = chrono::Utc::now(); + let started = std::time::Instant::now(); + + let (text, prompt_tokens, completion_tokens, calls) = if is_cloud { + let key = self.state.ollama_cloud_key.as_deref().ok_or_else(|| { + format!("cloud model {model} requested but OLLAMA_CLOUD_KEY not configured") + })?; + use crate::v1::{ChatRequest, Message}; + // Cloud path: retry up to 3× on empty response. gpt-oss:* + // models sometimes return empty after internal reasoning + // — this is the cloud-side analog of Phase 21's empty- + // response backoff, inlined since generate_continuable is + // local-only. + let mut text = String::new(); + let mut tokens_p = 0u32; + let mut tokens_c = 0u32; + let mut attempts = 0u32; + for attempt in 0..3 { + attempts = attempt + 1; + let req = ChatRequest { + model: model.to_string(), + messages: vec![Message::new_text("user", prompt.to_string())], + temperature: Some(temperature), + max_tokens: None, + stream: Some(false), + think: Some(think), + provider: Some("ollama_cloud".into()), + }; + let resp = crate::v1::ollama_cloud::chat(key, &req).await + .map_err(|e| format!("ollama_cloud: {e}"))?; + tokens_p = tokens_p.saturating_add(resp.usage.prompt_tokens); + tokens_c = tokens_c.saturating_add(resp.usage.completion_tokens); + let t: String = resp.choices.into_iter().next() + .map(|c| c.message.text()).unwrap_or_default(); + if !t.trim().is_empty() { + text = t; + break; + } + tracing::warn!(model = %model, attempt, "cloud returned empty, retrying"); + } + (text, tokens_p, tokens_c, attempts) + } else { + use aibridge::continuation::{generate_continuable, ContinuableOpts, ResponseShape}; + let mut opts = ContinuableOpts::new(model); + opts.temperature = Some(temperature); + opts.think = Some(think); + opts.shape = ResponseShape::Json; + let outcome = generate_continuable(&self.state.ai_client, prompt, &opts).await?; + if outcome.empty_retries > 0 || outcome.continuations > 0 || !outcome.final_complete { + tracing::info!( + model = %model, + empty_retries = outcome.empty_retries, + continuations = outcome.continuations, + final_complete = outcome.final_complete, + calls = outcome.calls, + "execution_loop.chat_once: continuation telemetry" + ); + } + (outcome.text, outcome.prompt_tokens, outcome.completion_tokens, outcome.calls) + }; + + let elapsed_ms = started.elapsed().as_millis() as u64; + let end_time = chrono::Utc::now(); + + // Langfuse trace — uniform across local + cloud, provider tag + // lets the bridge / observer differentiate downstream. + if let Some(lf) = &self.state.langfuse { + use crate::v1::{langfuse_trace::ChatTrace, Message}; + lf.emit_chat(ChatTrace { + provider: provider.to_string(), + model: model.to_string(), + input: vec![Message::new_text("user", prompt.to_string())], + output: text.clone(), + prompt_tokens, + completion_tokens, + temperature: Some(temperature), + max_tokens: None, + think: Some(think), + start_time: start_time.to_rfc3339(), + end_time: end_time.to_rfc3339(), + latency_ms: elapsed_ms, + }); + } + + // Per-task stats (stamps the outcomes row) + gateway-wide + // /v1/usage counters. Both updated uniformly; the by_provider + // split lets operators see the local/cloud mix per task. + let total_tokens = (prompt_tokens + completion_tokens) as u64; + self.stats.requests = self.stats.requests.saturating_add(calls as u64); + self.stats.prompt_tokens = self.stats.prompt_tokens.saturating_add(prompt_tokens as u64); + self.stats.completion_tokens = self.stats.completion_tokens.saturating_add(completion_tokens as u64); + self.stats.total_tokens = self.stats.total_tokens.saturating_add(total_tokens); + self.stats.latency_ms += elapsed_ms; + + { + let mut u = self.state.usage.write().await; + u.requests = u.requests.saturating_add(calls as u64); + u.prompt_tokens = u.prompt_tokens.saturating_add(prompt_tokens as u64); + u.completion_tokens = u.completion_tokens.saturating_add(completion_tokens as u64); + u.total_tokens = u.total_tokens.saturating_add(total_tokens); + let pu = u.by_provider.entry(provider.to_string()).or_default(); + pu.requests = pu.requests.saturating_add(calls as u64); + pu.prompt_tokens = pu.prompt_tokens.saturating_add(prompt_tokens as u64); + pu.completion_tokens = pu.completion_tokens.saturating_add(completion_tokens as u64); + pu.total_tokens = pu.total_tokens.saturating_add(total_tokens); + } + + Ok(text) + } + + /// Final step for every terminal path — write the outcomes row (with + /// the full indicator set stamped) and, on success, seed the playbook + /// back into memory so the next similar task hits the fast path. + /// The write-through is what closes the 0→85% compounding loop. + /// + /// Both writes are best-effort: KB-write failure emits a warn but + /// doesn't convert an Ok into a Failed. The caller's response should + /// reflect what the loop actually accomplished, not whether the log + /// sink was reachable. + async fn finalize(&mut self, mut outcome: RespondOutcome) -> RespondOutcome { + // PORT FROM orchestrator.ts:251-293. On consensus, write-through + // to playbook_memory so the next semantically-similar query + // surfaces the endorsed names. + let seed_outcome = if let RespondOutcome::Ok { artifact, .. } = &outcome { + match self.seed_playbook_memory(artifact).await { + Ok(v) => Some(v), + Err(e) => { + tracing::warn!("playbook_memory seed failed: {e}"); + Some(serde_json::json!({ "error": e })) + } + } + } else { + None + }; + + // Append the outcomes row — polarity derived from the variant, + // indicators stamped from loop state. schema_version=2 flags + // this as a per-task row (distinct from the scenario-level rows + // already in outcomes.jsonl). + let outcomes_row = build_outcomes_row( + &self.req, &self.stats, self.turns_used, + self.overseer_called, + &outcome, seed_outcome.clone(), + ); + if let Err(e) = append_outcomes_row(&outcomes_row).await { + tracing::warn!("outcomes.jsonl append failed: {e}"); + } + + // Enrich the response artifact with the seed + usage info so + // the API caller can see compounding state without a second call. + if let RespondOutcome::Ok { artifact, .. } = &mut outcome { + if let Some(obj) = artifact.as_object_mut() { + if let Some(seed) = seed_outcome { + obj.insert("playbook_seed".into(), seed); + } + obj.insert("usage".into(), serde_json::to_value(&self.stats).unwrap_or_default()); + obj.insert("sig_hash".into(), serde_json::Value::String(sig_hash(&self.req))); + } + } + + outcome + } + + /// PORT FROM orchestrator.ts:255-293. Three retries with geometric + /// backoff. `append: true` routes through Phase 26 upsert semantics + /// (ADD/UPDATE/NOOP on operation+day+city+state), so a re-seal of + /// the same fill on the same day merges names instead of duplicating. + async fn seed_playbook_memory( + &self, + artifact: &serde_json::Value, + ) -> Result { + let fills = artifact.get("fills").and_then(|v| v.as_array()) + .ok_or_else(|| "artifact missing fills".to_string())?; + let endorsed_names: Vec = fills.iter() + .filter_map(|f| f.get("name").and_then(|v| v.as_str()).map(String::from)) + .collect(); + if endorsed_names.is_empty() { + return Err("no endorsed_names to seed".into()); + } + + // Seed context is what the embedding model sees — carry + // task-semantic content (role, city, scenario) not orchestrator + // bookkeeping. Falls back to approach_hint, then to a built + // string from spec. Matches orchestrator.ts:262-263. + let approach = artifact.get("approach").and_then(|v| v.as_str()) + .filter(|s| !s.is_empty()) + .unwrap_or("multi-agent → hybrid search") + .to_string(); + let context = seed_context(&self.req); + + let body = serde_json::json!({ + "operation": self.req.operation, + "approach": approach, + "context": context, + "endorsed_names": endorsed_names, + "append": true, + }); + + let client = reqwest::Client::new(); + let mut last_err = String::new(); + for attempt in 0..3u32 { + match client.post("http://127.0.0.1:3100/vectors/playbook_memory/seed") + .json(&body).send().await + { + Ok(resp) => { + let status = resp.status(); + let text = resp.text().await.unwrap_or_default(); + if status.is_success() { + let j: serde_json::Value = serde_json::from_str(&text) + .unwrap_or(serde_json::json!({ "raw": text })); + return Ok(j); + } + last_err = format!("{}: {}", status, truncate(&text, 200)); + } + Err(e) => last_err = format!("transport: {e}"), + } + // Geometric backoff: 1s, 2s, 3s (matches orchestrator.ts:281). + tokio::time::sleep(std::time::Duration::from_secs(attempt as u64 + 1)).await; + } + Err(format!("after 3 attempts: {last_err}")) + } + + /// Phase 20 step (8) — T3 overseer escalation. + /// + /// When the local executor/reviewer loop can't self-correct, call + /// the cloud overseer (`gpt-oss:120b` via Ollama Cloud) with (a) + /// the KB context — recent outcomes + prior corrections for this + /// sig_hash + task_class, across every profile that has run it — + /// and (b) the recent log tail. Its output is appended as a + /// `system` role turn so the next executor generation sees it, + /// AND written to `data/_kb/overseer_corrections.jsonl` so every + /// future profile activation reads from the same learning pool. + /// + /// This is the "pipe to the overviewer" piece from 2026-04-23 — + /// the overseer is now a first-class KB consumer AND producer, not + /// a one-shot correction oracle. + async fn escalate_to_overseer(&mut self, turn: u32, reason: &str) -> Result<(), String> { + let Some(cloud_key) = self.state.ollama_cloud_key.clone() else { + return Err("OLLAMA_CLOUD_KEY not configured — skipping escalation".into()); + }; + + let kb = KbContext::load_for(&sig_hash(&self.req), &self.req.task_class).await; + let prompt = build_overseer_prompt(&self.req, &kb, &self.log, reason); + + let started = std::time::Instant::now(); + let start_time = chrono::Utc::now(); + let chat_req = crate::v1::ChatRequest { + model: "gpt-oss:120b".to_string(), + messages: vec![crate::v1::Message::new_text("user", prompt.clone())], + temperature: Some(0.1), + max_tokens: None, + stream: Some(false), + think: Some(true), // overseer KEEPS thinking (Phase 20 rule) + provider: Some("ollama_cloud".into()), + }; + let resp = crate::v1::ollama_cloud::chat(&cloud_key, &chat_req).await + .map_err(|e| format!("ollama_cloud: {e}"))?; + let latency_ms = started.elapsed().as_millis() as u64; + let end_time = chrono::Utc::now(); + let correction_text: String = resp.choices.into_iter().next() + .map(|c| c.message.text()).unwrap_or_default(); + + // Stamp per-task stats — cloud call counts against the same + // usage counter so `/v1/usage` shows cloud token spend too. + self.stats.requests = self.stats.requests.saturating_add(1); + self.stats.prompt_tokens = self.stats.prompt_tokens.saturating_add(resp.usage.prompt_tokens as u64); + self.stats.completion_tokens = self.stats.completion_tokens.saturating_add(resp.usage.completion_tokens as u64); + self.stats.total_tokens = self.stats.total_tokens.saturating_add(resp.usage.total_tokens as u64); + self.stats.latency_ms = self.stats.latency_ms.saturating_add(latency_ms); + + // Langfuse trace for the overseer call (same pipe that feeds + // the observer/KB, so this correction's cost lands in the KB + // too — closing the loop). + if let Some(lf) = &self.state.langfuse { + use crate::v1::langfuse_trace::ChatTrace; + lf.emit_chat(ChatTrace { + provider: "ollama_cloud".into(), + model: "gpt-oss:120b".into(), + input: vec![crate::v1::Message::new_text("user", prompt.clone())], + output: correction_text.clone(), + prompt_tokens: resp.usage.prompt_tokens, + completion_tokens: resp.usage.completion_tokens, + temperature: Some(0.1), + max_tokens: None, + think: Some(true), + start_time: start_time.to_rfc3339(), + end_time: end_time.to_rfc3339(), + latency_ms, + }); + } + + // Append to the transcript so the next executor turn sees it. + self.append(LogEntry::new( + turn, "system", "gpt-oss:120b", "overseer_correction", + serde_json::json!({ + "reason": reason, + "correction": correction_text, + "kb_context_summary": { + "total_observed": kb.total_observed, + "success_rate": kb.success_rate, + "prior_corrections": kb.recent_corrections.len(), + }, + }), + )); + + // Write to the KB — read by KbContext::load_for on every + // subsequent escalation, AND by any profile that iterates on + // this task class later. + let row = serde_json::json!({ + "schema_version": 2, + "source_service": "v1.respond.overseer", + "sig_hash": sig_hash(&self.req), + "task_class": self.req.task_class, + "operation": self.req.operation, + "reason": reason, + "model": "gpt-oss:120b", + "correction": correction_text, + "applied_at_turn": turn, + "kb_context_used": kb, + "usage": { + "prompt_tokens": resp.usage.prompt_tokens, + "completion_tokens": resp.usage.completion_tokens, + "total_tokens": resp.usage.total_tokens, + "latency_ms": latency_ms, + }, + "created_at": chrono::Utc::now().to_rfc3339(), + }); + if let Err(e) = append_corrections_row(&row).await { + tracing::warn!("overseer_corrections.jsonl append failed: {e}"); + } + + self.overseer_called = true; + Ok(()) + } + + async fn fetch_playbook_boost(&self, operation: &str) -> Result, ()> { + let body = serde_json::json!({ "operation": operation, "top_k": 5 }); + let client = reqwest::Client::new(); + let resp = client + .post("http://127.0.0.1:3100/vectors/playbook_memory/search") + .json(&body) + .send().await.map_err(|_| ())?; + if !resp.status().is_success() { + return Ok(Vec::new()); + } + let j: serde_json::Value = resp.json().await.map_err(|_| ())?; + Ok(j.get("boosts").and_then(|v| v.as_array()).cloned().unwrap_or_default()) + } + + /// PORT FROM orchestrator.ts:101-124 + agent.ts:348-364. + /// Three tool surfaces unified behind one dispatcher: + /// - `hybrid_search` → `POST /vectors/hybrid` (pseudo-tool, not in + /// the Phase 12 registry — lives in vectord) + /// - `sql` → `POST /query/sql` with a SELECT-only guard + /// - anything else → `POST /tools/{name}/call` via the Phase 12 + /// registry (permissions, audit, validation all happen there) + /// + /// Loopback HTTP on 127.0.0.1:3100 on purpose: mirrors the TS + /// behavior exactly (every call goes through the same middleware, + /// auth, audit, CORS path), and lets us swap to in-process routing + /// later without changing the dispatch contract. + async fn dispatch_tool( + &self, + tool: &str, + args: &serde_json::Value, + ) -> Result { + let client = reqwest::Client::new(); + match tool { + "hybrid_search" => { + let sql_filter = args.get("sql_filter").and_then(|v| v.as_str()) + .ok_or_else(|| "hybrid_search needs sql_filter (string)".to_string())?; + let question = args.get("question").and_then(|v| v.as_str()) + .ok_or_else(|| "hybrid_search needs question (string)".to_string())?; + let index_name = args.get("index_name").and_then(|v| v.as_str()) + .ok_or_else(|| "hybrid_search needs index_name (string)".to_string())?; + // Accept either `top_k` or `k` from the model — same + // tolerance as orchestrator.ts. Default 10. + let top_k = args.get("top_k").or_else(|| args.get("k")) + .and_then(|v| v.as_u64()).unwrap_or(10); + let body = serde_json::json!({ + "sql_filter": sql_filter, + "question": question, + "index_name": index_name, + "top_k": top_k, + "generate": false, + }); + let resp = client.post("http://127.0.0.1:3100/vectors/hybrid") + .json(&body).send().await + .map_err(|e| format!("hybrid_search transport: {e}"))?; + parse_tool_response(resp).await + } + "sql" => { + let query = args.get("query").and_then(|v| v.as_str()) + .ok_or_else(|| "sql needs query (string)".to_string())?; + // SELECT-only guard mirroring orchestrator.ts:119. The + // tool is read-only; any mutation needs the Phase 12 + // registry + its permission + audit flow, not the + // unchecked raw sql surface. + if !query.trim_start().to_ascii_uppercase().starts_with("SELECT") { + return Err(format!("sql tool allows SELECT only: {}", truncate(query, 120))); + } + let body = serde_json::json!({ "sql": query, "format": "json" }); + let resp = client.post("http://127.0.0.1:3100/query/sql") + .json(&body).send().await + .map_err(|e| format!("sql transport: {e}"))?; + parse_tool_response(resp).await + } + other => { + // Phase 12 registry — any registered staffing tool lands here. + // Body shape matches agent.ts::callTool (POST /tools/{name}/call + // with {params, agent}). + let url = format!("http://127.0.0.1:3100/tools/{}/call", other); + let body = serde_json::json!({ + "params": args, + "agent": "v1.respond", + }); + let resp = client.post(&url).json(&body).send().await + .map_err(|e| format!("{other} transport: {e}"))?; + parse_tool_response(resp).await + } + } + } +} + +/// Read a tool response body into JSON, or surface the status + text +/// as an error. Keeps the `error` path structurally identical whether +/// the transport fails (caller handles), the server 5xx's (here), or +/// the tool returns a 200 with an `{"error":"..."}` payload (caller +/// surfaces to the executor as normal tool_result content). +async fn parse_tool_response(resp: reqwest::Response) -> Result { + let status = resp.status(); + let text = resp.text().await.map_err(|e| format!("body read: {e}"))?; + if !status.is_success() { + return Err(format!("{}: {}", status, truncate(&text, 300))); + } + serde_json::from_str(&text) + .map_err(|e| format!("non-JSON response: {e} | body: {}", truncate(&text, 200))) +} + +fn seed_context(req: &RespondRequest) -> String { + let hint = spec_field_str(&req.spec, "approach_hint"); + if !hint.is_empty() { + return hint.to_string(); + } + let role = spec_field_str(&req.spec, "target_role"); + let city = spec_field_str(&req.spec, "target_city"); + let state = spec_field_str(&req.spec, "target_state"); + if !role.is_empty() && !city.is_empty() { + return format!("{role} fill in {city}, {state}"); + } + // Non-staffing task class — use the operation verbatim. The + // embedding surface still works; it just has less geo signal. + req.operation.clone() +} + +/// Stable rollup key. PORT FROM the sig_hash usage in observer/kb. +/// DefaultHasher isn't cryptographic but is stable for a single +/// deployment and matches the 16-char hex format already in +/// outcomes.jsonl. Swap to sha256 if cross-deployment stability is +/// needed. +fn sig_hash(req: &RespondRequest) -> String { + use std::hash::{Hash, Hasher}; + let mut h = std::collections::hash_map::DefaultHasher::new(); + req.task_class.hash(&mut h); + req.operation.hash(&mut h); + spec_field_str(&req.spec, "target_role").hash(&mut h); + spec_field_str(&req.spec, "target_city").hash(&mut h); + spec_field_str(&req.spec, "target_state").hash(&mut h); + format!("{:016x}", h.finish()) +} + +/// Build the per-task outcomes row with every indicator the +/// 2026-04-23 audit called out. schema_version=2 distinguishes +/// per-task rows from the scenario-level rows already in the file. +fn build_outcomes_row( + req: &RespondRequest, + stats: &LoopStats, + turns_used: u32, + overseer_called: bool, + outcome: &RespondOutcome, + seed_outcome: Option, +) -> serde_json::Value { + let (ok, polarity, error) = match outcome { + RespondOutcome::Ok { .. } => (true, "success_confirmation", serde_json::Value::Null), + RespondOutcome::Failed { reason, .. } => (false, "failure_pattern", serde_json::Value::String(reason.clone())), + RespondOutcome::Blocked { reason, .. } => (false, "truth_block", serde_json::Value::String(reason.clone())), + }; + let fills = match outcome { + RespondOutcome::Ok { artifact, .. } => artifact.get("fills").cloned().unwrap_or(serde_json::Value::Null), + _ => serde_json::Value::Null, + }; + + // Correction effectiveness: if the overseer was called this loop, + // the outcome tells us whether the correction helped. OK = it + // worked, Failed/Blocked = it didn't. When overseer wasn't called, + // these fields stay null so aggregators can filter cleanly. + let correction_applied = overseer_called; + let correction_effective = if overseer_called { + serde_json::Value::Bool(ok) + } else { + serde_json::Value::Null + }; + + serde_json::json!({ + "schema_version": 2, + "source_service": "v1.respond", + "sig_hash": sig_hash(req), + "task_class": req.task_class, + "operation": req.operation, + "ok": ok, + "polarity": polarity, + "iterations": turns_used, + "turns": turns_used, + "fills": fills, + "models": { + "executor": req.executor_model.clone().unwrap_or_else(|| DEFAULT_EXECUTOR_MODEL.to_string()), + "reviewer": req.reviewer_model.clone().unwrap_or_else(|| DEFAULT_REVIEWER_MODEL.to_string()), + }, + "usage": stats, + "provider": "ollama", + "playbook_seed": seed_outcome, + "truth_rule_citations": [], // Phase 42 gate hook — empty until wired + "validator_report": null, // Phase 43 hook + "correction_applied": correction_applied, + "correction_effective": correction_effective, + "error": error, + "created_at": chrono::Utc::now().to_rfc3339(), + }) +} + +/// PORT FROM Phase 20's T3 overseer prompt shape. The overseer sees: +/// - Task + spec +/// - KB context (historical outcomes + prior corrections across +/// every profile that ran this task class) +/// - Recent log tail (last 12 turns) +/// - Specific reason the local loop escalated +/// It returns prose guidance the executor reads next turn. We do NOT +/// ask it to emit a JSON action — the executor still owns the final +/// shape. The overseer is a strategist, not a tool-caller. +fn build_overseer_prompt( + req: &RespondRequest, + kb: &KbContext, + log: &[LogEntry], + reason: &str, +) -> String { + let mut p = String::new(); + p.push_str("You are the OVERSEER (T3 strategic tier). The local executor/reviewer loop has hit a wall and escalated to you for a strategic correction. You do not call tools; you read the record and tell the executor what to do differently on its next turn.\n\n"); + p.push_str(&format!("## Task\n{}\n", req.operation)); + p.push_str(&format!("Task class: {}\n", req.task_class)); + if !req.spec.is_null() { + p.push_str(&format!("Spec: {}\n", req.spec)); + } + p.push_str(&format!("\n## Reason for escalation\n{}\n\n", reason)); + + p.push_str(&kb.to_prompt_section()); + + p.push_str("\n## Recent log (last 12 turns, most recent last):\n"); + let start = log.len().saturating_sub(12); + for e in &log[start..] { + let content = e.content.to_string(); + p.push_str(&format!( + " [t{:02} {} {}] {}\n", + e.turn, e.role, e.kind, truncate(&content, 200), + )); + } + + p.push_str("\n## Your output\n"); + p.push_str("Write 3-6 sentences of CONCRETE guidance the executor will read next turn. "); + p.push_str("Reference what specifically went wrong, what to try instead, and what to AVOID "); + p.push_str("(especially if it appears in the \"Recent overseer corrections\" above — don't repeat yourself). "); + p.push_str("No JSON, no tool syntax — the executor will translate your guidance into action.\n"); + p +} + +async fn append_corrections_row(row: &serde_json::Value) -> Result<(), String> { + append_outcomes_row_at( + std::path::Path::new("data/_kb/overseer_corrections.jsonl"), + row, + ).await +} + +/// Append one JSONL row to `data/_kb/outcomes.jsonl`. Creates the +/// directory if missing. Same write shape as the TS pipeline; the +/// Phase 24 observer fix taught us `/ingest/file` has REPLACE +/// semantics, so this writes the JSONL directly — APPEND, not replace. +async fn append_outcomes_row(row: &serde_json::Value) -> Result<(), String> { + append_outcomes_row_at(std::path::Path::new("data/_kb/outcomes.jsonl"), row).await +} + +/// Path-taking variant — lets tests write to a tmp path without +/// mutating the process CWD (which isn't thread-safe under parallel +/// test execution). +async fn append_outcomes_row_at( + path: &std::path::Path, + row: &serde_json::Value, +) -> Result<(), String> { + use tokio::io::AsyncWriteExt; + + if let Some(dir) = path.parent() { + tokio::fs::create_dir_all(dir).await.map_err(|e| format!("mkdir: {e}"))?; + } + let mut line = serde_json::to_string(row).map_err(|e| format!("serialize: {e}"))?; + line.push('\n'); + let mut f = tokio::fs::OpenOptions::new() + .create(true).append(true).open(path).await + .map_err(|e| format!("open: {e}"))?; + f.write_all(line.as_bytes()).await.map_err(|e| format!("write: {e}"))?; + // Explicit flush + sync before drop. tokio::fs::File uses a + // threadpool; plain drop doesn't guarantee the write is + // durable by the time the next open sees the file, which + // surfaced as a 3/8 flake on the back-to-back-append test. + f.flush().await.map_err(|e| format!("flush: {e}"))?; + Ok(()) +} + +/// PORT FROM orchestrator.ts:306-311. Cap `rows` at 20 entries and +/// annotate the truncation so the executor sees it on the next turn +/// prompt — prevents a 1000-row hybrid_search result from wiping the +/// context budget on a single tool call. +fn trim_result(r: &serde_json::Value) -> serde_json::Value { + if let Some(rows) = r.get("rows").and_then(|v| v.as_array()) { + if rows.len() > 20 { + let mut truncated = r.clone(); + if let Some(obj) = truncated.as_object_mut() { + obj.insert("rows".into(), serde_json::Value::Array(rows.iter().take(20).cloned().collect())); + obj.insert("_trimmed".into(), serde_json::Value::String( + format!("{} more rows", rows.len() - 20), + )); + } + return truncated; + } + } + r.clone() +} + +// --- Parsing + prompt builders (PORT FROM agent.ts:566-698) --- + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum Role { Executor, Reviewer } + +/// PORT FROM agent.ts:650. Strip ```json fences, find the first {...} +/// block, soft-fix the two common model mistakes: stray `)}`, trailing +/// commas. Reviewer shape tolerance: bare `kind: "approve_done"` gets +/// normalized to `{kind: "critique", verdict: "approve_done"}` — some +/// models (qwen2.5) emit that way and the semantic content is identical. +pub fn parse_action(raw: &str, role: Role) -> Result { + let mut s = raw.trim().to_string(); + if let Some(stripped) = s.strip_prefix("```json") { + s = stripped.trim_start_matches('\n').to_string(); + } else if let Some(stripped) = s.strip_prefix("```") { + s = stripped.trim_start_matches('\n').to_string(); + } + if let Some(stripped) = s.strip_suffix("```") { + s = stripped.trim_end().to_string(); + } + let start = s.find('{').ok_or_else(|| format!("no JSON object in {role:?} response: {}", truncate(raw, 300)))?; + let end = s.rfind('}').ok_or_else(|| format!("no closing brace in {role:?} response: {}", truncate(raw, 300)))?; + if end <= start { + return Err(format!("no JSON object in {role:?} response: {}", truncate(raw, 300))); + } + + // Soft-fix: stray ")}" (qwen2.5 tool_call quirk) + trailing commas. + let mut json = s[start..=end].to_string(); + json = json.replace(")}", "}"); + json = fix_trailing_commas(&json); + + let obj: serde_json::Value = serde_json::from_str(&json) + .map_err(|e| format!("invalid JSON from {role:?}: {e} | raw: {}", truncate(&json, 300)))?; + + let kind = obj.get("kind").and_then(|v| v.as_str()).unwrap_or("").to_string(); + + match role { + Role::Executor => match kind.as_str() { + "plan" | "tool_call" | "propose_done" => { + serde_json::from_value(obj).map_err(|e| format!("executor shape mismatch: {e}")) + } + _ => Err(format!("executor returned unexpected shape: {}", truncate(&obj.to_string(), 200))), + }, + Role::Reviewer => { + // Accept the wrapped shape: {kind:"critique", verdict:"continue"|...} + if kind == "critique" { + return serde_json::from_value(obj) + .map_err(|e| format!("reviewer shape mismatch: {e}")); + } + // Accept the bare-verdict shape: {kind:"approve_done", notes:"..."} + if matches!(kind.as_str(), "continue" | "drift" | "approve_done") { + let verdict = match kind.as_str() { + "continue" => Verdict::Continue, + "drift" => Verdict::Drift, + "approve_done" => Verdict::ApproveDone, + _ => unreachable!(), + }; + let notes = obj.get("notes").and_then(|v| v.as_str()).unwrap_or("").to_string(); + return Ok(Action::Critique { verdict, notes }); + } + Err(format!("reviewer returned unexpected shape: {}", truncate(&obj.to_string(), 200))) + } + } +} + +/// Remove `,` immediately followed by `}` or `]` (with optional whitespace). +/// Same intent as the TS regex `,(\s*[}\]])`. +fn fix_trailing_commas(s: &str) -> String { + let bytes = s.as_bytes(); + let mut out = String::with_capacity(s.len()); + let mut i = 0; + while i < bytes.len() { + if bytes[i] == b',' { + let mut j = i + 1; + while j < bytes.len() && bytes[j].is_ascii_whitespace() { j += 1; } + if j < bytes.len() && (bytes[j] == b'}' || bytes[j] == b']') { + // skip the comma + i += 1; + continue; + } + } + out.push(bytes[i] as char); + i += 1; + } + out +} + +fn action_kind(a: &Action) -> &'static str { + match a { + Action::Plan { .. } => "plan", + Action::ToolCall { .. } => "tool_call", + Action::ProposeDone { .. } => "propose_done", + Action::Critique { .. } => "critique", + } +} + +fn action_content(a: &Action) -> serde_json::Value { + serde_json::to_value(a).unwrap_or(serde_json::Value::Null) +} + +/// Returns true if the model name belongs to Ollama Cloud. Prefix-based +/// so new cloud models are pickable by name without a config update — +/// match the rough family prefixes Phase 20's matrix declares. +/// `qwen3.5:397b` lives in the cloud; `qwen3.5:latest` is local — +/// hence the `:3` suffix check rather than matching all of `qwen3.5:`. +pub fn is_cloud_model(model: &str) -> bool { + model.starts_with("gpt-oss:") + || model.starts_with("qwen3-coder:") + || model.starts_with("qwen3.5:3") + || model.starts_with("kimi-") + || model.starts_with("kimi/") +} + +fn truncate(s: &str, n: usize) -> String { + if s.len() <= n { s.to_string() } else { format!("{}…", &s[..n]) } +} + +fn spec_field_str<'a>(spec: &'a serde_json::Value, key: &str) -> &'a str { + spec.get(key).and_then(|v| v.as_str()).unwrap_or("") +} + +fn spec_target_count(spec: &serde_json::Value) -> u64 { + spec.get("target_count").and_then(|v| v.as_u64()).unwrap_or(0) +} + +/// PORT FROM agent.ts:566. Same structural shape: operation + target + +/// candidates-surfaced hint + recent log + ONE-JSON-action instruction. +/// Staffing-specific fields degrade gracefully when spec is empty (non- +/// staffing task classes still get a usable prompt, just without the +/// target_role / target_count scaffolding). +fn build_executor_prompt( + req: &RespondRequest, + boost: &[serde_json::Value], + log: &[LogEntry], +) -> String { + let target_role = spec_field_str(&req.spec, "target_role"); + let target_count = spec_target_count(&req.spec); + let target_city = spec_field_str(&req.spec, "target_city"); + let target_state = spec_field_str(&req.spec, "target_state"); + let approach_hint = spec_field_str(&req.spec, "approach_hint"); + + let mut p = String::new(); + p.push_str("You are the EXECUTOR agent. Your job is to complete this task:\n\n"); + p.push_str(&format!("OPERATION: {}\n", req.operation)); + if target_count > 0 && !target_role.is_empty() { + p.push_str(&format!( + "TARGET: {target_count} × {target_role} in {target_city}, {target_state}\n" + )); + } else { + p.push_str(&format!("TASK CLASS: {}\n", req.task_class)); + if !req.spec.is_null() { + p.push_str(&format!("SPEC: {}\n", req.spec)); + } + } + if !approach_hint.is_empty() { + p.push_str(&format!("HINT: {approach_hint}\n")); + } + p.push_str("\nThe REVIEWER agent is watching every turn. They will flag drift. Stay on target.\n\n"); + + if !boost.is_empty() { + p.push_str("SIMILAR PAST PLAYBOOKS (reference, not prescription):\n"); + for (i, b) in boost.iter().take(3).enumerate() { + p.push_str(&format!(" {}. {}\n", i + 1, b)); + } + p.push('\n'); + } + + // Orchestrator-tracked candidate memory (agent.ts:568). The log- + // render cap chops tool_result content, so the executor can't + // always see what earlier searches returned. This block is a + // durable rollup — every candidate the loop has seen, formatted + // for prompt reading. Critical for letting the executor reach + // propose_done instead of re-searching. + let seen = candidates_seen(log); + p.push_str("CANDIDATES SURFACED SO FAR (orchestrator-tracked, do not forget):\n"); + if seen.is_empty() { + p.push_str(" (none yet — start with hybrid_search)\n"); + } else { + p.push_str(" # Use the name + city + state for sql verification (NOT doc_id — that's the vector-index key, not workers_500k.worker_id)\n"); + for c in seen.iter().take(30) { + p.push_str(&format!(" - name=\"{}\" city=\"{}\" state=\"{}\" (vector doc_id={})\n", + c.name, c.city, c.state, c.doc_id)); + } + if seen.len() > 30 { + p.push_str(&format!(" ... {} more surfaced\n", seen.len() - 30)); + } + } + p.push('\n'); + + p.push_str("SHARED LOG (recent turns):\n"); + p.push_str(&render_log_for_prompt(log, 8)); + p.push('\n'); + + p.push_str("AVAILABLE TOOLS (use tool_call with these exact names — DO NOT invent others):\n"); + p.push_str(" hybrid_search(sql_filter: string, question: string, index_name: string, k?: number)\n"); + p.push_str(" SQL-narrow + vector-rerank. Use for: \"find candidates matching criteria X, ranked by semantic match to Y\".\n"); + p.push_str(" For staffing fills, index_name is typically \"w500k_b18\" or \"w500k_b3\" (workers_500k).\n"); + p.push_str(" Example: {\"tool\":\"hybrid_search\",\"args\":{\"sql_filter\":\"role='Welder' AND city='Toledo' AND state='OH'\",\"question\":\"reliable welders with OSHA certs\",\"index_name\":\"w500k_b18\",\"k\":10},\"rationale\":\"pull top 10 welder candidates in Toledo\"}\n"); + p.push_str(" sql(query: string) — SELECT-only. Use for: verification queries before propose_done.\n"); + p.push_str(" IMPORTANT: workers_500k.worker_id is an INTEGER internal key — NOT the doc_id from hybrid_search.\n"); + p.push_str(" To verify a candidate from hybrid_search results, query by name+city+state (which ARE in the chunk_text you already received):\n"); + p.push_str(" Example: {\"tool\":\"sql\",\"args\":{\"query\":\"SELECT worker_id, name, role FROM workers_500k WHERE name = 'Donna Hall' AND city = 'Columbus' AND state = 'OH' LIMIT 1\"},\"rationale\":\"confirm Donna Hall exists as a Warehouse Associate in Columbus\"}\n\n"); + p.push_str("Your next action MUST be a JSON object matching one of these shapes:\n"); + p.push_str("{\"kind\":\"plan\",\"steps\":[\"short step 1\",\"short step 2\"]}\n"); + p.push_str("{\"kind\":\"tool_call\",\"tool\":\"...\",\"args\":{...},\"rationale\":\"why\"}\n"); + if target_count > 0 { + p.push_str(&format!( + "{{\"kind\":\"propose_done\",\"fills\":[{{\"candidate_id\":\"...\",\"name\":\"First Last\"}}],\"rationale\":\"...\"}} — fills MUST have EXACTLY {target_count} entries.\n" + )); + } else { + p.push_str("{\"kind\":\"propose_done\",\"fills\":[...],\"rationale\":\"...\"}\n"); + } + if target_count > 0 { + p.push_str(&format!( + "\nSTRATEGY: once prior tool_result rows contain ≥ {target_count} candidates in {target_city}, {target_state} matching role \"{target_role}\", STOP SEARCHING. Pick the top {target_count} by score, verify ONE via `sql` tool, then emit propose_done. Do NOT repeat hybrid_search if you already have enough candidates.\n" + )); + } + p.push_str("\nRespond with ONLY the JSON object. No markdown fences, no prose.\n"); + p +} + +/// PORT FROM agent.ts:602. Reviewer prompt with the `awaitingApproval` +/// hard rule: if the most recent executor action was propose_done, the +/// reviewer cannot emit `continue` (would stall the loop). +fn build_reviewer_prompt(req: &RespondRequest, log: &[LogEntry]) -> String { + let target_role = spec_field_str(&req.spec, "target_role"); + let target_count = spec_target_count(&req.spec); + let target_city = spec_field_str(&req.spec, "target_city"); + let target_state = spec_field_str(&req.spec, "target_state"); + + let last_executor_kind = log.iter().rev() + .find(|e| e.role == "executor") + .map(|e| e.kind.as_str()) + .unwrap_or(""); + let awaiting_approval = last_executor_kind == "propose_done"; + + let mut p = String::new(); + p.push_str("You are the REVIEWER agent. The EXECUTOR is trying to complete this task:\n\n"); + p.push_str(&format!("OPERATION: {}\n", req.operation)); + if target_count > 0 && !target_role.is_empty() { + p.push_str(&format!( + "TARGET: {target_count} × {target_role} in {target_city}, {target_state}\n\n" + )); + } + p.push_str("Your job: catch drift. Agents often wander from the actual objective. Specifically watch for:\n"); + if target_count > 0 && !target_city.is_empty() { + p.push_str(&format!("- Proposing candidates who aren't in {target_city}, {target_state}.\n")); + p.push_str(&format!("- Proposing candidates who don't have {target_role} skill.\n")); + p.push_str(&format!("- Proposing fewer or more than {target_count} fills.\n")); + } else { + p.push_str("- Drifting from the stated task class or spec.\n"); + } + p.push_str("- Irrelevant tool calls.\n\n"); + + p.push_str("SHARED LOG (recent turns):\n"); + p.push_str(&render_log_for_prompt(log, 10)); + p.push('\n'); + + p.push_str("Your next action MUST be a JSON object:\n"); + p.push_str("{\"kind\":\"critique\",\"verdict\":\"continue\" | \"drift\" | \"approve_done\",\"notes\":\"...\"}\n\n"); + p.push_str("- \"continue\" → executor is on a reasonable path, let them keep going.\n"); + p.push_str("- \"drift\" → executor is off-track; notes MUST tell them how to redirect.\n"); + p.push_str("- \"approve_done\" → executor's propose_done meets the criteria. Seal it.\n\n"); + if target_count > 0 { + p.push_str(&format!( + "APPROVAL CRITERIA (use only for propose_done):\n\ + 1. Exactly {target_count} fills.\n\ + 2. Each fill's name appears in a prior tool_result from {target_city}, {target_state} matching role \"{target_role}\".\n\ + 3. Executor has SQL-verified at least one fill.\n\ + If 1-3 all hold, return approve_done.\n" + )); + } + if awaiting_approval { + p.push_str("\nHARD RULE: The executor's most recent action was propose_done. On this turn you CANNOT return \"continue\" — it would stall the task. Choose approve_done or drift (state which criterion failed in notes).\n"); + } + + // Loop-detection: if the executor has tool_called ≥ 3 times since + // the last propose_done without proposing, it's stuck in a search + // loop. Reviewer rubber-stamping "continue" here is the failure + // pattern the 2026-04-23 battery surfaced in phase α task 2 — + // 12 turns, 0 proposes, 100% reviewer:continue. + let stuck_tool_calls = tool_calls_since_last_propose(log); + if stuck_tool_calls >= 3 { + p.push_str(&format!( + "\nLOOP DETECTION: The executor has called tools {stuck_tool_calls} times without proposing done. \ + Look at the CANDIDATES SURFACED SO FAR (visible in executor's view): if there are already ≥ {} \ + matching candidates in {target_city}, {target_state} for role \"{target_role}\", respond with \ + verdict=\"drift\" and notes=\"You have enough candidates — pick the top {} by score and emit \ + propose_done this turn. Stop re-searching.\"\n", + target_count, target_count, + )); + } + + p.push_str("\nRespond with ONLY the JSON object.\n"); + p +} + +fn render_log_for_prompt(log: &[LogEntry], tail: usize) -> String { + if log.is_empty() { + return "(no prior turns)\n".into(); + } + let start = log.len().saturating_sub(tail); + let mut s = String::new(); + for e in &log[start..] { + let content = e.content.to_string(); + // tool_result is the executor's eyes — candidate data lives + // there and a 160-char cap chops off every name/doc_id the + // executor needs for propose_done. Keep these generous; cap + // other kinds tighter since they're decision/status entries + // and don't carry payload the executor will re-read. + let cap = if e.kind == "tool_result" { 1200 } else { 200 }; + s.push_str(&format!( + " [t{:02} {} {}] {}\n", + e.turn, e.role, e.kind, truncate(&content, cap) + )); + } + s +} + +/// Ports agent.ts:538 `candidatesSeen`. Walks tool_result entries, +/// parses `sources[].chunk_text` for the staffing "Name — Role in +/// City, ST" shape, dedupes by doc_id. Returns an orchestrator-tracked +/// surface the executor prompt can show verbatim — stopping the +/// executor from "forgetting" candidates when the log-render truncates. +fn candidates_seen(log: &[LogEntry]) -> Vec { + let mut out: Vec = Vec::new(); + let mut seen_ids: std::collections::HashSet = std::collections::HashSet::new(); + for e in log { + if e.kind != "tool_result" { continue; } + let Some(sources) = e.content.get("sources").and_then(|v| v.as_array()) else { continue }; + for s in sources { + let Some(doc_id) = s.get("doc_id").and_then(|v| v.as_str()) else { continue }; + if seen_ids.contains(doc_id) { continue; } + let chunk_text = s.get("chunk_text").and_then(|v| v.as_str()).unwrap_or(""); + let Some((name_part, rest)) = chunk_text.split_once('—') else { continue }; + let name = name_part.trim().to_string(); + let loc = rest.split_once(" in ").map(|(_, r)| r).unwrap_or(""); + let Some((city, state_raw)) = loc.split_once(',') else { continue }; + let city = city.trim().to_string(); + let state = state_raw + .trim() + .chars() + .take_while(|c| c.is_alphabetic()) + .collect::(); + if name.is_empty() || city.is_empty() || state.is_empty() { continue; } + seen_ids.insert(doc_id.to_string()); + out.push(CandidateHint { + doc_id: doc_id.to_string(), + name, + city, + state, + }); + } + } + out +} + +#[derive(Debug, Clone)] +struct CandidateHint { + doc_id: String, + name: String, + city: String, + state: String, +} + +/// Count executor tool_calls since the last propose_done (or since +/// loop start if none). Used by the reviewer prompt to flag stuck +/// search loops — if an executor has tool_called ≥ 3× without +/// proposing, the reviewer should verdict:drift with a stop-searching +/// note rather than rubber-stamping continue. +fn tool_calls_since_last_propose(log: &[LogEntry]) -> u32 { + let mut count = 0u32; + for e in log.iter().rev() { + if e.role != "executor" { continue; } + if e.kind == "propose_done" { break; } + if e.kind == "tool_call" { count += 1; } + } + count +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn log_entry_serializes_to_orchestrator_shape() { + let e = LogEntry::new(3, "executor", "qwen3.5:latest", "tool_call", + serde_json::json!({"tool": "hybrid_search"})); + let j = serde_json::to_value(&e).unwrap(); + for k in ["turn", "role", "kind", "model", "content", "at"] { + assert!(j.get(k).is_some(), "missing field: {k}"); + } + } + + #[test] + fn outcome_into_log_is_lossless() { + let e = LogEntry::new(1, "system", "m", "boost_loaded", serde_json::json!({})); + let o = RespondOutcome::Failed { reason: "scaffold".into(), log: vec![e] }; + assert_eq!(o.into_log().len(), 1); + } + + #[test] + fn parse_executor_plan() { + let raw = r#"{"kind":"plan","steps":["hybrid_search","verify","propose_done"]}"#; + let a = parse_action(raw, Role::Executor).unwrap(); + match a { + Action::Plan { steps } => assert_eq!(steps.len(), 3), + _ => panic!("wrong variant"), + } + } + + #[test] + fn parse_executor_tool_call_with_stray_paren() { + // Mimics the qwen2.5 quirk where the model closes with ")}" — + // agent.ts:666 has the same fix. PORT from TS test territory. + let raw = r#"{"kind":"tool_call","tool":"sql","args":{"query":"SELECT 1"},"rationale":"verify")}"#; + let a = parse_action(raw, Role::Executor).unwrap(); + match a { + Action::ToolCall { tool, .. } => assert_eq!(tool, "sql"), + _ => panic!("wrong variant"), + } + } + + #[test] + fn parse_executor_propose_done_with_fence() { + let raw = "```json\n{\"kind\":\"propose_done\",\"fills\":[{\"candidate_id\":\"W-1\",\"name\":\"A B\"}],\"rationale\":\"ok\"}\n```"; + let a = parse_action(raw, Role::Executor).unwrap(); + match a { + Action::ProposeDone { fills, .. } => { + assert_eq!(fills.len(), 1); + assert_eq!(fills[0].candidate_id, "W-1"); + } + _ => panic!("wrong variant"), + } + } + + #[test] + fn parse_reviewer_wrapped_verdict() { + let raw = r#"{"kind":"critique","verdict":"approve_done","notes":"ok"}"#; + let a = parse_action(raw, Role::Reviewer).unwrap(); + match a { + Action::Critique { verdict, .. } => assert_eq!(verdict, Verdict::ApproveDone), + _ => panic!("wrong variant"), + } + } + + #[test] + fn parse_reviewer_bare_verdict_normalizes() { + // agent.ts:690-694 — qwen2.5/mistral emit the verdict as `kind`. + let raw = r#"{"kind":"drift","notes":"wrong city"}"#; + let a = parse_action(raw, Role::Reviewer).unwrap(); + match a { + Action::Critique { verdict, notes } => { + assert_eq!(verdict, Verdict::Drift); + assert_eq!(notes, "wrong city"); + } + _ => panic!("wrong variant"), + } + } + + #[test] + fn parse_reviewer_rejects_unknown_verdict() { + let raw = r#"{"kind":"maybe","notes":"?"}"#; + assert!(parse_action(raw, Role::Reviewer).is_err()); + } + + #[test] + fn parse_trailing_comma() { + let raw = r#"{"kind":"plan","steps":["a","b",]}"#; + assert!(parse_action(raw, Role::Executor).is_ok()); + } + + #[test] + fn parse_no_json_errors_cleanly() { + let raw = "sorry I cannot comply"; + let err = parse_action(raw, Role::Executor).unwrap_err(); + assert!(err.contains("no JSON")); + } + + #[test] + fn candidates_seen_parses_sources() { + let log = vec![ + LogEntry::new(1, "executor", "m", "tool_result", serde_json::json!({ + "sources": [ + {"doc_id": "W-1", "chunk_text": "Alice Smith — Welder in Toledo, OH. 5 years experience."}, + {"doc_id": "W-2", "chunk_text": "Bob Jones — Welder in Toledo, OH. Night shift."}, + ] + })), + LogEntry::new(2, "reviewer", "m", "critique", serde_json::json!({ + "verdict": "continue", "notes": "" + })), + LogEntry::new(3, "executor", "m", "tool_result", serde_json::json!({ + "sources": [ + {"doc_id": "W-2", "chunk_text": "Bob Jones — Welder in Toledo, OH. Night shift."}, + {"doc_id": "W-3", "chunk_text": "Carol Davis — Welder in Toledo, OH. AWS certified."}, + ] + })), + ]; + let seen = candidates_seen(&log); + assert_eq!(seen.len(), 3, "dedup by doc_id"); + assert_eq!(seen[0].name, "Alice Smith"); + assert_eq!(seen[0].city, "Toledo"); + assert_eq!(seen[0].state, "OH"); + assert_eq!(seen[2].name, "Carol Davis"); + } + + #[test] + fn candidates_seen_ignores_malformed() { + let log = vec![ + LogEntry::new(1, "executor", "m", "tool_result", serde_json::json!({ + "sources": [ + {"doc_id": "W-1", "chunk_text": "no dash here"}, + {"doc_id": "W-2", "chunk_text": "Name — but no 'in' keyword"}, + {"doc_id": "W-3"}, // no chunk_text + ] + })), + ]; + assert_eq!(candidates_seen(&log).len(), 0); + } + + #[test] + fn tool_calls_since_propose_counts_correctly() { + let log = vec![ + LogEntry::new(1, "executor", "m", "tool_call", serde_json::json!({})), + LogEntry::new(2, "executor", "m", "tool_call", serde_json::json!({})), + LogEntry::new(3, "executor", "m", "tool_call", serde_json::json!({})), + ]; + assert_eq!(tool_calls_since_last_propose(&log), 3); + + // propose_done resets the counter + let log2 = vec![ + LogEntry::new(1, "executor", "m", "tool_call", serde_json::json!({})), + LogEntry::new(2, "executor", "m", "propose_done", serde_json::json!({})), + LogEntry::new(3, "executor", "m", "tool_call", serde_json::json!({})), + ]; + assert_eq!(tool_calls_since_last_propose(&log2), 1); + } + + #[test] + fn executor_prompt_includes_surfaced_candidates() { + let req = req_with_spec(serde_json::json!({ + "target_role": "Welder", "target_count": 2, "target_city": "Toledo", "target_state": "OH" + })); + let log = vec![ + LogEntry::new(1, "executor", "m", "tool_result", serde_json::json!({ + "sources": [ + {"doc_id": "W-1", "chunk_text": "Alice Smith — Welder in Toledo, OH."}, + ] + })), + ]; + let p = build_executor_prompt(&req, &[], &log); + assert!(p.contains("CANDIDATES SURFACED SO FAR")); + // Prompt format deliberately separates name from doc_id now — + // the line reads `name="Alice Smith" ... (vector doc_id=W-1)` + // so the executor prompt explicitly tells the model NOT to + // conflate doc_id with workers_500k.worker_id. Assertion was + // expecting the old concatenated format; update to match the + // semantic contract (both tokens present, any order). + assert!(p.contains("Alice Smith")); + assert!(p.contains("W-1")); + assert!(p.contains("Toledo")); + } + + #[test] + fn reviewer_prompt_flags_loop_after_three_tool_calls() { + let req = req_with_spec(serde_json::json!({ + "target_role": "Welder", "target_count": 2, "target_city": "Toledo", "target_state": "OH" + })); + let log = vec![ + LogEntry::new(1, "executor", "m", "tool_call", serde_json::json!({})), + LogEntry::new(2, "executor", "m", "tool_call", serde_json::json!({})), + LogEntry::new(3, "executor", "m", "tool_call", serde_json::json!({})), + ]; + let p = build_reviewer_prompt(&req, &log); + assert!(p.contains("LOOP DETECTION")); + assert!(p.contains("Stop re-searching")); + } + + #[test] + fn reviewer_prompt_no_loop_clause_before_three_calls() { + let req = req_with_spec(serde_json::json!({ + "target_role": "Welder", "target_count": 2, "target_city": "Toledo", "target_state": "OH" + })); + let log = vec![ + LogEntry::new(1, "executor", "m", "tool_call", serde_json::json!({})), + ]; + let p = build_reviewer_prompt(&req, &log); + assert!(!p.contains("LOOP DETECTION")); + } + + #[test] + fn is_cloud_model_recognizes_cloud_prefixes() { + assert!(is_cloud_model("gpt-oss:120b")); + assert!(is_cloud_model("gpt-oss:20b")); + assert!(is_cloud_model("qwen3-coder:480b")); + assert!(is_cloud_model("qwen3.5:397b")); + assert!(is_cloud_model("kimi-k2.5")); + assert!(is_cloud_model("kimi/k2-thinking")); + } + + #[test] + fn is_cloud_model_rejects_local_prefixes() { + assert!(!is_cloud_model("qwen3.5:latest")); + assert!(!is_cloud_model("qwen3:latest")); + assert!(!is_cloud_model("qwen2.5:latest")); + assert!(!is_cloud_model("mistral")); + assert!(!is_cloud_model("nomic-embed-text")); + } + + #[test] + fn spec_target_count_defaults_to_zero() { + let spec = serde_json::json!({}); + assert_eq!(spec_target_count(&spec), 0); + } + + #[test] + fn executor_prompt_includes_target_when_spec_has_it() { + let req = RespondRequest { + task_class: "staffing.fill".into(), + operation: "fill: Welder x2 in Toledo, OH".into(), + spec: serde_json::json!({ + "target_role": "Welder", "target_count": 2, + "target_city": "Toledo", "target_state": "OH" + }), + executor_model: None, reviewer_model: None, max_turns: None, + }; + let p = build_executor_prompt(&req, &[], &[]); + assert!(p.contains("TARGET: 2 × Welder in Toledo, OH")); + assert!(p.contains("EXACTLY 2 entries")); + assert!(p.contains("hybrid_search"), "executor prompt must list hybrid_search in tool catalog"); + assert!(p.contains("sql(query"), "executor prompt must list sql tool signature"); + assert!(p.contains("DO NOT invent others"), "executor prompt must warn against tool-name invention"); + } + + #[test] + fn executor_prompt_degrades_without_spec() { + let req = RespondRequest { + task_class: "code.review".into(), + operation: "review PR #42".into(), + spec: serde_json::json!(null), + executor_model: None, reviewer_model: None, max_turns: None, + }; + let p = build_executor_prompt(&req, &[], &[]); + assert!(p.contains("TASK CLASS: code.review")); + assert!(!p.contains("TARGET:")); + } + + #[test] + fn reviewer_prompt_adds_hard_rule_when_awaiting_approval() { + let req = RespondRequest { + task_class: "staffing.fill".into(), + operation: "fill: Welder x2 in Toledo, OH".into(), + spec: serde_json::json!({"target_count": 2}), + executor_model: None, reviewer_model: None, max_turns: None, + }; + let log = vec![LogEntry::new(1, "executor", "m", "propose_done", serde_json::json!({}))]; + let p = build_reviewer_prompt(&req, &log); + assert!(p.contains("HARD RULE")); + } + + fn req_with_spec(spec: serde_json::Value) -> RespondRequest { + RespondRequest { + task_class: "staffing.fill".into(), + operation: "fill: Welder x2 in Toledo, OH".into(), + spec, + executor_model: None, + reviewer_model: None, + max_turns: None, + } + } + + fn sample_stats() -> LoopStats { + LoopStats { + requests: 8, prompt_tokens: 12345, completion_tokens: 2345, + total_tokens: 14690, latency_ms: 42000, + } + } + + #[test] + fn sig_hash_is_stable_for_same_inputs() { + let spec = serde_json::json!({ + "target_role": "Welder", "target_city": "Toledo", "target_state": "OH" + }); + let a = sig_hash(&req_with_spec(spec.clone())); + let b = sig_hash(&req_with_spec(spec)); + assert_eq!(a, b); + assert_eq!(a.len(), 16); + } + + #[test] + fn sig_hash_differs_by_geo() { + let a = sig_hash(&req_with_spec(serde_json::json!({ + "target_role": "Welder", "target_city": "Toledo", "target_state": "OH" + }))); + let b = sig_hash(&req_with_spec(serde_json::json!({ + "target_role": "Welder", "target_city": "Dayton", "target_state": "OH" + }))); + assert_ne!(a, b); + } + + #[test] + fn seed_context_uses_hint_when_present() { + let req = req_with_spec(serde_json::json!({ + "approach_hint": "hybrid search", "target_role": "Welder", "target_city": "Toledo" + })); + assert_eq!(seed_context(&req), "hybrid search"); + } + + #[test] + fn seed_context_falls_back_to_role_city_state() { + let req = req_with_spec(serde_json::json!({ + "target_role": "Welder", "target_city": "Toledo", "target_state": "OH" + })); + assert_eq!(seed_context(&req), "Welder fill in Toledo, OH"); + } + + #[test] + fn seed_context_falls_back_to_operation_for_non_staffing() { + let req = req_with_spec(serde_json::json!({})); + assert_eq!(seed_context(&req), "fill: Welder x2 in Toledo, OH"); + } + + #[test] + fn outcomes_row_stamps_full_indicator_set_on_success() { + let req = req_with_spec(serde_json::json!({ + "target_role": "Welder", "target_city": "Toledo", "target_state": "OH" + })); + let stats = sample_stats(); + let outcome = RespondOutcome::Ok { + artifact: serde_json::json!({"fills": [{"candidate_id": "W-1", "name": "A B"}]}), + log: vec![], + }; + let seed = serde_json::json!({"outcome": {"mode": "added"}, "entries_after": 1337}); + let row = build_outcomes_row(&req, &stats, 4, false, &outcome, Some(seed)); + assert_eq!(row["schema_version"], 2); + assert_eq!(row["source_service"], "v1.respond"); + assert_eq!(row["task_class"], "staffing.fill"); + assert_eq!(row["ok"], true); + assert_eq!(row["polarity"], "success_confirmation"); + assert_eq!(row["iterations"], 4); + assert_eq!(row["turns"], 4); + assert_eq!(row["usage"]["total_tokens"], 14690); + assert_eq!(row["usage"]["requests"], 8); + assert_eq!(row["models"]["executor"], "qwen3.5:latest"); + assert_eq!(row["provider"], "ollama"); + assert_eq!(row["playbook_seed"]["entries_after"], 1337); + assert!(row["sig_hash"].as_str().unwrap().len() == 16); + assert!(row["truth_rule_citations"].is_array()); + } + + #[test] + fn outcomes_row_stamps_failure_polarity() { + let req = req_with_spec(serde_json::json!({})); + let stats = sample_stats(); + let outcome = RespondOutcome::Failed { + reason: "3 consecutive drifts".into(), + log: vec![], + }; + let row = build_outcomes_row(&req, &stats, 2, false, &outcome, None); + assert_eq!(row["ok"], false); + assert_eq!(row["polarity"], "failure_pattern"); + assert_eq!(row["error"], "3 consecutive drifts"); + assert_eq!(row["fills"], serde_json::Value::Null); + assert!(row["playbook_seed"].is_null()); + assert_eq!(row["correction_applied"], false); + assert!(row["correction_effective"].is_null()); + } + + #[test] + fn outcomes_row_marks_correction_effective_when_overseer_called_and_ok() { + let req = req_with_spec(serde_json::json!({})); + let stats = sample_stats(); + let outcome = RespondOutcome::Ok { + artifact: serde_json::json!({"fills": []}), + log: vec![], + }; + let row = build_outcomes_row(&req, &stats, 3, true, &outcome, None); + assert_eq!(row["correction_applied"], true); + assert_eq!(row["correction_effective"], true); + } + + #[test] + fn outcomes_row_marks_correction_ineffective_when_overseer_called_and_failed() { + let req = req_with_spec(serde_json::json!({})); + let stats = sample_stats(); + let outcome = RespondOutcome::Failed { + reason: "still drifting after overseer".into(), + log: vec![], + }; + let row = build_outcomes_row(&req, &stats, 3, true, &outcome, None); + assert_eq!(row["correction_applied"], true); + assert_eq!(row["correction_effective"], false); + } + + // Atomic counter + PID guarantees a unique path across parallel + // test invocations. Nanos-only showed 1/5 flake under `cargo + // test` because SystemTime can repeat across threads that run + // within sub-ns of each other. + static APPEND_TEST_SEQ: std::sync::atomic::AtomicU64 = + std::sync::atomic::AtomicU64::new(0); + + #[tokio::test] + async fn append_outcomes_row_at_writes_valid_jsonl() { + let seq = APPEND_TEST_SEQ.fetch_add(1, std::sync::atomic::Ordering::SeqCst); + let tmpdir = std::env::temp_dir().join(format!( + "lh_outcomes_{}_{}", std::process::id(), seq, + )); + let path = tmpdir.join("outcomes.jsonl"); + + let row = serde_json::json!({"schema_version": 2, "ok": true, "test": "marker"}); + append_outcomes_row_at(&path, &row).await.unwrap(); + append_outcomes_row_at(&path, &row).await.unwrap(); + + let written = std::fs::read_to_string(&path).unwrap(); + let lines: Vec<_> = written.lines().collect(); + assert_eq!(lines.len(), 2); + for line in lines { + let parsed: serde_json::Value = serde_json::from_str(line).unwrap(); + assert_eq!(parsed["test"], "marker"); + } + std::fs::remove_dir_all(&tmpdir).ok(); + } + + #[test] + fn trim_result_leaves_small_arrays_alone() { + let r = serde_json::json!({ "rows": [1, 2, 3] }); + let t = trim_result(&r); + assert_eq!(t["rows"].as_array().unwrap().len(), 3); + assert!(t.get("_trimmed").is_none()); + } + + #[test] + fn trim_result_caps_at_20_and_annotates() { + let rows: Vec<_> = (0..100).map(serde_json::Value::from).collect(); + let r = serde_json::json!({ "rows": rows, "other_field": "kept" }); + let t = trim_result(&r); + assert_eq!(t["rows"].as_array().unwrap().len(), 20); + assert_eq!(t["_trimmed"], "80 more rows"); + assert_eq!(t["other_field"], "kept"); + } + + #[test] + fn trim_result_passthrough_when_no_rows() { + let r = serde_json::json!({ "answer": "42" }); + let t = trim_result(&r); + assert_eq!(t["answer"], "42"); + } + + #[test] + fn reviewer_prompt_omits_hard_rule_otherwise() { + let req = RespondRequest { + task_class: "staffing.fill".into(), + operation: "fill: Welder x2 in Toledo, OH".into(), + spec: serde_json::json!({"target_count": 2}), + executor_model: None, reviewer_model: None, max_turns: None, + }; + let log = vec![LogEntry::new(1, "executor", "m", "tool_call", serde_json::json!({}))]; + let p = build_reviewer_prompt(&req, &log); + assert!(!p.contains("HARD RULE")); + } +} diff --git a/crates/gateway/src/main.rs b/crates/gateway/src/main.rs index 539398b..eae6adc 100644 --- a/crates/gateway/src/main.rs +++ b/crates/gateway/src/main.rs @@ -1,6 +1,7 @@ mod access; mod access_service; mod auth; +mod execution_loop; mod observability; mod tools; mod v1; @@ -67,14 +68,62 @@ async fn main() { let access = access::AccessControl::new(config.auth.enabled); access.register_defaults().await; + // Phase 42 — file-backed truth rules. Probes the `truth/` directory + // at repo root (or $LAKEHOUSE_TRUTH_DIR override) and logs how many + // rules load. Current request paths still build their own stores + // via truth::default_truth_store() / truth::sql_query_guard_store(); + // the composed-at-boot store gets plumbed through V1State in a + // follow-up. This boot probe catches parse errors + duplicate-ID + // collisions early rather than at first request. + { + let truth_dir = std::env::var("LAKEHOUSE_TRUTH_DIR") + .unwrap_or_else(|_| "/home/profit/lakehouse/truth".to_string()); + if std::path::Path::new(&truth_dir).exists() { + let mut probe_store = truth::default_truth_store(); + match truth::loader::load_from_dir(&mut probe_store, &truth_dir) { + Ok(n) => tracing::info!("truth: loaded {n} file-backed rule(s) from {truth_dir}"), + Err(e) => tracing::warn!("truth: failed to load rules from {truth_dir}: {e}"), + } + } else { + tracing::debug!("truth: no rule dir at {truth_dir}, skipping file-backed load"); + } + } + // Workspace manager for agent-specific overlays let workspace_mgr = queryd::workspace::WorkspaceManager::new(store.clone()); if let Err(e) = workspace_mgr.rebuild().await { tracing::warn!("workspace rebuild: {e}"); } - // AI sidecar client - let ai_client = aibridge::client::AiClient::new(&config.sidecar.url); + // AI sidecar clients — Phase 44 part 3 (2026-04-27). + // + // Two flavors of the same client: + // - `ai_client_direct` posts directly to ${sidecar}/generate. Used + // inside the gateway by V1State + the legacy /ai proxy. These + // call sites are themselves the implementation of /v1/chat + // (or its sidecar shim), so routing them through /v1/chat + // would self-loop. + // - `ai_client_observable` posts via ${gateway}/v1/chat with + // provider="ollama". Used by vectord modules (autotune agent, + // /vectors service) so their LLM calls land in /v1/usage and + // Langfuse traces. Adds one localhost HTTP hop per call (~ms); + // accepted for the observability gain. + // + // The gateway can call its own /v1/chat over localhost during + // boot's transient period because we don't fire any LLM calls + // until the listener is up — the observable client is just + // configured here, not exercised. + let ai_client_direct = aibridge::client::AiClient::new(&config.sidecar.url); + let gateway_self_url = format!("http://{}:{}", config.gateway.host, config.gateway.port); + let ai_client_observable = aibridge::client::AiClient::new_with_gateway( + &config.sidecar.url, + &gateway_self_url, + ); + // Backwards-compat alias for the (many) existing references in this file. + // Defaults to direct so the existing wiring (V1State, /ai proxy) + // keeps its non-self-loop transport. New vectord wiring below + // explicitly uses ai_client_observable. + let ai_client = ai_client_direct.clone(); // Vector service components — built before the router because both the // /vectors service AND ingestd need the agent handle to enqueue triggers. @@ -92,6 +141,12 @@ async fn main() { // operators call POST /vectors/playbook_memory/rebuild to populate. let pbm = vectord::playbook_memory::PlaybookMemory::new(store.clone()); let _ = pbm.load_from_storage().await; + // Pathway memory — consensus-designed sidecar for full-context + // backtracking + hot-swap of successful review pathways. Same + // load-on-boot pattern as playbook_memory: empty state is fine, + // operators start populating via scrum_master_pipeline.ts. + let pwm = vectord::pathway_memory::PathwayMemory::new(store.clone()); + let _ = pwm.load_from_storage().await; // Phase 16.2: spawn the autotune agent. When config.agent.enabled=false // this returns a handle that drops triggers silently — no surprise load. @@ -106,7 +161,9 @@ async fn main() { agent_cfg, vectord::agent::AgentDeps { store: store.clone(), - ai_client: ai_client.clone(), + // Observable: autotune agent's LLM calls go through + // /v1/chat for /v1/usage + Langfuse visibility. + ai_client: ai_client_observable.clone(), catalog: registry.clone(), index_registry: index_reg.clone(), hnsw_store: hnsw.clone(), @@ -153,10 +210,17 @@ async fn main() { agent_handle: agent_handle.clone(), index_registry: index_reg.clone(), schedules: sched_store, + // P9-001 fix 2026-04-23: journal reference flows into ingest so + // successful uploads emit a record_ingest event. Journal is Clone + // (Arc inside) so the /journal nest below still sees the + // same buffer + persistence. + journal: Some(journal.clone()), })) .nest("/vectors", vectord::service::router(vectord::service::VectorState { store: store.clone(), - ai_client: ai_client.clone(), + // Observable: /vectors service's LLM calls (RAG, summary, + // playbook synthesis, etc.) flow through /v1/chat. + ai_client: ai_client_observable.clone(), job_tracker: vectord::jobs::JobTracker::new(), index_registry: index_reg.clone(), hnsw_store: hnsw, @@ -172,17 +236,19 @@ async fn main() { bucket_registry.clone(), index_reg.clone(), ), playbook_memory: pbm, + pathway_memory: pwm, embed_semaphore: std::sync::Arc::new(tokio::sync::Semaphore::new(1)), })) .nest("/workspaces", queryd::workspace_service::router(workspace_mgr)) .nest("/journal", journald::service::router(journal)) .nest("/access", access_service::router(access)) .nest("/tools", tools::service::router({ - let tool_reg = tools::registry::ToolRegistry::new_with_defaults(); + let tool_reg = tools::registry::ToolRegistry::new(); tool_reg.register_defaults().await; tools::ToolState { registry: tool_reg, query_fn: tools::QueryExecutor::new(engine.clone()), + truth: std::sync::Arc::new(truth::sql_query_guard_store()), } })) // Phase 38 — Universal API skeleton. Thin OpenAI-compatible @@ -204,6 +270,86 @@ async fn main() { } k }, + openrouter_key: { + // 2026-04-24 free-tier rescue rung for iter 5+. Shares + // the LLM Team UI's OPENROUTER_API_KEY so both systems + // draw from one quota. + let k = v1::openrouter::resolve_openrouter_key(); + if k.is_some() { + tracing::info!("v1: OpenRouter key loaded — /v1/chat provider=openrouter enabled"); + } else { + tracing::warn!("v1: no OpenRouter key — openrouter rescue rung will 503"); + } + k + }, + gemini_key: { + // Phase 40 provider. GEMINI_API_KEY in env or .env. + let k = v1::gemini::resolve_gemini_key(); + if k.is_some() { + tracing::info!("v1: Gemini key loaded — /v1/chat provider=gemini enabled"); + } else { + tracing::debug!("v1: no Gemini key — provider=gemini will 503"); + } + k + }, + claude_key: { + // Phase 40 provider. ANTHROPIC_API_KEY in env or .env. + let k = v1::claude::resolve_claude_key(); + if k.is_some() { + tracing::info!("v1: Claude key loaded — /v1/chat provider=claude enabled"); + } else { + tracing::debug!("v1: no Claude key — provider=claude will 503"); + } + k + }, + kimi_key: { + // Direct Kimi For Coding (api.kimi.com) — bypasses the + // broken-upstream kimi-k2:1t and OpenRouter rate caps. + // Key from /etc/lakehouse/kimi.env (KIMI_API_KEY=sk-kimi-…). + let k = v1::kimi::resolve_kimi_key(); + if k.is_some() { + tracing::info!("v1: Kimi key loaded — /v1/chat provider=kimi enabled (model=kimi-for-coding)"); + } else { + tracing::debug!("v1: no Kimi key — provider=kimi will 503"); + } + k + }, + opencode_key: { + // OpenCode GO multi-vendor gateway — Claude Opus 4.7, + // GPT-5.5-pro, Gemini 3.1-pro, Kimi K2.6, DeepSeek, GLM, + // Qwen + free-tier. Key from /etc/lakehouse/opencode.env. + let k = v1::opencode::resolve_opencode_key(); + if k.is_some() { + tracing::info!("v1: OpenCode key loaded — /v1/chat provider=opencode enabled (40 models)"); + } else { + tracing::debug!("v1: no OpenCode key — provider=opencode will 503"); + } + k + }, + validate_workers: { + // Load workers_500k.parquet snapshot for /v1/validate. + // Path overridable via LH_WORKERS_PARQUET env. Missing + // file is non-fatal — validators run schema/PII checks + // unaffected; only worker-existence checks fail clean. + let path_str = std::env::var("LH_WORKERS_PARQUET") + .unwrap_or_else(|_| "/home/profit/lakehouse/data/datasets/workers_500k.parquet".into()); + let path = std::path::Path::new(&path_str); + if path.exists() { + match validator::staffing::parquet_lookup::load_workers_parquet(path) { + Ok(lookup) => { + tracing::info!("v1: workers parquet loaded from {} — /v1/validate worker-existence checks enabled", path_str); + lookup + } + Err(e) => { + tracing::warn!("v1: workers parquet at {} unreadable ({e}) — /v1/validate worker-existence checks will fail Consistency", path_str); + std::sync::Arc::new(validator::InMemoryWorkerLookup::new()) + } + } + } else { + tracing::warn!("v1: workers parquet at {} not found — /v1/validate worker-existence checks will fail Consistency", path_str); + std::sync::Arc::new(validator::InMemoryWorkerLookup::new()) + } + }, // Phase 40 early deliverable — Langfuse trace emitter. // Defaults match mcp-server/tracing.ts conventions so // gateway traces land in the same staffing project. @@ -218,14 +364,19 @@ async fn main() { }, })); - // Auth middleware (if enabled) + // Auth middleware (if enabled) — P5-001 fix 2026-04-23: + // previously only inserted the ApiKey as an extension and never layered + // the middleware, so auth.enabled=true enforced nothing. Now wraps the + // router with from_fn_with_state, which calls api_key_auth on every + // request. /health is exempted inside the middleware (LB probes). if config.auth.enabled { if let Some(ref key) = config.auth.api_key { - tracing::info!("API key auth enabled"); + tracing::info!("API key auth enabled — enforcing on all routes except /health"); let api_key = auth::ApiKey(key.clone()); - app = app.layer(axum::Extension(api_key)); - // Note: auth middleware applied per-route in production - // For now, the ApiKey extension is available for handlers to check + app = app.layer(axum::middleware::from_fn_with_state( + api_key, + auth::api_key_auth, + )); } else { tracing::warn!("auth enabled but no api_key set — all requests allowed"); } diff --git a/crates/gateway/src/tools/mod.rs b/crates/gateway/src/tools/mod.rs index 2f316f6..f96dd93 100644 --- a/crates/gateway/src/tools/mod.rs +++ b/crates/gateway/src/tools/mod.rs @@ -3,12 +3,18 @@ pub mod service; use queryd::context::QueryEngine; use arrow::json::writer::{JsonArray, Writer as JsonWriter}; +use std::sync::Arc; +use truth::TruthStore; /// State for the tool system. #[derive(Clone)] pub struct ToolState { pub registry: registry::ToolRegistry, pub query_fn: QueryExecutor, + /// SQL guard (shared with queryd). Mirrors the queryd /sql truth + /// gate from P42-002 (9cc0ceb) — tools also execute model- + /// originated SQL, need the same destructive-verb block. + pub truth: Arc, } /// Wraps QueryEngine to provide a simple execute interface for tools. diff --git a/crates/gateway/src/tools/registry.rs b/crates/gateway/src/tools/registry.rs index a5254ac..f2be6f0 100644 --- a/crates/gateway/src/tools/registry.rs +++ b/crates/gateway/src/tools/registry.rs @@ -67,24 +67,14 @@ pub struct ToolRegistry { } impl ToolRegistry { + /// Build an empty registry. Callers in an async context should follow + /// this with `.register_defaults().await` if they want the built-in + /// staffing tools pre-installed — main.rs does exactly that. pub fn new() -> Self { - let registry = Self { + Self { tools: Arc::new(RwLock::new(HashMap::new())), audit_log: Arc::new(RwLock::new(Vec::new())), - }; - // Register built-in staffing tools - tokio::task::block_in_place(|| { - tokio::runtime::Handle::current().block_on(registry.register_defaults()) - }); - registry - } - - pub fn new_with_defaults() -> Self { - let registry = Self { - tools: Arc::new(RwLock::new(HashMap::new())), - audit_log: Arc::new(RwLock::new(Vec::new())), - }; - registry + } } /// Register default staffing tools. diff --git a/crates/gateway/src/tools/service.rs b/crates/gateway/src/tools/service.rs index 408b2bb..ef8e099 100644 --- a/crates/gateway/src/tools/service.rs +++ b/crates/gateway/src/tools/service.rs @@ -7,7 +7,7 @@ use axum::{ }; use serde::Deserialize; -use super::registry::{Permission, ToolInvocation, ToolRegistry}; +use super::registry::{ToolInvocation, ToolRegistry}; use crate::tools::ToolState; pub fn router(state: ToolState) -> Router { @@ -92,6 +92,32 @@ async fn call_tool( } }; + // Truth gate — same contract as queryd /sql (P42-002). Rejects + // destructive verbs + empty SQL. Scrum iter 11 CF-1 + CF-2 on this + // file: tools executed model-provided SQL parameters without any + // validation. Close the gap here so the parallel surface has the + // same safety floor as queryd. + let ctx = serde_json::json!({ "sql": sql }); + for outcome in state.truth.evaluate("sql_query", &ctx) { + if outcome.passed { + if let truth::RuleAction::Reject { message } | truth::RuleAction::Block { message } = &outcome.action { + tracing::warn!("tool {name}: SQL blocked by truth gate ({}): {message}", outcome.rule_id); + state.registry.log_invocation(ToolInvocation { + id: format!("inv-{}", chrono::Utc::now().timestamp_millis()), + tool_name: name.clone(), + agent: req.agent.clone(), + params: req.params.clone(), + permission: tool.permission.clone(), + timestamp: chrono::Utc::now(), + success: false, + error: Some(format!("truth gate: {message}")), + rows_returned: None, + }).await; + return Err((StatusCode::FORBIDDEN, message.clone())); + } + } + } + // Execute via query engine let result = state.query_fn.execute(&sql).await; diff --git a/crates/gateway/src/v1/claude.rs b/crates/gateway/src/v1/claude.rs new file mode 100644 index 0000000..a71a15f --- /dev/null +++ b/crates/gateway/src/v1/claude.rs @@ -0,0 +1,222 @@ +//! Claude (Anthropic) adapter. +//! +//! POST `https://api.anthropic.com/v1/messages`. Auth via `x-api-key` +//! header (not bearer) + required `anthropic-version` header. Payload +//! is NOT OpenAI-compatible — response text lives at +//! `content[0].text`. Phase 40 deliverable. System prompts travel in +//! a top-level `system` field, separate from the `messages` array. + +use std::time::Duration; +use serde::{Deserialize, Serialize}; + +use super::{ChatRequest, ChatResponse, Choice, Message, UsageBlock}; + +const CLAUDE_BASE_URL: &str = "https://api.anthropic.com/v1"; +const CLAUDE_API_VERSION: &str = "2023-06-01"; +const CLAUDE_TIMEOUT_SECS: u64 = 180; + +pub fn resolve_claude_key() -> Option { + if let Ok(k) = std::env::var("ANTHROPIC_API_KEY") { + if !k.trim().is_empty() { return Some(k.trim().to_string()); } + } + for path in ["/home/profit/.env", "/root/.env"] { + if let Ok(raw) = std::fs::read_to_string(path) { + for line in raw.lines() { + if let Some(rest) = line.strip_prefix("ANTHROPIC_API_KEY=") { + let k = rest.trim().trim_matches('"').trim_matches('\''); + if !k.is_empty() { return Some(k.to_string()); } + } + } + } + } + None +} + +pub async fn chat( + key: &str, + req: &ChatRequest, +) -> Result { + // Strip the "claude/" prefix if the caller used the namespaced form. + let model = req.model.strip_prefix("claude/").unwrap_or(&req.model).to_string(); + + // Anthropic carries system prompts outside the messages array. + // Concatenate any system-role messages into a single system string; + // keep user + assistant messages in `messages`. + let mut system_parts: Vec = Vec::new(); + let mut msgs: Vec = Vec::new(); + for m in &req.messages { + if m.role == "system" { + system_parts.push(m.text()); + } else { + // Anthropic expects strictly "user" or "assistant"; anything + // else we normalize to "user". + let role = if m.role == "assistant" { "assistant" } else { "user" }; + msgs.push(AnMessage { role: role.to_string(), content: m.text() }); + } + } + let system = if system_parts.is_empty() { + None + } else { + Some(system_parts.join("\n\n")) + }; + + let body = AnChatBody { + model: model.clone(), + messages: msgs, + max_tokens: req.max_tokens.unwrap_or(800), + temperature: req.temperature.unwrap_or(0.3), + system, + }; + + let client = reqwest::Client::builder() + .timeout(Duration::from_secs(CLAUDE_TIMEOUT_SECS)) + .build() + .map_err(|e| format!("build client: {e}"))?; + + let t0 = std::time::Instant::now(); + let resp = client + .post(format!("{}/messages", CLAUDE_BASE_URL)) + .header("x-api-key", key) + .header("anthropic-version", CLAUDE_API_VERSION) + .json(&body) + .send() + .await + .map_err(|e| format!("api.anthropic.com unreachable: {e}"))?; + + let status = resp.status(); + if !status.is_success() { + let body = resp.text().await.unwrap_or_else(|_| "?".into()); + return Err(format!("claude {}: {}", status, body)); + } + + let parsed: AnChatResponse = resp.json().await + .map_err(|e| format!("invalid claude response: {e}"))?; + + let latency_ms = t0.elapsed().as_millis(); + let text = parsed.content.into_iter() + .find(|b| b.block_type == "text") + .map(|b| b.text) + .unwrap_or_default(); + + let prompt_tokens = parsed.usage.as_ref().map(|u| u.input_tokens).unwrap_or_else(|| { + let chars: usize = req.messages.iter().map(|m| m.text().chars().count()).sum(); + ((chars + 3) / 4) as u32 + }); + let completion_tokens = parsed.usage.as_ref().map(|u| u.output_tokens).unwrap_or_else(|| { + ((text.chars().count() + 3) / 4) as u32 + }); + + tracing::info!( + target: "v1.chat", + provider = "claude", + model = %model, + prompt_tokens, + completion_tokens, + latency_ms = latency_ms as u64, + "claude chat completed", + ); + + Ok(ChatResponse { + id: format!("chatcmpl-{}", chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0)), + object: "chat.completion", + created: chrono::Utc::now().timestamp(), + model, + choices: vec![Choice { + index: 0, + message: Message::new_text("assistant", text), + finish_reason: parsed.stop_reason.unwrap_or_else(|| "stop".into()), + }], + usage: UsageBlock { + prompt_tokens, + completion_tokens, + total_tokens: prompt_tokens + completion_tokens, + }, + }) +} + +// -- Anthropic Messages API wire shapes -- + +#[derive(Serialize)] +struct AnChatBody { + model: String, + messages: Vec, + max_tokens: u32, + temperature: f64, + #[serde(skip_serializing_if = "Option::is_none")] + system: Option, +} + +#[derive(Serialize)] +struct AnMessage { role: String, content: String } + +#[derive(Deserialize)] +struct AnChatResponse { + content: Vec, + #[serde(default, rename = "stop_reason")] + stop_reason: Option, + #[serde(default)] + usage: Option, +} + +#[derive(Deserialize)] +struct AnContentBlock { + #[serde(rename = "type")] + block_type: String, + #[serde(default)] + text: String, +} + +#[derive(Deserialize)] +struct AnUsage { input_tokens: u32, output_tokens: u32 } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn resolve_claude_key_does_not_panic() { + let _ = resolve_claude_key(); + } + + #[test] + fn chat_body_serializes_with_separate_system() { + let body = AnChatBody { + model: "claude-3-5-sonnet-latest".into(), + messages: vec![ + AnMessage { role: "user".into(), content: "hi".into() }, + ], + max_tokens: 800, + temperature: 0.3, + system: Some("You are helpful.".into()), + }; + let json = serde_json::to_string(&body).unwrap(); + assert!(json.contains("\"system\":\"You are helpful.\"")); + assert!(json.contains("\"messages\"")); + assert!(json.contains("\"max_tokens\":800")); + } + + #[test] + fn body_omits_system_when_none() { + let body = AnChatBody { + model: "claude-3-5-sonnet-latest".into(), + messages: vec![AnMessage { role: "user".into(), content: "hi".into() }], + max_tokens: 800, + temperature: 0.3, + system: None, + }; + let json = serde_json::to_string(&body).unwrap(); + assert!(!json.contains("\"system\""), "system field should be skipped when None: {json}"); + } + + #[test] + fn model_prefix_strip_preserves_bare_names() { + let cases = [ + ("claude/claude-3-5-sonnet-latest", "claude-3-5-sonnet-latest"), + ("claude-3-5-sonnet-latest", "claude-3-5-sonnet-latest"), + ]; + for (input, expected) in cases { + let out = input.strip_prefix("claude/").unwrap_or(input); + assert_eq!(out, expected); + } + } +} diff --git a/crates/gateway/src/v1/gemini.rs b/crates/gateway/src/v1/gemini.rs new file mode 100644 index 0000000..5ef0782 --- /dev/null +++ b/crates/gateway/src/v1/gemini.rs @@ -0,0 +1,230 @@ +//! Gemini adapter — Google's Generative Language API. +//! +//! POST `https://generativelanguage.googleapis.com/v1beta/models/ +//! {model}:generateContent?key=`. Auth via query-string key +//! (not bearer). Payload shape is NOT OpenAI-compatible — we map +//! messages → contents + parts, extract response from `candidates[0] +//! .content.parts[0].text`. Phase 40 deliverable; gate: `/v1/chat` +//! with a prefixed or explicit gemini model returns normally. + +use std::time::Duration; +use serde::{Deserialize, Serialize}; + +use super::{ChatRequest, ChatResponse, Choice, Message, UsageBlock}; + +const GEMINI_BASE_URL: &str = "https://generativelanguage.googleapis.com/v1beta"; +const GEMINI_TIMEOUT_SECS: u64 = 180; + +pub fn resolve_gemini_key() -> Option { + if let Ok(k) = std::env::var("GEMINI_API_KEY") { + if !k.trim().is_empty() { return Some(k.trim().to_string()); } + } + for path in ["/home/profit/.env", "/root/.env"] { + if let Ok(raw) = std::fs::read_to_string(path) { + for line in raw.lines() { + if let Some(rest) = line.strip_prefix("GEMINI_API_KEY=") { + let k = rest.trim().trim_matches('"').trim_matches('\''); + if !k.is_empty() { return Some(k.to_string()); } + } + } + } + } + None +} + +pub async fn chat( + key: &str, + req: &ChatRequest, +) -> Result { + // Strip the "gemini/" prefix if the caller used the namespaced form. + let model = req.model.strip_prefix("gemini/").unwrap_or(&req.model).to_string(); + + // Gemini splits system prompt from conversation differently. + // Simplest working mapping: concatenate any system messages at the + // top of a single user turn, then append user/assistant turns as + // separate contents entries. Covers the common single-turn case + // the scrum pipeline uses. + let mut contents: Vec = Vec::new(); + for m in &req.messages { + let role = match m.role.as_str() { + "system" | "user" => "user", + _ => "model", + }; + contents.push(GmContent { + role: role.to_string(), + parts: vec![GmPart { text: m.text() }], + }); + } + + let body = GmChatBody { + contents, + generation_config: GmGenerationConfig { + temperature: req.temperature.unwrap_or(0.3), + max_output_tokens: req.max_tokens.unwrap_or(800), + }, + }; + + let client = reqwest::Client::builder() + .timeout(Duration::from_secs(GEMINI_TIMEOUT_SECS)) + .build() + .map_err(|e| format!("build client: {e}"))?; + + let url = format!("{}/models/{}:generateContent?key={}", GEMINI_BASE_URL, model, key); + let t0 = std::time::Instant::now(); + let resp = client + .post(&url) + .json(&body) + .send() + .await + .map_err(|e| format!("generativelanguage.googleapis.com unreachable: {e}"))?; + + let status = resp.status(); + if !status.is_success() { + let body = resp.text().await.unwrap_or_else(|_| "?".into()); + return Err(format!("gemini {}: {}", status, body)); + } + + let parsed: GmChatResponse = resp.json().await + .map_err(|e| format!("invalid gemini response: {e}"))?; + + let latency_ms = t0.elapsed().as_millis(); + let candidate = parsed.candidates.into_iter().next() + .ok_or_else(|| "gemini returned no candidates".to_string())?; + let text = candidate.content.parts.into_iter() + .next() + .map(|p| p.text) + .unwrap_or_default(); + + let prompt_tokens = parsed.usage_metadata.as_ref() + .map(|u| u.prompt_token_count) + .unwrap_or_else(|| { + let chars: usize = req.messages.iter().map(|m| m.text().chars().count()).sum(); + ((chars + 3) / 4) as u32 + }); + let completion_tokens = parsed.usage_metadata.as_ref() + .map(|u| u.candidates_token_count) + .unwrap_or_else(|| ((text.chars().count() + 3) / 4) as u32); + + tracing::info!( + target: "v1.chat", + provider = "gemini", + model = %model, + prompt_tokens, + completion_tokens, + latency_ms = latency_ms as u64, + "gemini chat completed", + ); + + Ok(ChatResponse { + id: format!("chatcmpl-{}", chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0)), + object: "chat.completion", + created: chrono::Utc::now().timestamp(), + model, + choices: vec![Choice { + index: 0, + message: Message::new_text("assistant", text), + finish_reason: candidate.finish_reason.unwrap_or_else(|| "stop".into()), + }], + usage: UsageBlock { + prompt_tokens, + completion_tokens, + total_tokens: prompt_tokens + completion_tokens, + }, + }) +} + +// -- Gemini wire shapes -- + +#[derive(Serialize)] +struct GmChatBody { + contents: Vec, + #[serde(rename = "generationConfig")] + generation_config: GmGenerationConfig, +} + +#[derive(Serialize)] +struct GmContent { + role: String, + parts: Vec, +} + +#[derive(Serialize)] +struct GmPart { text: String } + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +struct GmGenerationConfig { + temperature: f64, + max_output_tokens: u32, +} + +#[derive(Deserialize)] +struct GmChatResponse { + candidates: Vec, + #[serde(default, rename = "usageMetadata")] + usage_metadata: Option, +} + +#[derive(Deserialize)] +struct GmCandidate { + content: GmContentResp, + #[serde(default, rename = "finishReason")] + finish_reason: Option, +} + +#[derive(Deserialize)] +struct GmContentResp { parts: Vec } + +#[derive(Deserialize)] +struct GmPartResp { #[serde(default)] text: String } + +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct GmUsage { + prompt_token_count: u32, + candidates_token_count: u32, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn resolve_gemini_key_does_not_panic() { + let _ = resolve_gemini_key(); + } + + #[test] + fn chat_body_serializes_to_gemini_shape() { + let body = GmChatBody { + contents: vec![ + GmContent { + role: "user".into(), + parts: vec![GmPart { text: "hello".into() }], + }, + ], + generation_config: GmGenerationConfig { + temperature: 0.3, + max_output_tokens: 800, + }, + }; + let json = serde_json::to_string(&body).unwrap(); + assert!(json.contains("\"contents\"")); + assert!(json.contains("\"parts\"")); + // camelCase per Gemini API + assert!(json.contains("\"generationConfig\"")); + assert!(json.contains("\"maxOutputTokens\":800")); + } + + #[test] + fn model_prefix_strip_preserves_bare_names() { + let cases = [ + ("gemini/gemini-2.0-flash", "gemini-2.0-flash"), + ("gemini-2.0-flash", "gemini-2.0-flash"), + ]; + for (input, expected) in cases { + let out = input.strip_prefix("gemini/").unwrap_or(input); + assert_eq!(out, expected); + } + } +} diff --git a/crates/gateway/src/v1/iterate.rs b/crates/gateway/src/v1/iterate.rs new file mode 100644 index 0000000..49a3ba6 --- /dev/null +++ b/crates/gateway/src/v1/iterate.rs @@ -0,0 +1,313 @@ +//! /v1/iterate — the Phase 43 PRD's "generate → validate → correct → retry" loop. +//! +//! Closes the "0→85% with iteration" thesis structurally. A caller +//! posts a prompt + artifact kind + validation context; the gateway: +//! 1. Generates a JSON artifact via /v1/chat (any provider/model) +//! 2. Extracts the JSON object from the model output +//! 3. Validates via /v1/validate (FillValidator / EmailValidator / +//! PlaybookValidator with the shared WorkerLookup) +//! 4. On ValidationError, appends the error to the prompt and +//! retries up to `max_iterations` (default 3) +//! 5. Returns the accepted artifact + Report on success, OR the +//! attempt history + final error on max-iter exhaustion +//! +//! Internal calls go via HTTP loopback to localhost:gateway_port so +//! the same /v1/usage tracking and Langfuse traces apply. A small +//! latency cost (~1-3ms per loopback hop) for clean separation of +//! concerns and observability. +//! +//! 2026-04-27 Phase 43 v3 part 3: this endpoint makes the iteration +//! loop a first-class lakehouse capability rather than a per-caller +//! re-implementation. Staffing executors, agent loops, and future +//! validators all reach the same code path. + +use axum::{extract::State, http::StatusCode, response::IntoResponse, Json}; +use serde::{Deserialize, Serialize}; + +const DEFAULT_MAX_ITERATIONS: u32 = 3; +const LOOPBACK_TIMEOUT_SECS: u64 = 240; + +#[derive(Deserialize)] +pub struct IterateRequest { + /// "fill" | "email" | "playbook" — picks which validator runs. + pub kind: String, + /// The prompt to seed generation. Validation errors from prior + /// attempts are appended on retry. + pub prompt: String, + /// Provider/model passed through to /v1/chat. e.g. "ollama_cloud" + /// + "kimi-k2.6", or "opencode" + "claude-haiku-4-5". + pub provider: String, + pub model: String, + /// Optional system prompt — sent to /v1/chat as the system message. + #[serde(default)] + pub system: Option, + /// Validation context (target_count, city, state, role, client_id + /// for fills; candidate_id for emails). Forwarded to /v1/validate. + #[serde(default)] + pub context: Option, + /// Cap on iteration count. Defaults to 3 per the Phase 43 PRD. + #[serde(default)] + pub max_iterations: Option, + /// Forwarded to /v1/chat. Defaults to 0.2 if unset. + #[serde(default)] + pub temperature: Option, + /// Forwarded to /v1/chat. Defaults to 4096 if unset. + #[serde(default)] + pub max_tokens: Option, +} + +#[derive(Serialize)] +pub struct IterateAttempt { + pub iteration: u32, + pub raw: String, + pub status: AttemptStatus, +} + +#[derive(Serialize)] +#[serde(tag = "kind", rename_all = "snake_case")] +pub enum AttemptStatus { + /// Model output didn't contain extractable JSON. + NoJson, + /// JSON extracted but failed validation; carries the error. + ValidationFailed { error: serde_json::Value }, + /// Validation passed (last attempt's terminal status). + Accepted, +} + +#[derive(Serialize)] +pub struct IterateResponse { + pub artifact: serde_json::Value, + pub validation: serde_json::Value, + pub iterations: u32, + pub history: Vec, +} + +#[derive(Serialize)] +pub struct IterateFailure { + pub error: String, + pub iterations: u32, + pub history: Vec, +} + +pub async fn iterate( + State(state): State, + Json(req): Json, +) -> impl IntoResponse { + let max_iter = req.max_iterations.unwrap_or(DEFAULT_MAX_ITERATIONS).max(1); + let temperature = req.temperature.unwrap_or(0.2); + let max_tokens = req.max_tokens.unwrap_or(4096); + let mut history: Vec = Vec::with_capacity(max_iter as usize); + let mut current_prompt = req.prompt.clone(); + + let client = match reqwest::Client::builder() + .timeout(std::time::Duration::from_secs(LOOPBACK_TIMEOUT_SECS)) + .build() { + Ok(c) => c, + Err(e) => return (StatusCode::INTERNAL_SERVER_ERROR, format!("client build: {e}")).into_response(), + }; + // Self-loopback to the gateway port. Carries gateway internal + // calls through /v1/chat + /v1/validate so /v1/usage tracks them. + let gateway = "http://127.0.0.1:3100"; + + for iteration in 0..max_iter { + // ── Generate ── + let mut messages = Vec::with_capacity(2); + if let Some(sys) = &req.system { + messages.push(serde_json::json!({"role": "system", "content": sys})); + } + messages.push(serde_json::json!({"role": "user", "content": current_prompt})); + let chat_body = serde_json::json!({ + "messages": messages, + "provider": req.provider, + "model": req.model, + "temperature": temperature, + "max_tokens": max_tokens, + }); + let raw = match call_chat(&client, gateway, &chat_body).await { + Ok(r) => r, + Err(e) => return (StatusCode::BAD_GATEWAY, format!("/v1/chat hop failed at iter {iteration}: {e}")).into_response(), + }; + + // ── Extract JSON ── + let artifact = match extract_json(&raw) { + Some(a) => a, + None => { + history.push(IterateAttempt { + iteration, + raw: raw.chars().take(2000).collect(), + status: AttemptStatus::NoJson, + }); + current_prompt = format!( + "{}\n\nYour previous attempt did not contain a JSON object. Reply with ONLY a valid JSON object matching the requested artifact shape.", + req.prompt, + ); + continue; + } + }; + + // ── Validate ── + let validate_body = serde_json::json!({ + "kind": req.kind, + "artifact": artifact, + "context": req.context.clone().unwrap_or(serde_json::Value::Null), + }); + match call_validate(&client, gateway, &validate_body).await { + Ok(report) => { + history.push(IterateAttempt { + iteration, + raw: raw.chars().take(2000).collect(), + status: AttemptStatus::Accepted, + }); + return (StatusCode::OK, Json(IterateResponse { + artifact, + validation: report, + iterations: iteration + 1, + history, + })).into_response(); + } + Err(err) => { + let err_summary = err.to_string(); + history.push(IterateAttempt { + iteration, + raw: raw.chars().take(2000).collect(), + status: AttemptStatus::ValidationFailed { + error: serde_json::to_value(&err_summary).unwrap_or(serde_json::Value::Null), + }, + }); + // Append validation feedback to prompt for next iter. + // The model sees concrete failure mode + retries with + // corrective context. This is the "observer correction" + // in Phase 43 PRD shape, simplified — the validator + // itself IS the observer for now. + current_prompt = format!( + "{}\n\nPrior attempt failed validation:\n{}\n\nFix the specific issue above and respond with a corrected JSON object.", + req.prompt, err_summary, + ); + continue; + } + } + } + + (StatusCode::UNPROCESSABLE_ENTITY, Json(IterateFailure { + error: format!("max iterations reached ({max_iter}) without passing validation"), + iterations: max_iter, + history, + })).into_response() +} + +async fn call_chat(client: &reqwest::Client, gateway: &str, body: &serde_json::Value) -> Result { + let resp = client.post(format!("{gateway}/v1/chat")) + .json(body) + .send() + .await + .map_err(|e| format!("chat hop: {e}"))?; + let status = resp.status(); + if !status.is_success() { + let body = resp.text().await.unwrap_or_default(); + return Err(format!("chat {}: {}", status, body.chars().take(300).collect::())); + } + let parsed: serde_json::Value = resp.json().await.map_err(|e| format!("chat parse: {e}"))?; + Ok(parsed.pointer("/choices/0/message/content") + .and_then(|v| v.as_str()) + .unwrap_or("") + .to_string()) +} + +async fn call_validate(client: &reqwest::Client, gateway: &str, body: &serde_json::Value) -> Result { + let resp = client.post(format!("{gateway}/v1/validate")) + .json(body) + .send() + .await + .map_err(|e| format!("validate hop: {e}"))?; + let status = resp.status(); + let parsed: serde_json::Value = resp.json().await.map_err(|e| format!("validate parse: {e}"))?; + if status.is_success() { + Ok(parsed) + } else { + // The /v1/validate endpoint returns a ValidationError JSON + // on 422; surface its structure verbatim so the prompt- + // appending step gets specific failure detail. + Err(serde_json::to_string(&parsed).unwrap_or_else(|_| format!("validation {} (unparseable body)", status))) + } +} + +/// Extract the first JSON object from a model's output. Handles +/// fenced code blocks (```json ... ```), bare braces, and stray +/// prose around the JSON. Returns None on no extractable object. +fn extract_json(raw: &str) -> Option { + // Try fenced first. + let candidates: Vec = { + let mut out = vec![]; + let mut s = raw; + while let Some(start) = s.find("```") { + let after = &s[start + 3..]; + // Skip optional language tag (json, etc.) + let body_start = after.find('\n').map(|n| n + 1).unwrap_or(0); + let body = &after[body_start..]; + if let Some(end) = body.find("```") { + out.push(body[..end].trim().to_string()); + s = &body[end + 3..]; + } else { break; } + } + out + }; + for c in &candidates { + if let Ok(v) = serde_json::from_str::(c) { + if v.is_object() { return Some(v); } + } + } + // Fall back to outermost {...} balance. + let bytes = raw.as_bytes(); + let mut depth = 0i32; + let mut start: Option = None; + for (i, &b) in bytes.iter().enumerate() { + match b { + b'{' => { if start.is_none() { start = Some(i); } depth += 1; } + b'}' => { + depth -= 1; + if depth == 0 { + if let Some(s) = start { + let slice = &raw[s..=i]; + if let Ok(v) = serde_json::from_str::(slice) { + if v.is_object() { return Some(v); } + } + start = None; + } + } + } + _ => {} + } + } + None +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn extract_json_from_fenced_block() { + let raw = "Here's my answer:\n```json\n{\"fills\": [{\"candidate_id\": \"W-1\"}]}\n```\nDone."; + let v = extract_json(raw).unwrap(); + assert!(v.get("fills").is_some()); + } + + #[test] + fn extract_json_from_bare_braces() { + let raw = "Here you go: {\"fills\": [{\"candidate_id\": \"W-2\"}]}"; + let v = extract_json(raw).unwrap(); + assert!(v.get("fills").is_some()); + } + + #[test] + fn extract_json_returns_none_on_no_object() { + assert!(extract_json("just prose, no json").is_none()); + } + + #[test] + fn extract_json_picks_first_balanced() { + let raw = "{\"a\":1} then {\"b\":2}"; + let v = extract_json(raw).unwrap(); + assert_eq!(v.get("a").and_then(|v| v.as_i64()), Some(1)); + } +} diff --git a/crates/gateway/src/v1/kimi.rs b/crates/gateway/src/v1/kimi.rs new file mode 100644 index 0000000..9ff2b7e --- /dev/null +++ b/crates/gateway/src/v1/kimi.rs @@ -0,0 +1,227 @@ +//! Kimi For Coding adapter — direct provider for `kimi-for-coding` +//! (kimi-k2.6 underneath). Used when Ollama Cloud's `kimi-k2:1t` is +//! returning sustained 5xx (broken upstream) and OpenRouter's +//! `moonshotai/kimi-k2.6` is rate-limited. +//! +//! Endpoint per `kimi.com/code/docs` and `moonshotai.github.io/kimi-cli`: +//! base_url: https://api.kimi.com/coding/v1 +//! model id: kimi-for-coding +//! auth: Bearer sk-kimi-… +//! protocol: OpenAI Chat Completions compatible +//! +//! IMPORTANT: `api.kimi.com` is a separate account system from +//! `api.moonshot.ai` and `api.moonshot.cn`. Keys are NOT interchangeable. +//! This adapter is for `sk-kimi-*` keys provisioned via the Kimi +//! membership console only. +//! +//! Key sourcing priority: +//! 1. Env var `KIMI_API_KEY` (loaded from /etc/lakehouse/kimi.env via +//! systemd EnvironmentFile=) +//! 2. /etc/lakehouse/kimi.env directly (rescue path if env not loaded) +//! +//! First hit wins. Resolved once at gateway startup, stored on +//! `V1State.kimi_key`. + +use std::time::Duration; +use serde::{Deserialize, Serialize}; + +use super::{ChatRequest, ChatResponse, Choice, Message, UsageBlock}; + +const KIMI_BASE_URL: &str = "https://api.kimi.com/coding/v1"; +// Default 600s — kimi-for-coding is a reasoning model; on large +// code-audit prompts (~50KB+ input + 8K output) it routinely needs +// 3-8 min to think + emit. Override with KIMI_TIMEOUT_SECS env var. +const KIMI_TIMEOUT_SECS_DEFAULT: u64 = 600; + +fn kimi_timeout_secs() -> u64 { + std::env::var("KIMI_TIMEOUT_SECS") + .ok() + .and_then(|s| s.trim().parse::().ok()) + .filter(|&n| n > 0) + .unwrap_or(KIMI_TIMEOUT_SECS_DEFAULT) +} + +pub fn resolve_kimi_key() -> Option { + if let Ok(k) = std::env::var("KIMI_API_KEY") { + if !k.trim().is_empty() { return Some(k.trim().to_string()); } + } + if let Ok(raw) = std::fs::read_to_string("/etc/lakehouse/kimi.env") { + for line in raw.lines() { + if let Some(rest) = line.strip_prefix("KIMI_API_KEY=") { + let k = rest.trim().trim_matches('"').trim_matches('\''); + if !k.is_empty() { return Some(k.to_string()); } + } + } + } + None +} + +pub async fn chat( + key: &str, + req: &ChatRequest, +) -> Result { + // Strip the "kimi/" namespace prefix if the caller used it so the + // upstream API sees the bare model id (e.g. "kimi-for-coding"). + let model = req.model.strip_prefix("kimi/").unwrap_or(&req.model).to_string(); + + // Flatten content to a plain String. api.kimi.com is text-only on + // the coding endpoint; the OpenAI multimodal array shape + // ([{type:"text",text:"..."},{type:"image_url",...}]) returns 400. + // Message::text() concats text-parts and drops non-text. Caught + // 2026-04-27 by Kimi's self-audit (kimi.rs:137 — content as raw + // serde_json::Value risked upstream rejection). + let body = KimiChatBody { + model: model.clone(), + messages: req.messages.iter().map(|m| KimiMessage { + role: m.role.clone(), + content: serde_json::Value::String(m.text()), + }).collect(), + max_tokens: req.max_tokens.unwrap_or(800), + temperature: req.temperature.unwrap_or(0.3), + stream: false, + }; + + let client = reqwest::Client::builder() + .timeout(Duration::from_secs(kimi_timeout_secs())) + .build() + .map_err(|e| format!("build client: {e}"))?; + + let t0 = std::time::Instant::now(); + let resp = client + .post(format!("{}/chat/completions", KIMI_BASE_URL)) + .bearer_auth(key) + // api.kimi.com gates this endpoint by User-Agent — only sanctioned + // coding agents (Claude Code, Kimi CLI, Roo Code, Kilo Code) get + // through. Generic clients receive 403 access_terminated_error. + // J accepted the TOS risk on 2026-04-27; revisit if Moonshot + // tightens enforcement. + .header("User-Agent", "claude-code/1.0.0") + .json(&body) + .send() + .await + .map_err(|e| format!("api.kimi.com unreachable: {e}"))?; + + let status = resp.status(); + if !status.is_success() { + let body = resp.text().await.unwrap_or_else(|_| "?".into()); + return Err(format!("api.kimi.com {}: {}", status, body)); + } + + let parsed: KimiChatResponse = resp.json().await + .map_err(|e| format!("invalid kimi response: {e}"))?; + + let latency_ms = t0.elapsed().as_millis(); + let choice = parsed.choices.into_iter().next() + .ok_or_else(|| "kimi returned no choices".to_string())?; + let text = choice.message.content; + + let prompt_tokens = parsed.usage.as_ref().map(|u| u.prompt_tokens).unwrap_or_else(|| { + let chars: usize = req.messages.iter().map(|m| m.text().chars().count()).sum(); + ((chars + 3) / 4) as u32 + }); + let completion_tokens = parsed.usage.as_ref().map(|u| u.completion_tokens).unwrap_or_else(|| { + ((text.chars().count() + 3) / 4) as u32 + }); + + tracing::info!( + target: "v1.chat", + provider = "kimi", + model = %model, + prompt_tokens, + completion_tokens, + latency_ms = latency_ms as u64, + "kimi chat completed", + ); + + Ok(ChatResponse { + id: format!("chatcmpl-{}", chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0)), + object: "chat.completion", + created: chrono::Utc::now().timestamp(), + model, + choices: vec![Choice { + index: 0, + message: Message { role: "assistant".into(), content: serde_json::Value::String(text) }, + finish_reason: choice.finish_reason.unwrap_or_else(|| "stop".into()), + }], + usage: UsageBlock { + prompt_tokens, + completion_tokens, + total_tokens: prompt_tokens + completion_tokens, + }, + }) +} + +// -- Kimi wire shapes (OpenAI-compatible) -- + +#[derive(Serialize)] +struct KimiChatBody { + model: String, + messages: Vec, + max_tokens: u32, + temperature: f64, + stream: bool, +} + +#[derive(Serialize)] +struct KimiMessage { role: String, content: serde_json::Value } + +#[derive(Deserialize)] +struct KimiChatResponse { + choices: Vec, + #[serde(default)] + usage: Option, +} + +#[derive(Deserialize)] +struct KimiChoice { + message: KimiMessageResp, + #[serde(default)] + finish_reason: Option, +} + +#[derive(Deserialize)] +struct KimiMessageResp { content: String } + +#[derive(Deserialize)] +struct KimiUsage { prompt_tokens: u32, completion_tokens: u32 } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn resolve_kimi_key_does_not_panic() { + let _ = resolve_kimi_key(); + } + + #[test] + fn chat_body_serializes_to_openai_shape() { + let body = KimiChatBody { + model: "kimi-for-coding".into(), + messages: vec![ + KimiMessage { role: "user".into(), content: "review this".into() }, + ], + max_tokens: 800, + temperature: 0.3, + stream: false, + }; + let json = serde_json::to_string(&body).unwrap(); + assert!(json.contains("\"model\":\"kimi-for-coding\"")); + assert!(json.contains("\"messages\"")); + assert!(json.contains("\"max_tokens\":800")); + assert!(json.contains("\"stream\":false")); + } + + #[test] + fn model_prefix_strip() { + let cases = [ + ("kimi/kimi-for-coding", "kimi-for-coding"), + ("kimi-for-coding", "kimi-for-coding"), + ("kimi/kimi-k2.6", "kimi-k2.6"), + ]; + for (input, expected) in cases { + let out = input.strip_prefix("kimi/").unwrap_or(input); + assert_eq!(out, expected, "{input} should become {expected}"); + } + } +} diff --git a/crates/gateway/src/v1/mod.rs b/crates/gateway/src/v1/mod.rs index d8ba8a3..052e5cc 100644 --- a/crates/gateway/src/v1/mod.rs +++ b/crates/gateway/src/v1/mod.rs @@ -13,7 +13,17 @@ pub mod ollama; pub mod ollama_cloud; +pub mod openrouter; +pub mod gemini; +pub mod claude; +pub mod kimi; +pub mod opencode; +pub mod validate; +pub mod iterate; pub mod langfuse_trace; +pub mod mode; +pub mod respond; +pub mod truth; use axum::{ Router, @@ -24,7 +34,7 @@ use axum::{ Json, }; use serde::{Deserialize, Serialize}; -use std::{collections::HashMap, sync::Arc}; +use std::sync::Arc; use tokio::sync::RwLock; #[derive(Clone)] @@ -34,6 +44,41 @@ pub struct V1State { /// Ollama Cloud bearer token. Loaded at startup via /// `ollama_cloud::resolve_cloud_key()`. None = cloud routes 503. pub ollama_cloud_key: Option, + /// OpenRouter bearer token — free-tier rescue rung. Loaded at + /// startup via `openrouter::resolve_openrouter_key()`. None means + /// provider="openrouter" calls 503 rather than attempt. Same key + /// sourcing as LLM Team UI so the two share one API quota. + pub openrouter_key: Option, + /// Gemini API key (Google Generative Language). Loaded at startup + /// via `gemini::resolve_gemini_key()`. None = provider="gemini" + /// calls 503. Phase 40 deliverable. + pub gemini_key: Option, + /// Anthropic Claude API key. Loaded at startup via + /// `claude::resolve_claude_key()`. None = provider="claude" calls + /// 503. Phase 40 deliverable. + pub claude_key: Option, + /// Kimi For Coding (api.kimi.com) bearer token — direct provider + /// for `kimi-for-coding`. Used when Ollama Cloud's `kimi-k2:1t` is + /// upstream-broken. Loaded at startup via `kimi::resolve_kimi_key()` + /// from `KIMI_API_KEY` env or `/etc/lakehouse/kimi.env`. None = + /// provider="kimi" calls 503. + pub kimi_key: Option, + /// OpenCode GO (opencode.ai) bearer token — multi-vendor curated + /// gateway. One sk-* key reaches Claude Opus 4.7, GPT-5.5-pro, + /// Gemini 3.1-pro, Kimi K2.6, DeepSeek, GLM, Qwen + free-tier. + /// Loaded at startup via `opencode::resolve_opencode_key()` from + /// `OPENCODE_API_KEY` env or `/etc/lakehouse/opencode.env`. None = + /// provider="opencode" calls 503. + pub opencode_key: Option, + /// Shared WorkerLookup loaded once at startup from + /// workers_500k.parquet (path: LH_WORKERS_PARQUET env, default + /// data/datasets/workers_500k.parquet). Used by /v1/validate to + /// run FillValidator/EmailValidator with worker-existence checks. + /// Falls back to an empty InMemoryWorkerLookup if the file is + /// missing — validators still run schema/PII checks but every + /// worker-existence check fails (Consistency error), which is + /// the correct behavior when the roster isn't configured. + pub validate_workers: std::sync::Arc, /// Phase 40 early deliverable — Langfuse client. None = tracing /// disabled (keys missing or container unreachable). Traces are /// fire-and-forget: never block the response path. @@ -61,20 +106,73 @@ pub struct ProviderUsage { pub fn router(state: V1State) -> Router { Router::new() .route("/chat", post(chat)) + // Canonical OpenAI path alias — lets any client built on the + // openai SDK (pi-ai, langchain-js, etc.) treat the gateway as + // a drop-in middleware via OPENAI_BASE_URL=http://gw/v1 alone. + // Same handler as /chat; same OpenAI-compatible request shape. + .route("/chat/completions", post(chat)) + .route("/respond", post(respond::respond)) .route("/usage", get(usage)) .route("/sessions", get(sessions)) + .route("/context", get(truth::context)) + .route("/mode", post(mode::route)) + .route("/mode/list", get(mode::list)) + .route("/mode/execute", post(mode::execute)) + .route("/validate", post(validate::validate)) + .route("/iterate", post(iterate::iterate)) + .route("/health", get(health)) .with_state(state) } // -- Shared types (OpenAI-compatible) -- +/// OpenAI-compatible message. `content` accepts either a plain string or +/// an array of content parts (the modern multimodal shape: +/// `[{type:"text", text:"..."}, {type:"image_url", ...}]`). We store as +/// `serde_json::Value` to preserve client shape on forward; downstream +/// providers can take it verbatim. `Message::text()` flattens for +/// places that need a plain string (Ollama prompt assembly, char +/// counts, the assistant's own response synthesis). #[derive(Serialize, Deserialize, Clone, Debug)] pub struct Message { pub role: String, - pub content: String, + pub content: serde_json::Value, } -#[derive(Deserialize, Debug)] +impl Message { + /// Construct a plain text message — the common shape for callers + /// that don't need multimodal content. Wraps the body in + /// `serde_json::Value::String` so downstream serializers see the + /// canonical OpenAI shape. + pub fn new_text(role: impl Into, body: impl Into) -> Self { + Self { + role: role.into(), + content: serde_json::Value::String(body.into()), + } + } + /// Flatten content to a plain string. Strings pass through; content- + /// part arrays concatenate the `text` fields with newlines and skip + /// non-text parts (images etc.) — Phase 38/39 callers are text-only, + /// real multimodal forwarding is queued. + pub fn text(&self) -> String { + match &self.content { + serde_json::Value::String(s) => s.clone(), + serde_json::Value::Array(parts) => { + let mut out = String::new(); + for p in parts { + if let Some(t) = p.get("text").and_then(|v| v.as_str()) { + if !out.is_empty() { out.push('\n'); } + out.push_str(t); + } + } + out + } + other => other.to_string(), + } + } +} + +#[derive(Deserialize, Debug, Clone)] pub struct ChatRequest { pub model: String, pub messages: Vec, @@ -130,6 +228,137 @@ pub struct UsageBlock { // -- Handlers -- +/// Phase 39: resolve (provider, effective_model) from a ChatRequest. +/// +/// Explicit `req.provider` wins. If absent, infer from a model-name +/// prefix: "openrouter/..." → openrouter (strip prefix), "cloud/..." → +/// ollama_cloud (strip prefix). Bare names default to "ollama". +/// +/// The stripped model is what the upstream adapter expects: +/// OpenRouter's API wants "openai/gpt-4o-mini", not +/// "openrouter/openai/gpt-4o-mini". +fn resolve_provider(req: &ChatRequest) -> (String, String) { + if let Some(p) = req.provider.as_deref() { + return (p.to_ascii_lowercase(), req.model.clone()); + } + if let Some(rest) = req.model.strip_prefix("openrouter/") { + return ("openrouter".to_string(), rest.to_string()); + } + if let Some(rest) = req.model.strip_prefix("cloud/") { + return ("ollama_cloud".to_string(), rest.to_string()); + } + if let Some(rest) = req.model.strip_prefix("gemini/") { + return ("gemini".to_string(), rest.to_string()); + } + if let Some(rest) = req.model.strip_prefix("claude/") { + return ("claude".to_string(), rest.to_string()); + } + if let Some(rest) = req.model.strip_prefix("kimi/") { + return ("kimi".to_string(), rest.to_string()); + } + if let Some(rest) = req.model.strip_prefix("opencode/") { + return ("opencode".to_string(), rest.to_string()); + } + // Bare `vendor/model` shape (e.g. `x-ai/grok-4.1-fast`, + // `moonshotai/kimi-k2`, `openai/gpt-oss-120b:free`) → OpenRouter. + // This makes the gateway a drop-in OpenAI-compatible middleware: + // clients using the official `openai` SDK only set OPENAI_BASE_URL + // + a model name and get correct upstream routing without needing + // our custom `provider` field. Ollama models in J's stack use + // `model:tag` form with NO slash (`qwen3.5:latest`, `kimi-k2:1t`), + // so a slash here unambiguously means "namespaced provider/model". + if req.model.contains('/') { + return ("openrouter".to_string(), req.model.clone()); + } + // Vendor-bare model names (no slash, no colon) — `gpt-4o-mini`, + // `claude-3-5-sonnet-20241022`, etc. Tools like pi-ai validate + // models against an OpenAI-style catalog (no namespace prefix), + // so they send the bare name. Map to OpenRouter's namespaced form + // by inferring the vendor from the leading token. Falls through to + // ollama if no pattern matches — preserves existing behavior. + if !req.model.contains(':') && !req.model.contains('/') { + let m = req.model.as_str(); + if m.starts_with("gpt-") || m.starts_with("o1-") || m.starts_with("o3-") || m.starts_with("o4-") || m == "o1" || m == "o3" || m == "o4-mini" { + return ("openrouter".to_string(), format!("openai/{}", m)); + } + if m.starts_with("claude-") { + return ("openrouter".to_string(), format!("anthropic/{}", m)); + } + if m.starts_with("grok-") { + return ("openrouter".to_string(), format!("x-ai/{}", m)); + } + } + ("ollama".to_string(), req.model.clone()) +} + +#[cfg(test)] +mod resolve_provider_tests { + use super::*; + + fn mk_req(provider: Option<&str>, model: &str) -> ChatRequest { + ChatRequest { + model: model.to_string(), + messages: vec![], + temperature: None, + max_tokens: None, + stream: None, + think: None, + provider: provider.map(|s| s.to_string()), + } + } + + #[test] + fn explicit_provider_wins() { + let r = mk_req(Some("openrouter"), "qwen3.5:latest"); + assert_eq!(resolve_provider(&r), ("openrouter".into(), "qwen3.5:latest".into())); + } + + #[test] + fn bare_model_defaults_to_ollama() { + let r = mk_req(None, "qwen3.5:latest"); + assert_eq!(resolve_provider(&r), ("ollama".into(), "qwen3.5:latest".into())); + } + + #[test] + fn openrouter_prefix_infers_and_strips() { + let r = mk_req(None, "openrouter/openai/gpt-4o-mini"); + assert_eq!(resolve_provider(&r), ("openrouter".into(), "openai/gpt-4o-mini".into())); + } + + #[test] + fn cloud_prefix_infers_and_strips() { + let r = mk_req(None, "cloud/kimi-k2:1t"); + assert_eq!(resolve_provider(&r), ("ollama_cloud".into(), "kimi-k2:1t".into())); + } + + #[test] + fn explicit_provider_preserves_full_model_even_with_prefix() { + // If caller provides both provider and a model with a prefix, + // trust them — don't strip. The adapter will get the full model + // string as-is. + let r = mk_req(Some("openrouter"), "openrouter/openai/gpt-4o-mini"); + assert_eq!(resolve_provider(&r), ("openrouter".into(), "openrouter/openai/gpt-4o-mini".into())); + } + + #[test] + fn gemini_prefix_infers_and_strips() { + let r = mk_req(None, "gemini/gemini-2.0-flash"); + assert_eq!(resolve_provider(&r), ("gemini".into(), "gemini-2.0-flash".into())); + } + + #[test] + fn claude_prefix_infers_and_strips() { + let r = mk_req(None, "claude/claude-3-5-sonnet-latest"); + assert_eq!(resolve_provider(&r), ("claude".into(), "claude-3-5-sonnet-latest".into())); + } + + #[test] + fn kimi_prefix_infers_and_strips() { + let r = mk_req(None, "kimi/kimi-for-coding"); + assert_eq!(resolve_provider(&r), ("kimi".into(), "kimi-for-coding".into())); + } +} + async fn chat( State(state): State, Json(req): Json, @@ -141,13 +370,29 @@ async fn chat( tracing::warn!("/v1/chat: stream=true requested but Phase 38 returns non-streaming"); } - let provider = req.provider.as_deref().unwrap_or("ollama").to_ascii_lowercase(); + // Provider resolution: explicit `req.provider` wins; otherwise + // infer from a model-name prefix. Phase 39 PRD gate example: + // `model: "openrouter/openai/gpt-4o-mini"` → provider "openrouter", + // adapter gets the stripped "openai/gpt-4o-mini". + let (provider, effective_model) = resolve_provider(&req); let start_time = chrono::Utc::now(); let start_instant = std::time::Instant::now(); + // If we stripped a prefix, clone req with the effective model so + // the adapter sees what the upstream provider expects (OpenRouter + // wants "openai/gpt-4o-mini", not "openrouter/openai/gpt-4o-mini"). + let req_for_adapter: std::borrow::Cow<'_, ChatRequest> = + if effective_model == req.model { + std::borrow::Cow::Borrowed(&req) + } else { + let mut cloned = req.clone(); + cloned.model = effective_model.clone(); + std::borrow::Cow::Owned(cloned) + }; + let (resp, used_provider) = match provider.as_str() { "ollama" | "local" | "" => { - let r = ollama::chat(&state.ai_client, &req) + let r = ollama::chat(&state.ai_client, &*req_for_adapter) .await .map_err(|e| (StatusCode::BAD_GATEWAY, format!("ollama local: {e}")))?; (r, "ollama".to_string()) @@ -157,15 +402,79 @@ async fn chat( StatusCode::SERVICE_UNAVAILABLE, "OLLAMA_CLOUD_KEY not configured".to_string(), ))?; - let r = ollama_cloud::chat(key, &req) + let r = ollama_cloud::chat(key, &*req_for_adapter) .await .map_err(|e| (StatusCode::BAD_GATEWAY, format!("ollama cloud: {e}")))?; (r, "ollama_cloud".to_string()) } + "openrouter" | "openrouter_free" => { + // Free-tier rescue rung. Added 2026-04-24 after iter 5 + // repeated Ollama Cloud 502s on kimi-k2:1t — OpenRouter + // gives a different provider backbone as fallback. + let key = state.openrouter_key.as_deref().ok_or(( + StatusCode::SERVICE_UNAVAILABLE, + "OPENROUTER_API_KEY not configured".to_string(), + ))?; + let r = openrouter::chat(key, &*req_for_adapter) + .await + .map_err(|e| (StatusCode::BAD_GATEWAY, format!("openrouter: {e}")))?; + (r, "openrouter".to_string()) + } + "gemini" => { + // Phase 40 provider adapter. Google Generative Language + // API via query-string key auth (not bearer). + let key = state.gemini_key.as_deref().ok_or(( + StatusCode::SERVICE_UNAVAILABLE, + "GEMINI_API_KEY not configured".to_string(), + ))?; + let r = gemini::chat(key, &*req_for_adapter) + .await + .map_err(|e| (StatusCode::BAD_GATEWAY, format!("gemini: {e}")))?; + (r, "gemini".to_string()) + } + "claude" | "anthropic" => { + // Phase 40 provider adapter. Anthropic Messages API via + // x-api-key header + anthropic-version:2023-06-01. + let key = state.claude_key.as_deref().ok_or(( + StatusCode::SERVICE_UNAVAILABLE, + "ANTHROPIC_API_KEY not configured".to_string(), + ))?; + let r = claude::chat(key, &*req_for_adapter) + .await + .map_err(|e| (StatusCode::BAD_GATEWAY, format!("claude: {e}")))?; + (r, "claude".to_string()) + } + "kimi" => { + // Direct Kimi For Coding provider — bypasses Ollama Cloud's + // upstream-broken kimi-k2:1t and OpenRouter's rate-limited + // moonshotai/kimi-k2.6. Uses sk-kimi-* keys from the Kimi + // membership console. + let key = state.kimi_key.as_deref().ok_or(( + StatusCode::SERVICE_UNAVAILABLE, + "KIMI_API_KEY not configured".to_string(), + ))?; + let r = kimi::chat(key, &*req_for_adapter) + .await + .map_err(|e| (StatusCode::BAD_GATEWAY, format!("kimi: {e}")))?; + (r, "kimi".to_string()) + } + "opencode" => { + // OpenCode GO multi-vendor gateway — Claude Opus 4.7, + // GPT-5.5-pro, Gemini 3.1-pro, Kimi K2.6, DeepSeek, GLM, + // Qwen, free-tier. OpenAI-compat at opencode.ai/zen/go/v1. + let key = state.opencode_key.as_deref().ok_or(( + StatusCode::SERVICE_UNAVAILABLE, + "OPENCODE_API_KEY not configured".to_string(), + ))?; + let r = opencode::chat(key, &*req_for_adapter) + .await + .map_err(|e| (StatusCode::BAD_GATEWAY, format!("opencode: {e}")))?; + (r, "opencode".to_string()) + } other => { return Err(( StatusCode::BAD_REQUEST, - format!("unknown provider '{other}' — supported: ollama, ollama_cloud"), + format!("unknown provider '{other}' — supported: ollama, ollama_cloud, openrouter, gemini, claude, kimi, opencode"), )); } }; @@ -179,7 +488,7 @@ async fn chat( // untouched. if let Some(lf) = &state.langfuse { let output = resp.choices.first() - .map(|c| c.message.content.clone()) + .map(|c| c.message.text()) .unwrap_or_default(); lf.emit_chat(langfuse_trace::ChatTrace { provider: used_provider.clone(), @@ -197,6 +506,46 @@ async fn chat( }); } + // Phase 40 part 2 — fire-and-forget /event to observer at :3800. + // Same ring-buffer that scrum + scenario events land in, so any + // tool-routed-through-our-gateway (Pi, Archon, openai SDK clients) + // shows up alongside scrum_master events for KB consolidation + + // pathway-memory + bug-fingerprint compounding. Best-effort: + // observer being down doesn't block the chat response. + { + let provider = used_provider.clone(); + let model = resp.model.clone(); + let prompt_tokens = resp.usage.prompt_tokens; + let completion_tokens = resp.usage.completion_tokens; + let success = true; + tokio::spawn(async move { + let body = serde_json::json!({ + "endpoint": "/v1/chat", + "source": "v1.chat", + "event_kind": "chat_completion", + "input_summary": format!( + "{} {} prompt={}t", + provider, model, prompt_tokens + ), + "output_summary": format!( + "completion={}t {}ms", + completion_tokens, latency_ms + ), + "success": success, + "duration_ms": latency_ms, + }); + let client = reqwest::Client::builder() + .timeout(std::time::Duration::from_secs(2)) + .build() + .unwrap_or_else(|_| reqwest::Client::new()); + let _ = client + .post("http://localhost:3800/event") + .json(&body) + .send() + .await; + }); + } + // Phase 40: per-provider usage tracking { let mut u = state.usage.write().await; @@ -220,6 +569,43 @@ async fn usage(State(state): State) -> impl IntoResponse { Json(snapshot) } +/// Production operational health endpoint. +/// +/// `/v1/health` reports per-subsystem status as a JSON object so an +/// operator (or the lakehouse-auditor service, or a load balancer) +/// can verify the gateway is fully booted, has its provider keys +/// loaded, the worker roster is hot, and Langfuse is reachable. +/// Returns 200 always — fields are observed-state, not pass/fail +/// gates. A monitoring tool should evaluate the booleans + counts +/// against its own thresholds. +async fn health(State(state): State) -> impl IntoResponse { + // Honest worker count via WorkerLookup::len. Production switchover + // verification: after swapping workers_500k.parquet → real Chicago + // data and restarting, this number should match the row count of + // the new file. 0 means the file was missing / unreadable / had a + // schema mismatch and the gateway booted with the empty fallback. + let workers_count = state.validate_workers.len(); + let providers_configured = serde_json::json!({ + "ollama_cloud": state.ollama_cloud_key.is_some(), + "openrouter": state.openrouter_key.is_some(), + "kimi": state.kimi_key.is_some(), + "opencode": state.opencode_key.is_some(), + "gemini": state.gemini_key.is_some(), + "claude": state.claude_key.is_some(), + }); + let langfuse_configured = state.langfuse.is_some(); + let usage_snapshot = state.usage.read().await.clone(); + Json(serde_json::json!({ + "status": "ok", + "workers_count": workers_count, + "workers_loaded": workers_count > 0, + "providers_configured": providers_configured, + "langfuse_configured": langfuse_configured, + "usage_total_requests": usage_snapshot.requests, + "usage_by_provider": usage_snapshot.by_provider.keys().collect::>(), + })) +} + // Phase 38 is stateless — no session persistence yet. Return an empty // list in OpenAI-ish shape so clients that probe this endpoint don't // 404. Real session state lands in Phase 41 with the profile-system @@ -251,7 +637,7 @@ mod tests { assert_eq!(r.model, "qwen3.5:latest"); assert_eq!(r.messages.len(), 2); assert_eq!(r.messages[0].role, "system"); - assert_eq!(r.messages[1].content, "Hi"); + assert_eq!(r.messages[1].text(), "Hi"); assert_eq!(r.temperature, Some(0.2)); assert_eq!(r.max_tokens, Some(100)); } diff --git a/crates/gateway/src/v1/mode.rs b/crates/gateway/src/v1/mode.rs new file mode 100644 index 0000000..4123b6e --- /dev/null +++ b/crates/gateway/src/v1/mode.rs @@ -0,0 +1,1076 @@ +//! Mode router — task_class → mode + model recommendation. +//! +//! HANDOVER §queued (2026-04-25): "Mode router — port LLM Team multi-model +//! patterns. Pick the right TOOL/MODE for each task class via the matrix, +//! not cascade through models." +//! +//! Two-stage architecture: +//! +//! 1. **Decision** (`POST /v1/mode`) — given `{task_class, prompt}`, +//! consult `config/modes.toml` + (future) pathway memory and return +//! `{mode, model, decision_trace}`. Pure recommendation; no execution. +//! +//! 2. **Execution** (`POST /v1/mode/execute`) — given `{mode, prompt, ...}`, +//! proxy to LLM Team UI (`localhost:5000/api/run`) which has all 25 +//! mode runners implemented. As Rust-native runners land in this +//! crate, they short-circuit before the proxy. +//! +//! The split lets us A/B-test the routing logic (decision-only) without +//! committing to running every recommendation. It also keeps the pure +//! decision function simple enough to unit-test exhaustively. + +use axum::{Json, extract::State, http::StatusCode, response::IntoResponse}; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::sync::OnceLock; + +use super::V1State; + +/// Validated against the LLM Team /api/run handler at +/// /root/llm_team_ui.py:10581. Kept in sync manually — adding a mode +/// here without adding it upstream returns 400 from the proxy. +/// +/// Modes prefixed with the codebase name (e.g. `codereview_lakehouse`) +/// are NATIVE Rust enrichment runners — they don't proxy to LLM Team, +/// they compose the lakehouse's own context primitives (pathway memory, +/// relevance filter, matrix corpora) into a one-shot prompt for the +/// recommended model. Native modes are listed alongside upstream ones +/// so the router can pick either without callers caring. +const VALID_MODES: &[&str] = &[ + "brainstorm", "pipeline", "debate", "validator", "roundrobin", + "redteam", "consensus", "codereview", "ladder", "tournament", + "evolution", "blindassembly", "staircase", "drift", "mesh", + "hallucination", "timeloop", "research", "eval", "extract", + "refine", "adaptive", "deep_analysis", "distill", + // Native runners (not in LLM Team — handled by /v1/mode/execute). + // Each is a parameterized preset of EnrichmentFlags below — designed + // as a deliberate experiment so we can read the matrix and identify + // which signals are doing real work vs adding latency for nothing. + "codereview_lakehouse", // all enrichment on (ceiling) + "codereview_null", // raw file + generic prompt (baseline) + "codereview_isolation", // file + pathway only (no matrix) + "codereview_matrix_only", // file + matrix only (no pathway) + "codereview_playbook_only", // pathway only, NO file content (lossy ceiling) + "staffing_inference_lakehouse", // staffing-domain composer (Pass 4) + "pr_audit", // PR-wide claim-vs-diff verifier (auditor) +]; + +/// Whether a mode is handled natively in this gateway vs proxied to +/// LLM Team. Drives /v1/mode/execute dispatch. +fn is_native_mode(mode: &str) -> bool { + matches!( + mode, + "codereview_lakehouse" + | "codereview_null" + | "codereview_isolation" + | "codereview_matrix_only" + | "codereview_playbook_only" + | "staffing_inference_lakehouse" + | "pr_audit" + ) +} + +/// Per-mode enrichment knobs — each native mode is a preset over these +/// flags. Exists so the runner code is one path (less drift between +/// modes) and the comparison harness can read which signals fired. +#[derive(Debug, Clone, Copy, Serialize)] +pub struct EnrichmentFlags { + pub include_file_content: bool, + pub include_bug_fingerprints: bool, + pub include_matrix_chunks: bool, + pub use_relevance_filter: bool, + pub framing: ReviewerFraming, +} + +#[derive(Debug, Clone, Copy, Serialize)] +pub enum ReviewerFraming { + Adversarial, // forensic, ranked findings + verdict (lakehouse default) + Generic, // "review this" — no codebase priors (null baseline) + Staffing, // staffing-domain coordinator framing (Pass 4) + PrAudit, // PR-wide claim verification — JSON-shaped {claim_verdicts} +} + +fn flags_for_mode(mode: &str) -> EnrichmentFlags { + match mode { + "codereview_null" => EnrichmentFlags { + include_file_content: true, + include_bug_fingerprints: false, + include_matrix_chunks: false, + use_relevance_filter: false, + framing: ReviewerFraming::Generic, + }, + "codereview_isolation" => EnrichmentFlags { + include_file_content: true, + include_bug_fingerprints: true, + include_matrix_chunks: false, + use_relevance_filter: false, + framing: ReviewerFraming::Adversarial, + }, + "codereview_matrix_only" => EnrichmentFlags { + include_file_content: true, + include_bug_fingerprints: false, + include_matrix_chunks: true, + use_relevance_filter: true, + framing: ReviewerFraming::Adversarial, + }, + "codereview_playbook_only" => EnrichmentFlags { + include_file_content: false, // lossy on purpose — measures pathway-alone ceiling + include_bug_fingerprints: true, + include_matrix_chunks: false, + use_relevance_filter: false, + framing: ReviewerFraming::Adversarial, + }, + "staffing_inference_lakehouse" => EnrichmentFlags { + // Staffing reuses the same composer architecture but with + // domain-specific framing. file_content here = the request + // payload (e.g. "fill 2 welders in Toledo OH"), bug_fingerprints + // surface prior playbook patterns from this geo+role, matrix + // pulls candidate workers + city/state demand chunks. + include_file_content: true, + include_bug_fingerprints: true, + include_matrix_chunks: true, + use_relevance_filter: true, + framing: ReviewerFraming::Staffing, + }, + "pr_audit" => EnrichmentFlags { + // PR-wide claim verification. file_content = the diff text + // (or curated scratchpad for huge PRs — auditor handles the + // tree-split BEFORE calling). bug_fingerprints surface + // prior PR-level patterns. matrix corpus pulls + // lakehouse_answers_v1 — prior accepted scrum reviews + + // observer escalations — so the reviewer sees how similar + // claims were resolved before. relevance filter on to drop + // adjacency pollution from the answer corpus. + include_file_content: true, + include_bug_fingerprints: true, + include_matrix_chunks: true, + use_relevance_filter: true, + framing: ReviewerFraming::PrAudit, + }, + // Default (codereview_lakehouse): everything on. + _ => EnrichmentFlags { + include_file_content: true, + include_bug_fingerprints: true, + include_matrix_chunks: true, + use_relevance_filter: true, + framing: ReviewerFraming::Adversarial, + }, + } +} + +#[derive(Clone, Debug, Deserialize)] +pub struct TaskClassEntry { + pub name: String, + pub preferred_mode: String, + #[serde(default)] + pub fallback_modes: Vec, + pub default_model: String, + /// One or more corpora the mode runner queries (top-k per corpus, + /// merged by score before the relevance filter). Accepts a single + /// string or an array in modes.toml — `deserialize_string_or_vec` + /// handles both shapes for backward compat. + #[serde(default, deserialize_with = "deserialize_string_or_vec")] + pub matrix_corpus: Vec, +} + +/// Accept `key = "x"` or `key = ["x", "y"]` in TOML/JSON. Empty string or +/// missing field → empty vec. +fn deserialize_string_or_vec<'de, D>(d: D) -> Result, D::Error> +where D: serde::Deserializer<'de> { + use serde::de::Error; + let v = serde_json::Value::deserialize(d).map_err(D::Error::custom)?; + match v { + serde_json::Value::Null => Ok(vec![]), + serde_json::Value::String(s) if s.is_empty() => Ok(vec![]), + serde_json::Value::String(s) => Ok(vec![s]), + serde_json::Value::Array(a) => a + .into_iter() + .map(|x| x.as_str().map(String::from) + .ok_or_else(|| D::Error::custom("matrix_corpus array must contain strings"))) + .collect(), + other => Err(D::Error::custom(format!("matrix_corpus must be string or array, got {other:?}"))), + } +} + +#[derive(Clone, Debug, Deserialize)] +pub struct DefaultEntry { + pub preferred_mode: String, + #[serde(default)] + pub fallback_modes: Vec, + pub default_model: String, +} + +#[derive(Clone, Debug, Deserialize)] +pub struct ModeRouterConfig { + #[serde(default, rename = "task_class")] + pub task_classes: Vec, + pub default: DefaultEntry, +} + +impl ModeRouterConfig { + pub fn lookup(&self, task_class: &str) -> Option<&TaskClassEntry> { + self.task_classes.iter().find(|t| t.name == task_class) + } +} + +/// Process-global config cache. Loaded on first request from +/// `config/modes.toml` (or `LH_MODES_CONFIG`). If parsing fails the +/// router falls back to a hard-coded default so a malformed config can +/// never take the gateway down. +static CONFIG: OnceLock = OnceLock::new(); + +fn load_config() -> &'static ModeRouterConfig { + CONFIG.get_or_init(|| { + let path = std::env::var("LH_MODES_CONFIG") + .unwrap_or_else(|_| "config/modes.toml".to_string()); + match std::fs::read_to_string(&path) { + Ok(s) => match toml::from_str::(&s) { + Ok(c) => { + tracing::info!(target: "v1::mode", "loaded {} task classes from {}", c.task_classes.len(), path); + c + } + Err(e) => { + tracing::warn!(target: "v1::mode", "parse {} failed ({}), using built-in default", path, e); + fallback_config() + } + }, + Err(e) => { + tracing::warn!(target: "v1::mode", "read {} failed ({}), using built-in default", path, e); + fallback_config() + } + } + }) +} + +fn fallback_config() -> ModeRouterConfig { + ModeRouterConfig { + task_classes: vec![], + default: DefaultEntry { + preferred_mode: "pipeline".into(), + fallback_modes: vec!["consensus".into(), "ladder".into()], + default_model: "qwen3.5:latest".into(), + }, + } +} + +#[derive(Deserialize, Debug)] +pub struct RouteRequest { + pub task_class: String, + /// Reserved for future matrix-informed routing (cosine against + /// matrix_corpus + pathway memory). Currently parsed but unused by + /// the decision logic — kept on the API so callers can land their + /// integration without waiting on the matrix-signal hookup. + #[serde(default)] + #[allow(dead_code)] + pub prompt: Option, + /// Caller-supplied override. When set, the router honors it (with a + /// validation check against VALID_MODES) and skips the matrix + /// signal — useful for testing a specific mode in isolation. + #[serde(default)] + pub force_mode: Option, +} + +#[derive(Serialize, Debug)] +pub struct DecisionTrace { + pub task_class_matched: bool, + pub source: &'static str, // "config" | "default" | "force_mode" + pub fallbacks: Vec, + pub matrix_corpus: Vec, + pub notes: Vec, +} + +#[derive(Serialize, Debug)] +pub struct RouteDecision { + pub mode: String, + pub model: String, + pub decision: DecisionTrace, +} + +/// `POST /v1/mode` — pure recommendation. Returns a `RouteDecision` +/// with the chosen mode + model + reasoning trail. Caller is then +/// responsible for invoking the mode (either via `/v1/mode/execute` +/// proxy or directly against the LLM Team `/api/run`). +pub async fn route( + State(_state): State, + Json(req): Json, +) -> impl IntoResponse { + let cfg = load_config(); + let mut notes = Vec::new(); + + // force_mode short-circuits everything else but still validates. + if let Some(forced) = req.force_mode.as_deref() { + if !VALID_MODES.contains(&forced) { + return Err(( + StatusCode::BAD_REQUEST, + Json(serde_json::json!({ + "error": format!("Unknown mode: {}", forced), + "valid_modes": VALID_MODES, + })), + )); + } + let model = cfg + .lookup(&req.task_class) + .map(|t| t.default_model.clone()) + .unwrap_or_else(|| cfg.default.default_model.clone()); + notes.push("force_mode override accepted".into()); + return Ok(Json(RouteDecision { + mode: forced.to_string(), + model, + decision: DecisionTrace { + task_class_matched: cfg.lookup(&req.task_class).is_some(), + source: "force_mode", + fallbacks: vec![], + matrix_corpus: vec![], + notes, + }, + })); + } + + // Lookup task class; fall through to default if absent. + if let Some(tc) = cfg.lookup(&req.task_class) { + notes.push(format!( + "task_class '{}' matched, preferred mode '{}'", + tc.name, tc.preferred_mode + )); + if !VALID_MODES.contains(&tc.preferred_mode.as_str()) { + notes.push(format!( + "preferred '{}' not in VALID_MODES — falling through to first valid fallback", + tc.preferred_mode + )); + for fb in &tc.fallback_modes { + if VALID_MODES.contains(&fb.as_str()) { + notes.push(format!("fallback '{}' selected", fb)); + return Ok(Json(RouteDecision { + mode: fb.clone(), + model: tc.default_model.clone(), + decision: DecisionTrace { + task_class_matched: true, + source: "config", + fallbacks: tc.fallback_modes.clone(), + matrix_corpus: tc.matrix_corpus.clone(), + notes, + }, + })); + } + } + // No fallback was valid either — return 422 so the caller + // knows the config is broken for this task class. + return Err(( + StatusCode::UNPROCESSABLE_ENTITY, + Json(serde_json::json!({ + "error": format!( + "task_class '{}' has no valid mode (preferred='{}', fallbacks={:?})", + req.task_class, tc.preferred_mode, tc.fallback_modes + ), + "valid_modes": VALID_MODES, + })), + )); + } + return Ok(Json(RouteDecision { + mode: tc.preferred_mode.clone(), + model: tc.default_model.clone(), + decision: DecisionTrace { + task_class_matched: true, + source: "config", + fallbacks: tc.fallback_modes.clone(), + matrix_corpus: tc.matrix_corpus.clone(), + notes, + }, + })); + } + + notes.push(format!( + "task_class '{}' not in config, using default", + req.task_class + )); + Ok(Json(RouteDecision { + mode: cfg.default.preferred_mode.clone(), + model: cfg.default.default_model.clone(), + decision: DecisionTrace { + task_class_matched: false, + source: "default", + fallbacks: cfg.default.fallback_modes.clone(), + matrix_corpus: vec![], + notes, + }, + })) +} + +/// `GET /v1/mode/list` — operator-facing introspection. Returns the +/// current registry table + valid modes so a UI can render the matrix +/// without re-parsing the TOML. +pub async fn list(State(_state): State) -> impl IntoResponse { + let cfg = load_config(); + let task_map: HashMap<&str, serde_json::Value> = cfg + .task_classes + .iter() + .map(|t| { + ( + t.name.as_str(), + serde_json::json!({ + "preferred_mode": t.preferred_mode, + "fallback_modes": t.fallback_modes, + "default_model": t.default_model, + "matrix_corpus": t.matrix_corpus, + }), + ) + }) + .collect(); + Json(serde_json::json!({ + "task_classes": task_map, + "default": { + "preferred_mode": cfg.default.preferred_mode, + "fallback_modes": cfg.default.fallback_modes, + "default_model": cfg.default.default_model, + }, + "valid_modes": VALID_MODES, + })) +} + +// ─── Native runner: codereview_lakehouse ─── +// +// Enrichment composer for the lakehouse-specific code review mode. +// Pulls every context primitive the gateway exposes — focus file +// content, pathway-memory bug fingerprints, matrix corpus chunks +// (post relevance filter) — bundles them into ONE prompt designed +// for one-shot success against qwen3-coder:480b. The whole point of +// the mode is that the model gets it right the first time because +// the prompt was molded for THIS file in THIS codebase. +// +// Network composition only — no Rust port of the relevance scorer. +// Every primitive is already an HTTP endpoint; the runner just stitches. + +#[derive(Deserialize, Debug)] +pub struct ExecuteRequest { + pub task_class: String, + pub file_path: String, + /// If absent, the runner reads the file from disk relative to the + /// gateway working directory. Useful for test harnesses that don't + /// want to rely on filesystem state. + #[serde(default)] + pub file_content: Option, + /// Override the resolved mode — same semantics as RouteRequest. + #[serde(default)] + pub force_mode: Option, + /// Override the resolved model. Defaults to the task_class's + /// default_model from modes.toml. + #[serde(default)] + pub force_model: Option, + /// Reserved for ad-hoc questions about the file. If omitted, the + /// runner uses its built-in forensic-review framing. + #[serde(default)] + pub user_question: Option, + /// Override the matrix corpus (or corpora) the runner queries. + /// Accepts a single string or array — same semantics as + /// modes.toml's `matrix_corpus`. Empty/missing → use the task + /// class default. Multi-corpus path: top-k retrieved from each, + /// merged and re-sorted by score before the relevance filter. + #[serde(default, deserialize_with = "deserialize_string_or_vec")] + pub force_matrix_corpus: Vec, + /// Override the relevance filter threshold (default 0.3). Setting + /// to 0 keeps every chunk; raising rejects more aggressively. Used + /// to find the threshold sweet spot per task class. + #[serde(default)] + pub force_relevance_threshold: Option, + /// Override the LLM temperature (default 0.1). Used by Pass 3 + /// variance testing to measure run-to-run stability. + #[serde(default)] + pub force_temperature: Option, +} + +#[derive(Serialize, Debug, Default)] +pub struct EnrichmentSources { + pub focus_file_bytes: usize, + pub bug_fingerprints_count: usize, + pub matrix_chunks_kept: usize, + pub matrix_chunks_dropped: usize, + pub matrix_corpus: Vec, + pub relevance_filter_used: bool, + /// Set when the model-aware downgrade fires — records the mode the + /// caller was originally routed to before is_weak_model() flipped + /// it. None means no downgrade happened. + #[serde(skip_serializing_if = "Option::is_none")] + pub downgraded_from: Option, + pub enrichment_warnings: Vec, + /// Which enrichment knobs the runner used for this mode. Lets + /// the comparison aggregator group runs by signal-set. + pub flags: Option, +} + +#[derive(Serialize, Debug)] +pub struct ExecuteResponse { + pub mode: String, + pub model: String, + pub task_class: String, + pub enriched_prompt_chars: usize, + pub enriched_prompt_preview: String, + pub sources: EnrichmentSources, + pub response: String, + pub latency_ms: u64, +} + +const FRAMING_ADVERSARIAL: &str = "You are an adversarial code reviewer for the Lakehouse codebase \ +(Rust + DataFusion + Parquet + object storage). Audit the focus file forensically. \ +Output a markdown report with: (1) one-line verdict (pass | needs_patch | fail), (2) ranked \ +findings table with file:line, evidence, severity, confidence percent, (3) concrete patch \ +suggestions, (4) PRD/ADR refs where applicable. Be precise — assume nothing works until \ +proven. Do NOT hedge."; + +const FRAMING_GENERIC: &str = "You are a code reviewer. Read the file below and produce a \ +markdown review with findings."; + +const FRAMING_STAFFING: &str = "You are a senior staffing coordinator for a light-industrial \ +labor agency. You receive a fill request (role × count × city × deadline) and have access \ +to historical playbook patterns from prior fills in this geo, plus a corpus of candidate \ +workers + demand signals. Produce a markdown plan with: (1) one-line verdict (fillable | \ +contingent | unfillable), (2) ranked candidate list with name, city, role, distance, prior \ +fill citations from the playbook, (3) risks (double-booking, eligibility gaps, geo stretch) \ +with severity + confidence percent, (4) playbook reference IDs you used. Be precise — only \ +recommend candidates whose names appear in the matrix data; do NOT fabricate workers."; + +const FRAMING_PR_AUDIT: &str = "You are an adversarial PR claim verifier for the Lakehouse \ +codebase (Rust + DataFusion + Parquet + object storage). Caller passes ship-claims from a PR \ +description and the unified diff (or a curated scratchpad of it for huge PRs). Your job: for \ +each claim, decide whether the diff actually backs it. Be ruthless — claim-diff divergence \ +is the failure mode this auditor exists to prevent. Output ONLY a single JSON object with \ +this exact shape:\n\ +{\n\ + \"claim_verdicts\": [\n\ + {\"claim_idx\": , \"backed\": , \"evidence\": \"\"}\n\ + ],\n\ + \"unflagged_gaps\": [\"\"]\n\ +}\n\ +No markdown, no preamble, no explanation outside the JSON. Every input claim must appear in \ +claim_verdicts exactly once. Lean toward backed=false when in doubt — false positives waste \ +human time but false negatives ship broken claims."; + +fn framing_text(f: ReviewerFraming) -> &'static str { + match f { + ReviewerFraming::Adversarial => FRAMING_ADVERSARIAL, + ReviewerFraming::Generic => FRAMING_GENERIC, + ReviewerFraming::Staffing => FRAMING_STAFFING, + ReviewerFraming::PrAudit => FRAMING_PR_AUDIT, + } +} + +/// Strong-model heuristic for the model-aware enrichment downgrade. +/// +/// Pass 5 variance test (2026-04-26, see docs/MODE_RUNNER_TUNING_PLAN.md) +/// proved that on `x-ai/grok-4.1-fast`, composing matrix corpora into the +/// `codereview_lakehouse` prompt LOST 5/5 head-to-head reps against the +/// matrix-free `codereview_isolation` mode. Strong models have enough +/// native capacity that bug fingerprints + adversarial framing + file +/// content carry them; matrix chunks displace depth-of-analysis. +/// +/// We default to "strong" (downgrade matrix off) because most production +/// traffic uses paid models. The explicit `weak` predicate keeps the +/// list small and easy to extend — anything matching `:free` (OpenRouter +/// free tier) or the local last-resort qwen3.5 stays on the full +/// `codereview_lakehouse` path where matrix demonstrably helped during +/// the 2026-04-26 free-tier bake-off. +fn is_weak_model(model: &str) -> bool { + if model.ends_with(":free") || model.contains(":free/") { + return true; + } + // Local last-resort rung from the scrum ladder. Other local models + // can be added here as we test them. + matches!(model, "qwen3.5:latest" | "qwen3:latest") +} + +pub async fn execute( + State(_state): State, + Json(req): Json, +) -> impl IntoResponse { + let cfg = load_config(); + let t0 = std::time::Instant::now(); + + // Resolve mode + model (mirrors /v1/mode logic). + let tc = cfg.lookup(&req.task_class); + let mode = req + .force_mode + .clone() + .or_else(|| tc.map(|t| t.preferred_mode.clone())) + .unwrap_or_else(|| cfg.default.preferred_mode.clone()); + let model = req + .force_model + .clone() + .or_else(|| tc.map(|t| t.default_model.clone())) + .unwrap_or_else(|| cfg.default.default_model.clone()); + let matrix_corpus: Vec = tc + .map(|t| t.matrix_corpus.clone()) + .unwrap_or_default(); + + // Model-aware enrichment downgrade (2026-04-26 pass 5 finding). + // If a caller resolves `codereview_lakehouse` against a strong + // model, downgrade to `codereview_isolation` so we don't pollute + // the prompt with matrix chunks the model would do better without. + // `LH_FORCE_FULL_ENRICHMENT=1` bypasses for diagnostic runs. + // `force_mode` from the caller is treated as opt-in to the chosen + // mode and skips the downgrade — experiments need to inspect exact + // mode behavior on whatever model they pass. + let force_full = std::env::var("LH_FORCE_FULL_ENRICHMENT") + .map(|v| v == "1" || v.eq_ignore_ascii_case("true")) + .unwrap_or(false); + let downgraded_from = if mode == "codereview_lakehouse" + && req.force_mode.is_none() + && !force_full + && !is_weak_model(&model) + { + tracing::info!( + target: "v1::mode", + "downgrade codereview_lakehouse -> codereview_isolation for strong model {}", + model + ); + Some(mode.clone()) + } else { + None + }; + let mode = if downgraded_from.is_some() { + "codereview_isolation".to_string() + } else { + mode + }; + + if !is_native_mode(&mode) { + // Native execute is the only path implemented; LLM-Team proxy + // is queued behind this. Surface a clear 501 so callers know. + return Err(( + StatusCode::NOT_IMPLEMENTED, + Json(serde_json::json!({ + "error": format!( + "mode '{}' has no native runner — proxy to /api/run not yet wired", + mode + ), + "hint": "use force_mode=codereview_lakehouse, or call LLM Team /api/run directly until proxy lands", + })), + )); + } + + // Caller can override the matrix corpus per-call (Pass 2 corpus + // tightening). Empty force_matrix_corpus falls back to modes.toml. + let matrix_corpus: Vec = if req.force_matrix_corpus.is_empty() { + matrix_corpus + } else { + req.force_matrix_corpus.clone() + }; + let flags = flags_for_mode(&mode); + let mut sources = EnrichmentSources { + matrix_corpus: matrix_corpus.clone(), + flags: Some(flags), + downgraded_from: downgraded_from.clone(), + ..Default::default() + }; + + // Step 1: focus file content (always read — even modes that don't + // include it in the prompt may need it for citation/sources). + let file_content = match req.file_content.clone() { + Some(c) => c, + None => match std::fs::read_to_string(&req.file_path) { + Ok(c) => c, + Err(e) => { + return Err(( + StatusCode::BAD_REQUEST, + Json(serde_json::json!({ + "error": format!("read {} failed: {}", req.file_path, e), + })), + )); + } + }, + }; + sources.focus_file_bytes = file_content.len(); + + // Local HTTP client for composing internal calls. Short timeout + // because every endpoint is on localhost; the LLM call uses its + // own longer timeout further down. + let client = match reqwest::Client::builder() + .timeout(std::time::Duration::from_secs(8)) + .build() + { + Ok(c) => c, + Err(e) => { + return Err(( + StatusCode::INTERNAL_SERVER_ERROR, + Json(serde_json::json!({"error": format!("client build: {e}")})), + )); + } + }; + + // Step 2: pathway memory bug fingerprints for this file area. + let mut bug_preamble = String::new(); + if flags.include_bug_fingerprints { + let body = serde_json::json!({ + "task_class": req.task_class, + "file_path": req.file_path, + "signal_class": null, + "limit": 10, + }); + match client + .post("http://localhost:3100/vectors/pathway/bug_fingerprints") + .json(&body) + .send() + .await + { + Ok(r) if r.status().is_success() => { + if let Ok(j) = r.json::().await { + let fps = j.get("fingerprints").and_then(|v| v.as_array()).cloned().unwrap_or_default(); + sources.bug_fingerprints_count = fps.len(); + if !fps.is_empty() { + bug_preamble.push_str( + "📚 PATHWAY MEMORY — BUGS PREVIOUSLY FOUND IN THIS FILE AREA:\n", + ); + for fp in &fps { + let pk = fp.get("pattern_key").and_then(|v| v.as_str()).unwrap_or("?"); + let occ = fp.get("occurrences").and_then(|v| v.as_u64()).unwrap_or(0); + let ex = fp.get("example").and_then(|v| v.as_str()).unwrap_or(""); + bug_preamble.push_str(&format!( + " • {} (×{}) e.g. `{}`\n", + pk, occ, ex + )); + } + bug_preamble.push_str("Watch for these patterns recurring.\n\n"); + } + } + } + Ok(r) => sources + .enrichment_warnings + .push(format!("bug_fingerprints HTTP {}", r.status())), + Err(e) => sources + .enrichment_warnings + .push(format!("bug_fingerprints err: {e}")), + } + } + + // Step 3: matrix corpus search. Multi-corpus path: query top_k from + // each, merge, re-sort by score, take top 8 overall before the + // relevance filter — orthogonal corpora (e.g. arch + symbols) get + // composed without one swamping the other on chunk count alone. + let mut raw_chunks: Vec = vec![]; + if flags.include_matrix_chunks && !matrix_corpus.is_empty() { + let query_str = format!( + "{} {}\n{}", + req.task_class, + req.file_path, + &file_content[..file_content.len().min(500)] + ); + let per_corpus_k = if matrix_corpus.len() == 1 { 8 } else { 6 }; + for corpus in &matrix_corpus { + let body = serde_json::json!({ + "index_name": corpus, + "query": query_str, + "top_k": per_corpus_k, + }); + match client + .post("http://localhost:3100/vectors/search") + .json(&body) + .send() + .await + { + Ok(r) if r.status().is_success() => { + if let Ok(j) = r.json::().await { + if let Some(arr) = j.get("results").and_then(|v| v.as_array()) { + for mut c in arr.iter().cloned() { + // Tag the corpus origin on each chunk so + // dropped/kept telemetry can attribute + // signal back to its source corpus. + if let serde_json::Value::Object(ref mut obj) = c { + obj.insert( + "corpus".to_string(), + serde_json::Value::String(corpus.clone()), + ); + } + raw_chunks.push(c); + } + } + } + } + Ok(r) => sources + .enrichment_warnings + .push(format!("matrix_search[{}] HTTP {}", corpus, r.status())), + Err(e) => sources + .enrichment_warnings + .push(format!("matrix_search[{}] err: {e}", corpus)), + } + } + // Sort merged chunks by score desc and take the global top 8. + raw_chunks.sort_by(|a, b| { + let sa = a.get("score").and_then(|v| v.as_f64()).unwrap_or(0.0); + let sb = b.get("score").and_then(|v| v.as_f64()).unwrap_or(0.0); + sb.partial_cmp(&sa).unwrap_or(std::cmp::Ordering::Equal) + }); + raw_chunks.truncate(8); + } + + // Step 4: relevance filter — drop adjacency pollution. + let kept_chunks: Vec = if flags.use_relevance_filter && !raw_chunks.is_empty() { + let chunks_for_filter: Vec = raw_chunks + .iter() + .map(|c| { + serde_json::json!({ + "source": c.get("source").cloned().unwrap_or_default(), + "doc_id": c.get("doc_id").cloned().unwrap_or_default(), + "text": c.get("chunk_text").or_else(|| c.get("text")).cloned().unwrap_or_default(), + "score": c.get("score").cloned().unwrap_or(serde_json::json!(0.0)), + }) + }) + .collect(); + let body = serde_json::json!({ + "focus_file": { "path": req.file_path, "content": file_content }, + "chunks": chunks_for_filter, + "threshold": req.force_relevance_threshold.unwrap_or(0.3), + }); + match client + .post("http://localhost:3800/relevance") + .json(&body) + .send() + .await + { + Ok(r) if r.status().is_success() => { + sources.relevance_filter_used = true; + if let Ok(j) = r.json::().await { + let kept = j.get("kept").and_then(|v| v.as_array()).cloned().unwrap_or_default(); + let dropped = j.get("dropped").and_then(|v| v.as_array()).cloned().unwrap_or_default(); + sources.matrix_chunks_kept = kept.len(); + sources.matrix_chunks_dropped = dropped.len(); + kept + } else { + raw_chunks + } + } + _ => { + sources + .enrichment_warnings + .push("relevance filter unreachable, using raw chunks".to_string()); + raw_chunks + } + } + } else if !flags.use_relevance_filter && !raw_chunks.is_empty() { + // Take raw matrix chunks unfiltered — `codereview_matrix_only` + // turns the filter off intentionally to measure how much + // pollution the filter is actually catching. + sources.matrix_chunks_kept = raw_chunks.len(); + raw_chunks.clone() + } else { + vec![] + }; + + // Step 5: assemble the prompt — strictly per-flag so we don't + // leak signals across modes. + let mut user_prompt = String::new(); + if flags.include_bug_fingerprints { + user_prompt.push_str(&bug_preamble); + } + if flags.include_matrix_chunks && !kept_chunks.is_empty() { + user_prompt.push_str("📁 RELATED CONTEXT (matrix chunks):\n"); + for c in &kept_chunks { + // Prefer doc_id for the tag — corpus builders encode origin + // in doc_id (e.g. `adr:017`, `phase:19`) so the reviewer sees + // useful provenance instead of a generic source label. + let tag = c.get("doc_id").and_then(|v| v.as_str()) + .filter(|s| !s.is_empty()) + .or_else(|| c.get("source").and_then(|v| v.as_str())) + .unwrap_or("?"); + let txt = c.get("text").or_else(|| c.get("chunk_text")) + .and_then(|v| v.as_str()).unwrap_or(""); + user_prompt.push_str(&format!(" [{}] {}\n", tag, &txt[..txt.len().min(280)])); + } + user_prompt.push_str("\n"); + } + if flags.include_file_content { + user_prompt.push_str(&format!("FILE: {}\n```rust\n{}\n```\n", req.file_path, file_content)); + } else { + // Lossy mode — playbook_only intentionally omits file content + // to measure how much value pathway memory carries on its own. + user_prompt.push_str(&format!( + "FILE PATH (content omitted): {}\nFile size: {} bytes\n", + req.file_path, file_content.len() + )); + } + if let Some(q) = &req.user_question { + user_prompt.push_str(&format!("\nQUESTION: {}\n", q)); + } else { + user_prompt.push_str("\nProduce the review now.\n"); + } + + let enriched_chars = user_prompt.len(); + let preview: String = user_prompt.chars().take(800).collect(); + + // Step 6: ONE call to /v1/chat. The whole point of the mode is + // that this single call gets it right because the prompt was + // molded for THIS file. No retry ladder. + // + // Provider selection mirrors routing.toml's broad strokes — Phase 40 + // routing engine isn't auto-wired into /v1/chat yet, so the runner + // hints explicitly. Cloud-only models (kimi*, qwen3-coder*, + // deepseek*, mistral-large*, gpt-oss:120b, qwen3.5:397b) → cloud; + // smaller local-resident models → local ollama default. + let provider_hint = if model.contains('/') || model.contains(":free") { + // OpenRouter convention: vendor/model[:tag] (e.g. + // "openai/gpt-oss-120b:free", "google/gemma-3-27b-it:free"). + "openrouter" + } else if model.starts_with("kimi-") + || model.starts_with("qwen3-coder") + || model.starts_with("deepseek-v") + || model.starts_with("mistral-large") + || model == "gpt-oss:120b" + || model == "qwen3.5:397b" + { + "ollama_cloud" + } else { + "ollama" + }; + let chat_body = serde_json::json!({ + "model": model, + "provider": provider_hint, + "messages": [ + { "role": "system", "content": framing_text(flags.framing) }, + { "role": "user", "content": user_prompt }, + ], + "temperature": req.force_temperature.unwrap_or(0.1), + "max_tokens": 4096, + }); + let chat_client = match reqwest::Client::builder() + .timeout(std::time::Duration::from_secs(180)) + .build() + { + Ok(c) => c, + Err(e) => { + return Err(( + StatusCode::INTERNAL_SERVER_ERROR, + Json(serde_json::json!({"error": format!("chat client build: {e}")})), + )); + } + }; + let response_text = match chat_client + .post("http://localhost:3100/v1/chat") + .json(&chat_body) + .send() + .await + { + Ok(r) if r.status().is_success() => match r.json::().await { + Ok(j) => j + .get("choices") + .and_then(|c| c.as_array()) + .and_then(|a| a.first()) + .and_then(|c| c.get("message")) + .and_then(|m| m.get("content")) + .and_then(|s| s.as_str()) + .unwrap_or("") + .to_string(), + Err(e) => { + return Err(( + StatusCode::BAD_GATEWAY, + Json(serde_json::json!({"error": format!("/v1/chat parse: {e}")})), + )); + } + }, + Ok(r) => { + let status = r.status(); + let body = r.text().await.unwrap_or_default(); + return Err(( + status, + Json(serde_json::json!({"error": "/v1/chat upstream error", "body": body})), + )); + } + Err(e) => { + return Err(( + StatusCode::BAD_GATEWAY, + Json(serde_json::json!({"error": format!("/v1/chat send: {e}")})), + )); + } + }; + + let resp = ExecuteResponse { + mode: mode.clone(), + model: model.clone(), + task_class: req.task_class.clone(), + enriched_prompt_chars: enriched_chars, + enriched_prompt_preview: preview, + sources, + response: response_text, + latency_ms: t0.elapsed().as_millis() as u64, + }; + + // Append to mode_experiments.jsonl so the comparison aggregator + // can read the matrix later. Best-effort — write failure must not + // fail the request. Skips if LH_MODE_LOG_OFF=1. + if std::env::var("LH_MODE_LOG_OFF").as_deref() != Ok("1") { + let log_path = std::env::var("LH_MODE_LOG_PATH") + .unwrap_or_else(|_| "data/_kb/mode_experiments.jsonl".to_string()); + let row = serde_json::json!({ + "ts": chrono::Utc::now().to_rfc3339(), + "mode": resp.mode, + "model": resp.model, + "task_class": resp.task_class, + "file_path": req.file_path, + "enriched_prompt_chars": resp.enriched_prompt_chars, + "response_chars": resp.response.len(), + "latency_ms": resp.latency_ms, + "sources": resp.sources, + "response": resp.response, + }); + if let Some(parent) = std::path::Path::new(&log_path).parent() { + let _ = std::fs::create_dir_all(parent); + } + if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(&log_path) { + use std::io::Write; + let _ = writeln!(f, "{}", row); + } + } + + Ok(Json(resp)) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn cfg_for_test() -> ModeRouterConfig { + ModeRouterConfig { + task_classes: vec![ + TaskClassEntry { + name: "scrum_review".into(), + preferred_mode: "codereview".into(), + fallback_modes: vec!["consensus".into()], + default_model: "qwen3-coder:480b".into(), + matrix_corpus: vec!["distilled_procedural_v1".into()], + }, + TaskClassEntry { + name: "broken".into(), + preferred_mode: "nonsense_mode".into(), + fallback_modes: vec!["consensus".into()], + default_model: "x".into(), + matrix_corpus: vec![], + }, + ], + default: DefaultEntry { + preferred_mode: "pipeline".into(), + fallback_modes: vec![], + default_model: "qwen3.5:latest".into(), + }, + } + } + + #[test] + fn lookup_finds_matching_task_class() { + let cfg = cfg_for_test(); + assert_eq!(cfg.lookup("scrum_review").unwrap().preferred_mode, "codereview"); + assert!(cfg.lookup("unknown").is_none()); + } + + #[test] + fn valid_modes_contains_known_runners() { + assert!(VALID_MODES.contains(&"extract")); + assert!(VALID_MODES.contains(&"codereview")); + assert!(VALID_MODES.contains(&"deep_analysis")); + assert!(!VALID_MODES.contains(&"made_up")); + } + + #[test] + fn fallback_path_is_well_defined() { + let cfg = cfg_for_test(); + let tc = cfg.lookup("broken").unwrap(); + // Preferred is invalid; first valid fallback should be 'consensus'. + assert!(!VALID_MODES.contains(&tc.preferred_mode.as_str())); + assert!(VALID_MODES.contains(&tc.fallback_modes[0].as_str())); + } +} diff --git a/crates/gateway/src/v1/ollama.rs b/crates/gateway/src/v1/ollama.rs index 71ffec3..240d8da 100644 --- a/crates/gateway/src/v1/ollama.rs +++ b/crates/gateway/src/v1/ollama.rs @@ -60,10 +60,7 @@ pub async fn chat(client: &AiClient, req: &ChatRequest) -> Result (String, String) { let mut system = String::new(); let mut prompt = String::new(); for m in messages { + let body = m.text(); if m.role == "system" { if !system.is_empty() { system.push('\n'); } - system.push_str(&m.content); + system.push_str(&body); } else { prompt.push_str(&m.role); prompt.push_str(": "); - prompt.push_str(&m.content); + prompt.push_str(&body); prompt.push_str("\n\n"); } } @@ -104,7 +102,7 @@ fn flatten_messages(messages: &[Message]) -> (String, String) { } fn estimate_prompt_tokens(messages: &[Message]) -> u32 { - let chars: usize = messages.iter().map(|m| m.content.chars().count()).sum(); + let chars: usize = messages.iter().map(|m| m.text().chars().count()).sum(); ((chars + 3) / 4) as u32 } diff --git a/crates/gateway/src/v1/ollama_cloud.rs b/crates/gateway/src/v1/ollama_cloud.rs index b6d089c..8c6c05e 100644 --- a/crates/gateway/src/v1/ollama_cloud.rs +++ b/crates/gateway/src/v1/ollama_cloud.rs @@ -88,7 +88,7 @@ pub async fn chat( let text = parsed.response.unwrap_or_default(); let prompt_tokens = parsed.prompt_eval_count.unwrap_or_else(|| { - let chars: usize = req.messages.iter().map(|m| m.content.chars().count()).sum(); + let chars: usize = req.messages.iter().map(|m| m.text().chars().count()).sum(); ((chars + 3) / 4) as u32 }); let completion_tokens = parsed.eval_count.unwrap_or_else(|| { @@ -112,7 +112,7 @@ pub async fn chat( model: parsed.model.unwrap_or_else(|| req.model.clone()), choices: vec![Choice { index: 0, - message: Message { role: "assistant".into(), content: text }, + message: Message::new_text("assistant", text), finish_reason: "stop".into(), }], usage: UsageBlock { diff --git a/crates/gateway/src/v1/opencode.rs b/crates/gateway/src/v1/opencode.rs new file mode 100644 index 0000000..d45abf7 --- /dev/null +++ b/crates/gateway/src/v1/opencode.rs @@ -0,0 +1,228 @@ +//! OpenCode GO adapter — multi-vendor curated gateway via opencode.ai/zen/go. +//! +//! One sk-* key reaches Claude Opus 4.7, GPT-5.5-pro, Gemini 3.1-pro, +//! Kimi K2.6, DeepSeek, GLM, Qwen, plus 4 free-tier models. +//! OpenAI-compatible Chat Completions; auth via Bearer. +//! +//! Why a separate adapter (vs reusing openrouter.rs): +//! - Different account, different key, different base_url +//! - No HTTP-Referer / X-Title headers (those are OpenRouter-specific) +//! - Future-proof for any opencode-only request shaping +//! +//! Key sourcing priority: +//! 1. Env var `OPENCODE_API_KEY` (loaded from /etc/lakehouse/opencode.env +//! via systemd EnvironmentFile=) +//! 2. /etc/lakehouse/opencode.env directly (rescue path if env missing) +//! +//! Resolved once at gateway startup, stored on `V1State.opencode_key`. +//! Model-prefix routing: "opencode/" auto-routes here, prefix +//! stripped before upstream call. + +use std::time::Duration; +use serde::{Deserialize, Serialize}; + +use super::{ChatRequest, ChatResponse, Choice, Message, UsageBlock}; + +// /zen/v1 is the unified OpenCode endpoint that covers BOTH the +// Zen pay-per-token tier (Claude/GPT/Gemini frontier) AND the Go +// subscription tier (Kimi/GLM/DeepSeek/Qwen/Minimax/mimo). When the +// caller has both, opencode bills per-model: Zen models charge Zen +// balance, Go models charge against the Go subscription cap. +// +// /zen/go/v1 exists as a Go-only sub-path (rejects Zen models with +// "Model not supported"); we use the unified /zen/v1 since the same +// key works for both with correct billing routing upstream. +const OPENCODE_BASE_URL: &str = "https://opencode.ai/zen/v1"; +// 600s default — opencode upstream models include reasoning-heavy +// variants (Claude Opus, Kimi K2.6, GLM-5.1) that legitimately take +// 3-5 min on big audit prompts. Override via OPENCODE_TIMEOUT_SECS. +const OPENCODE_TIMEOUT_SECS_DEFAULT: u64 = 600; + +fn opencode_timeout_secs() -> u64 { + std::env::var("OPENCODE_TIMEOUT_SECS") + .ok() + .and_then(|s| s.trim().parse::().ok()) + .filter(|&n| n > 0) + .unwrap_or(OPENCODE_TIMEOUT_SECS_DEFAULT) +} + +pub fn resolve_opencode_key() -> Option { + if let Ok(k) = std::env::var("OPENCODE_API_KEY") { + if !k.trim().is_empty() { return Some(k.trim().to_string()); } + } + if let Ok(raw) = std::fs::read_to_string("/etc/lakehouse/opencode.env") { + for line in raw.lines() { + if let Some(rest) = line.strip_prefix("OPENCODE_API_KEY=") { + let k = rest.trim().trim_matches('"').trim_matches('\''); + if !k.is_empty() { return Some(k.to_string()); } + } + } + } + None +} + +pub async fn chat( + key: &str, + req: &ChatRequest, +) -> Result { + // Strip the "opencode/" namespace prefix so the upstream sees the + // bare model id (e.g. "claude-opus-4-7", "kimi-k2.6"). + let model = req.model.strip_prefix("opencode/").unwrap_or(&req.model).to_string(); + + // Anthropic models on opencode reject `temperature` with a 400 + // "temperature is deprecated for this model" error. Strip the + // field for claude-* and the new gpt-5.x reasoning lineages + // (Anthropic/OpenAI's reasoning models all moved away from temp). + // Other models keep the caller's value or default to 0.3. + let drop_temp = model.starts_with("claude-") + || model.starts_with("gpt-5") + || model.starts_with("o1") + || model.starts_with("o3") + || model.starts_with("o4"); + let body = OCChatBody { + model: model.clone(), + messages: req.messages.iter().map(|m| OCMessage { + role: m.role.clone(), + content: m.content.clone(), + }).collect(), + // filter(|&n| n > 0) catches Some(0) — same trap that bit the + // Kimi adapter when callers passed empty-env-parsed-to-0. + max_tokens: req.max_tokens.filter(|&n| n > 0).unwrap_or(800), + temperature: if drop_temp { None } else { Some(req.temperature.unwrap_or(0.3)) }, + stream: false, + }; + + let client = reqwest::Client::builder() + .timeout(Duration::from_secs(opencode_timeout_secs())) + .build() + .map_err(|e| format!("build client: {e}"))?; + + let t0 = std::time::Instant::now(); + let resp = client + .post(format!("{}/chat/completions", OPENCODE_BASE_URL)) + .bearer_auth(key) + .json(&body) + .send() + .await + .map_err(|e| format!("opencode.ai unreachable: {e}"))?; + + let status = resp.status(); + if !status.is_success() { + let body = resp.text().await.unwrap_or_else(|_| "?".into()); + return Err(format!("opencode.ai {}: {}", status, body)); + } + + let parsed: OCChatResponse = resp.json().await + .map_err(|e| format!("invalid opencode response: {e}"))?; + + let latency_ms = t0.elapsed().as_millis(); + let choice = parsed.choices.into_iter().next() + .ok_or_else(|| "opencode returned no choices".to_string())?; + let text = choice.message.content; + + let prompt_tokens = parsed.usage.as_ref().map(|u| u.prompt_tokens).unwrap_or_else(|| { + let chars: usize = req.messages.iter().map(|m| m.text().chars().count()).sum(); + ((chars + 3) / 4) as u32 + }); + let completion_tokens = parsed.usage.as_ref().map(|u| u.completion_tokens).unwrap_or_else(|| { + ((text.chars().count() + 3) / 4) as u32 + }); + + tracing::info!( + target: "v1.chat", + provider = "opencode", + model = %model, + prompt_tokens, + completion_tokens, + latency_ms = latency_ms as u64, + "opencode chat completed", + ); + + Ok(ChatResponse { + id: format!("chatcmpl-{}", chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0)), + object: "chat.completion", + created: chrono::Utc::now().timestamp(), + model, + choices: vec![Choice { + index: 0, + message: Message { role: "assistant".into(), content: serde_json::Value::String(text) }, + finish_reason: choice.finish_reason.unwrap_or_else(|| "stop".into()), + }], + usage: UsageBlock { + prompt_tokens, + completion_tokens, + total_tokens: prompt_tokens + completion_tokens, + }, + }) +} + +// -- OpenCode wire shapes (OpenAI-compatible) -- + +#[derive(Serialize)] +struct OCChatBody { + model: String, + messages: Vec, + max_tokens: u32, + #[serde(skip_serializing_if = "Option::is_none")] + temperature: Option, + stream: bool, +} + +#[derive(Serialize)] +struct OCMessage { role: String, content: serde_json::Value } + +#[derive(Deserialize)] +struct OCChatResponse { + choices: Vec, + #[serde(default)] + usage: Option, +} + +#[derive(Deserialize)] +struct OCChoice { + message: OCMessageResp, + #[serde(default)] + finish_reason: Option, +} + +#[derive(Deserialize)] +struct OCMessageResp { content: String } + +#[derive(Deserialize)] +struct OCUsage { prompt_tokens: u32, completion_tokens: u32 } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn resolve_opencode_key_does_not_panic() { + let _ = resolve_opencode_key(); + } + + #[test] + fn model_prefix_strip() { + let cases = [ + ("opencode/claude-opus-4-7", "claude-opus-4-7"), + ("opencode/kimi-k2.6", "kimi-k2.6"), + ("claude-opus-4-7", "claude-opus-4-7"), + ]; + for (input, expected) in cases { + let out = input.strip_prefix("opencode/").unwrap_or(input); + assert_eq!(out, expected); + } + } + + #[test] + fn max_tokens_filters_zero() { + // The trap: empty env -> Number("") -> 0 -> Some(0). Adapter + // must not pass 0 upstream; should fall to 800. + let some_zero: Option = Some(0); + let result = some_zero.filter(|&n| n > 0).unwrap_or(800); + assert_eq!(result, 800); + let some_real: Option = Some(4096); + assert_eq!(some_real.filter(|&n| n > 0).unwrap_or(800), 4096); + let none_val: Option = None; + assert_eq!(none_val.filter(|&n| n > 0).unwrap_or(800), 800); + } +} diff --git a/crates/gateway/src/v1/openrouter.rs b/crates/gateway/src/v1/openrouter.rs new file mode 100644 index 0000000..610c5eb --- /dev/null +++ b/crates/gateway/src/v1/openrouter.rs @@ -0,0 +1,220 @@ +//! OpenRouter adapter — free-tier rescue rung for /v1/chat. +//! +//! Direct HTTPS call to `https://openrouter.ai/api/v1/chat/completions` +//! with Bearer auth. Mirrors the OpenAI-compatible shape so the model +//! list can be expanded without code changes. Added 2026-04-24 after +//! iter 5 hit repeated Ollama Cloud 502s on kimi-k2:1t — OpenRouter +//! free-tier models give us a different provider backbone as fallback. +//! +//! Key sourcing priority: +//! 1. Env var `OPENROUTER_API_KEY` +//! 2. `/home/profit/.env` (LLM Team convention) +//! 3. `/root/llm_team_config.json` → providers.openrouter.api_key +//! +//! First hit wins. Key is resolved once at gateway startup and stored +//! on `V1State.openrouter_key`. + +use std::time::Duration; +use serde::{Deserialize, Serialize}; + +use super::{ChatRequest, ChatResponse, Choice, Message, UsageBlock}; + +const OR_BASE_URL: &str = "https://openrouter.ai/api/v1"; +const OR_TIMEOUT_SECS: u64 = 180; + +pub fn resolve_openrouter_key() -> Option { + if let Ok(k) = std::env::var("OPENROUTER_API_KEY") { + if !k.trim().is_empty() { return Some(k.trim().to_string()); } + } + // LLM Team UI writes its key to ~/.env on the host user — pick it up + // from the same source so the free-tier rescue path works without + // an explicit systemd Environment= line. + for path in ["/home/profit/.env", "/root/.env"] { + if let Ok(raw) = std::fs::read_to_string(path) { + for line in raw.lines() { + if let Some(rest) = line.strip_prefix("OPENROUTER_API_KEY=") { + let k = rest.trim().trim_matches('"').trim_matches('\''); + if !k.is_empty() { return Some(k.to_string()); } + } + } + } + } + if let Ok(raw) = std::fs::read_to_string("/root/llm_team_config.json") { + if let Ok(v) = serde_json::from_str::(&raw) { + if let Some(k) = v.pointer("/providers/openrouter/api_key").and_then(|x| x.as_str()) { + if !k.trim().is_empty() { return Some(k.trim().to_string()); } + } + } + } + None +} + +pub async fn chat( + key: &str, + req: &ChatRequest, +) -> Result { + // Strip the "openrouter/" prefix if the caller used the namespaced + // form so OpenRouter sees the raw model id (e.g. "openai/gpt-oss-120b:free"). + let model = req.model.strip_prefix("openrouter/").unwrap_or(&req.model).to_string(); + + let body = ORChatBody { + model: model.clone(), + // Pass content through verbatim — preserves OpenAI's multimodal + // content-parts shape (`[{type:"text",text:"..."}, ...]`) so the + // upstream provider sees exactly what the client sent. + messages: req.messages.iter().map(|m| ORMessage { + role: m.role.clone(), + content: m.content.clone(), + }).collect(), + max_tokens: req.max_tokens.unwrap_or(800), + temperature: req.temperature.unwrap_or(0.3), + stream: false, + }; + + let client = reqwest::Client::builder() + .timeout(Duration::from_secs(OR_TIMEOUT_SECS)) + .build() + .map_err(|e| format!("build client: {e}"))?; + + let t0 = std::time::Instant::now(); + let resp = client + .post(format!("{}/chat/completions", OR_BASE_URL)) + .bearer_auth(key) + // OpenRouter recommends Referer + Title for attribution; absent + // headers do not fail the call but help us see our traffic in + // their dashboard. + .header("HTTP-Referer", "https://vcp.devop.live") + .header("X-Title", "Lakehouse Scrum") + .json(&body) + .send() + .await + .map_err(|e| format!("openrouter.ai unreachable: {e}"))?; + + let status = resp.status(); + if !status.is_success() { + let body = resp.text().await.unwrap_or_else(|_| "?".into()); + return Err(format!("openrouter.ai {}: {}", status, body)); + } + + let parsed: ORChatResponse = resp.json().await + .map_err(|e| format!("invalid openrouter response: {e}"))?; + + let latency_ms = t0.elapsed().as_millis(); + let choice = parsed.choices.into_iter().next() + .ok_or_else(|| "openrouter returned no choices".to_string())?; + let text = choice.message.content; + + let prompt_tokens = parsed.usage.as_ref().map(|u| u.prompt_tokens).unwrap_or_else(|| { + let chars: usize = req.messages.iter().map(|m| m.text().chars().count()).sum(); + ((chars + 3) / 4) as u32 + }); + let completion_tokens = parsed.usage.as_ref().map(|u| u.completion_tokens).unwrap_or_else(|| { + ((text.chars().count() + 3) / 4) as u32 + }); + + tracing::info!( + target: "v1.chat", + provider = "openrouter", + model = %model, + prompt_tokens, + completion_tokens, + latency_ms = latency_ms as u64, + "openrouter chat completed", + ); + + Ok(ChatResponse { + id: format!("chatcmpl-{}", chrono::Utc::now().timestamp_nanos_opt().unwrap_or(0)), + object: "chat.completion", + created: chrono::Utc::now().timestamp(), + model, + choices: vec![Choice { + index: 0, + message: Message { role: "assistant".into(), content: serde_json::Value::String(text) }, + finish_reason: choice.finish_reason.unwrap_or_else(|| "stop".into()), + }], + usage: UsageBlock { + prompt_tokens, + completion_tokens, + total_tokens: prompt_tokens + completion_tokens, + }, + }) +} + +// -- OpenRouter wire shapes (OpenAI-compatible) -- + +#[derive(Serialize)] +struct ORChatBody { + model: String, + messages: Vec, + max_tokens: u32, + temperature: f64, + stream: bool, +} + +#[derive(Serialize)] +struct ORMessage { role: String, content: serde_json::Value } + +#[derive(Deserialize)] +struct ORChatResponse { + choices: Vec, + #[serde(default)] + usage: Option, +} + +#[derive(Deserialize)] +struct ORChoice { + message: ORMessageResp, + #[serde(default)] + finish_reason: Option, +} + +#[derive(Deserialize)] +struct ORMessageResp { content: String } + +#[derive(Deserialize)] +struct ORUsage { prompt_tokens: u32, completion_tokens: u32 } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn resolve_openrouter_key_does_not_panic() { + // Smoke test — all three sources may or may not be set depending + // on environment; just confirm the call returns cleanly. + let _ = resolve_openrouter_key(); + } + + #[test] + fn chat_body_serializes_to_openai_shape() { + let body = ORChatBody { + model: "openai/gpt-oss-120b:free".into(), + messages: vec![ + ORMessage { role: "user".into(), content: "review this".into() }, + ], + max_tokens: 800, + temperature: 0.3, + stream: false, + }; + let json = serde_json::to_string(&body).unwrap(); + assert!(json.contains("\"model\":\"openai/gpt-oss-120b:free\"")); + assert!(json.contains("\"messages\"")); + assert!(json.contains("\"max_tokens\":800")); + assert!(json.contains("\"stream\":false")); + } + + #[test] + fn model_prefix_strip_preserves_unprefixed() { + // If caller passes "openrouter/openai/gpt-oss-120b:free" we strip. + // If caller passes "openai/gpt-oss-120b:free" unchanged, we keep. + let cases = [ + ("openrouter/openai/gpt-oss-120b:free", "openai/gpt-oss-120b:free"), + ("openai/gpt-oss-120b:free", "openai/gpt-oss-120b:free"), + ("google/gemma-3-27b-it:free", "google/gemma-3-27b-it:free"), + ]; + for (input, expected) in cases { + let out = input.strip_prefix("openrouter/").unwrap_or(input); + assert_eq!(out, expected, "{input} should become {expected}"); + } + } +} diff --git a/crates/gateway/src/v1/respond.rs b/crates/gateway/src/v1/respond.rs new file mode 100644 index 0000000..640c0ff --- /dev/null +++ b/crates/gateway/src/v1/respond.rs @@ -0,0 +1,150 @@ +//! `/v1/respond` — the **execution** API (distinct from `/v1/chat`, the +//! completion API). +//! +//! This is the consolidation move called out in the 2026-04-23 session: +//! lift the proven pipeline from `tests/multi-agent/orchestrator.ts` +//! (executor → reviewer → escalate → validate → seal playbook → +//! write-through to KB) into the gateway, so the production path has +//! the intelligence the tests already proved. +//! +//! `/v1/chat` stays a naive completion proxy for callers that want one. +//! `/v1/respond` is where the loop lives. Every orchestrator-style +//! caller migrates here and the TS harnesses become thin clients. +//! +//! This file holds the HTTP surface + request/response shapes. The loop +//! itself lives in `execution_loop::ExecutionLoop`. + +use axum::{extract::State, http::StatusCode, Json}; +use serde::{Deserialize, Serialize}; + +use super::V1State; +use crate::execution_loop::{ExecutionLoop, LogEntry, RespondOutcome}; + +/// A structured task — mirrors `TaskSpec` in `tests/multi-agent/agent.ts`. +/// Kept deliberately open so non-staffing task classes (code-gen, +/// DevOps-long-horizon) can land without a schema fight. +#[derive(Deserialize, Debug, Clone)] +pub struct RespondRequest { + /// Task class — routes to the right truth rules + validator. For the + /// staffing substrate: `staffing.fill`, `staffing.rescue`, + /// `staffing.sms_draft`. Truth-layer lookup is a no-op until a rule + /// set is registered for the class. + pub task_class: String, + + /// Human-readable operation description — becomes the playbook + /// `operation` field on seal, and the primary signal for + /// playbook_memory embedding. + pub operation: String, + + /// Free-form structured context. Passed to the executor prompt and + /// to the playbook seeder. Staffing tasks expect + /// `{target_role, target_count, target_city, target_state, approach_hint}` + /// but nothing here validates that — the validator crate will (Phase 43). + #[serde(default)] + pub spec: serde_json::Value, + + /// Executor model. Defaults to the hot-path local model if omitted. + /// See orchestrator.ts:28 (`EXECUTOR_MODEL = "qwen3.5:latest"`). + #[serde(default)] + pub executor_model: Option, + + /// Reviewer model. Defaults to the hot-path local reviewer. + /// See orchestrator.ts:29 (`REVIEWER_MODEL = "qwen3:latest"`). + #[serde(default)] + pub reviewer_model: Option, + + /// Hard cap on executor turns. Default matches orchestrator.ts:30 + /// (`MAX_TURNS = 12`). Cloud escalation counts as a turn. + #[serde(default)] + pub max_turns: Option, +} + +#[derive(Serialize)] +pub struct RespondResponse { + /// `ok` = consensus reached, playbook sealed. `failed` = loop ran + /// out of turns or hit the drift cap. `blocked` = truth-layer + /// veto (Phase 42 rule citation in `error`). + pub status: &'static str, + + /// The final artifact — for staffing fills, `{fills: [{candidate_id, name}]}`. + /// Empty on failure / block. + pub artifact: serde_json::Value, + + /// Structured cross-turn log. Same shape as orchestrator.ts LogEntry + /// so existing tooling (kb extractors, fact_extractor.ts) reads it + /// without change. + pub log: Vec, + + /// Iteration count actually used. ≤ max_turns. Stamped on + /// outcomes.jsonl per the indicator audit (2026-04-23). + pub iterations: u32, + + /// Error message on non-ok status. Truth-rule citations land here + /// when `status == "blocked"`. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +pub async fn respond( + State(state): State, + Json(req): Json, +) -> Result, (StatusCode, String)> { + if req.operation.is_empty() { + return Err((StatusCode::BAD_REQUEST, "operation must be non-empty".into())); + } + if req.task_class.is_empty() { + return Err((StatusCode::BAD_REQUEST, "task_class must be non-empty".into())); + } + + let mut loop_runner = ExecutionLoop::new(state, req); + let outcome = loop_runner.run().await.map_err(|e| { + (StatusCode::INTERNAL_SERVER_ERROR, format!("execution loop: {e}")) + })?; + + let (status, error) = match &outcome { + RespondOutcome::Ok { .. } => ("ok", None), + RespondOutcome::Failed { reason, .. } => ("failed", Some(reason.clone())), + RespondOutcome::Blocked { reason, .. } => ("blocked", Some(reason.clone())), + }; + + Ok(Json(RespondResponse { + status, + artifact: outcome.artifact(), + log: outcome.into_log(), + iterations: loop_runner.turns_used(), + error, + })) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn respond_request_parses_minimal() { + let raw = r#"{ + "task_class": "staffing.fill", + "operation": "fill: Welder x2 in Toledo, OH" + }"#; + let r: RespondRequest = serde_json::from_str(raw).unwrap(); + assert_eq!(r.task_class, "staffing.fill"); + assert_eq!(r.executor_model, None); + assert_eq!(r.max_turns, None); + } + + #[test] + fn respond_request_parses_full() { + let raw = r#"{ + "task_class": "staffing.fill", + "operation": "fill: Welder x2 in Toledo, OH", + "spec": {"target_role": "Welder", "target_count": 2, "target_city": "Toledo", "target_state": "OH"}, + "executor_model": "qwen3.5:latest", + "reviewer_model": "qwen3:latest", + "max_turns": 12 + }"#; + let r: RespondRequest = serde_json::from_str(raw).unwrap(); + assert_eq!(r.executor_model.as_deref(), Some("qwen3.5:latest")); + assert_eq!(r.max_turns, Some(12)); + assert_eq!(r.spec["target_count"], 2); + } +} diff --git a/crates/gateway/src/v1/truth.rs b/crates/gateway/src/v1/truth.rs new file mode 100644 index 0000000..6e900e6 --- /dev/null +++ b/crates/gateway/src/v1/truth.rs @@ -0,0 +1,47 @@ +use serde::Serialize; +use truth::default_truth_store; + +// Note: truth_router() was a stub wrapper around a single /context route +// that nothing called — v1/mod.rs wires get(truth::context) directly +// onto its own router. Removed 2026-04-24 along with its #[allow(dead_code)] +// attribute; the handler below is the real surface. + +#[derive(Serialize)] +pub struct ContextResponse { + pub task_classes: Vec, + pub rules: Vec, +} + +#[derive(Serialize)] +pub struct RuleInfo { + pub id: String, + pub task_class: String, + pub description: String, +} + +pub async fn context() -> axum::Json { + let store = default_truth_store(); + + let task_classes: Vec = vec![ + "staffing.fill".to_string(), + "staffing.rescue".to_string(), + "staffing.sms_draft".to_string(), + "staffing.any".to_string(), + ]; + + let mut rules = Vec::new(); + for tc in &task_classes { + for rule in store.get_rules(tc) { + rules.push(RuleInfo { + id: rule.id.clone(), + task_class: rule.task_class.clone(), + description: rule.description.clone(), + }); + } + } + + axum::Json(ContextResponse { + task_classes, + rules, + }) +} \ No newline at end of file diff --git a/crates/gateway/src/v1/validate.rs b/crates/gateway/src/v1/validate.rs new file mode 100644 index 0000000..e326704 --- /dev/null +++ b/crates/gateway/src/v1/validate.rs @@ -0,0 +1,82 @@ +//! /v1/validate — gateway-side artifact validation endpoint. +//! +//! Phase 43 v3 part 2: makes the validator crate network-callable. +//! Any caller (scrum loop, test harness, future agent) can POST a +//! generated artifact and get back a Report (success) or +//! ValidationError (failure with structured field/reason). +//! +//! Request shape: +//! POST /v1/validate +//! { +//! "kind": "fill" | "email" | "playbook", +//! "artifact": { ... }, +//! "context": { ... } // optional — folded into artifact._context +//! } +//! +//! Response on success: 200 + Report JSON +//! Response on failure: 422 + ValidationError JSON +//! Response on bad request: 400 + plain-text error +//! +//! The shared WorkerLookup is loaded once at gateway startup from +//! workers_500k.parquet (path configurable via LH_WORKERS_PARQUET +//! env, defaults to data/datasets/workers_500k.parquet). Falls back +//! to an empty InMemoryWorkerLookup if the file is missing — the +//! validators will still run schema/length/PII checks but worker- +//! existence checks will all fail (Consistency error), which is the +//! correct behavior when the roster isn't configured. + +use axum::{extract::State, http::StatusCode, response::IntoResponse, Json}; +use serde::Deserialize; +use validator::{ + Artifact, Validator, ValidationError, + staffing::{ + fill::FillValidator, + email::EmailValidator, + playbook::PlaybookValidator, + }, +}; + +#[derive(Deserialize)] +pub struct ValidateRequest { + /// `"fill" | "email" | "playbook"` — picks which validator runs. + pub kind: String, + /// The artifact JSON (free-form; shape depends on `kind`). + pub artifact: serde_json::Value, + /// Optional context bag — merged into `artifact._context` so the + /// validator can read fields like `target_count`, `city`, + /// `client_id`, `candidate_id` without callers having to embed + /// `_context` in the artifact themselves. + #[serde(default)] + pub context: Option, +} + +pub async fn validate( + State(state): State, + Json(req): Json, +) -> impl IntoResponse { + // Merge context into artifact under `_context` so validators can + // pull contract metadata uniformly. + let mut artifact_value = req.artifact; + if let Some(ctx) = req.context { + if let Some(obj) = artifact_value.as_object_mut() { + obj.insert("_context".to_string(), ctx); + } + } + + // Dispatch. + let workers = state.validate_workers.clone(); + let result: Result = match req.kind.as_str() { + "fill" => FillValidator::new(workers).validate(&Artifact::FillProposal(artifact_value)), + "email" => EmailValidator::new(workers).validate(&Artifact::EmailDraft(artifact_value)), + "playbook" => PlaybookValidator.validate(&Artifact::Playbook(artifact_value)), + other => return ( + StatusCode::BAD_REQUEST, + format!("unknown kind '{other}' — expected fill | email | playbook"), + ).into_response(), + }; + + match result { + Ok(report) => (StatusCode::OK, Json(report)).into_response(), + Err(e) => (StatusCode::UNPROCESSABLE_ENTITY, Json(e)).into_response(), + } +} diff --git a/crates/ingestd/Cargo.toml b/crates/ingestd/Cargo.toml index bb41bf6..61a78dc 100644 --- a/crates/ingestd/Cargo.toml +++ b/crates/ingestd/Cargo.toml @@ -8,6 +8,7 @@ shared = { path = "../shared" } storaged = { path = "../storaged" } catalogd = { path = "../catalogd" } vectord = { path = "../vectord" } +journald = { path = "../journald" } tokio = { workspace = true } axum = { workspace = true, features = ["multipart"] } lopdf = { workspace = true } diff --git a/crates/ingestd/src/schema_evolution.rs b/crates/ingestd/src/schema_evolution.rs index c2ef057..1f7f8e9 100644 --- a/crates/ingestd/src/schema_evolution.rs +++ b/crates/ingestd/src/schema_evolution.rs @@ -2,10 +2,9 @@ /// When a source changes format (columns renamed, added, removed, type changed), /// the system detects the diff and can auto-map using AI or heuristic matching. -use arrow::datatypes::{DataType, Schema, SchemaRef}; +use arrow::datatypes::{DataType, SchemaRef}; use serde::{Deserialize, Serialize}; use std::collections::HashMap; -use std::sync::Arc; /// A detected change between two schema versions. #[derive(Debug, Clone, Serialize, Deserialize)] @@ -223,7 +222,8 @@ fn find_similar_column<'a>( #[cfg(test)] mod tests { use super::*; - use arrow::datatypes::Field; + use arrow::datatypes::{Field, Schema}; + use std::sync::Arc; fn schema(fields: Vec<(&str, DataType)>) -> SchemaRef { Arc::new(Schema::new( diff --git a/crates/ingestd/src/service.rs b/crates/ingestd/src/service.rs index b7e74c6..bc7f7ed 100644 --- a/crates/ingestd/src/service.rs +++ b/crates/ingestd/src/service.rs @@ -3,7 +3,7 @@ use axum::{ extract::{Multipart, Path, Query, State}, http::{HeaderMap, StatusCode}, response::IntoResponse, - routing::{delete, get, patch, post}, + routing::{get, post}, }; use bytes::Bytes; use object_store::ObjectStore; @@ -33,6 +33,11 @@ pub struct IngestState { /// Scheduled-ingest registry. The scheduler task runs against this /// store; HTTP CRUD endpoints write through it. pub schedules: schedule::ScheduleStore, + /// Event journal for ADR-012 mutation history. Optional for back-compat + /// with callers (like scheduled ingest tests) that don't wire it yet. + /// When present, successful ingests emit a record_ingest event — closes + /// P9-001 on the file-upload path. (2026-04-23) + pub journal: Option, } /// Push `DatasetAppended` triggers for every HNSW index bound to this @@ -136,6 +141,22 @@ async fn ingest_file( Ok(result) => { if !result.deduplicated { notify_agent_on_append(&state, &result.dataset_name).await; + // P9-001 fix (2026-04-23): emit a mutation event on every + // non-deduplicated ingest. Dedup no-ops don't need events + // (ADR-020 register() is already idempotent on same fingerprint). + if let Some(ref journal) = state.journal { + if let Err(e) = journal.record_ingest( + &result.dataset_name, + result.rows as usize, + "ingest_api", + &filename, + ).await { + tracing::warn!( + "journal record_ingest failed for '{}': {}", + result.dataset_name, e, + ); + } + } } if result.deduplicated { Ok((StatusCode::OK, Json(result))) @@ -630,3 +651,108 @@ async fn run_schedule_now( } Ok(Json(outcome)) } + +// ─── Tests ─── + +#[cfg(test)] +mod journal_integration_tests { + //! P9-001 integration test: prove that a successful ingest produces a + //! journal.record_ingest event. Block 2 on PR #10 was "journal event + //! verified live" being unbacked by the diff. This test makes the + //! verification committed and reproducible. + + use journald::journal::{Event, Journal}; + use object_store::memory::InMemory; + use std::sync::Arc; + + // Helper: build a bare Journal against an in-memory object store. + // Flush threshold 1 so every recorded event is persisted immediately. + fn test_journal() -> Journal { + let store: Arc = Arc::new(InMemory::new()); + Journal::new(store, 1) + } + + #[tokio::test] + async fn journal_record_ingest_increments_counter() { + // Arrange — fresh journal, counter starts at zero. + let journal = test_journal(); + let stats0 = journal.stats().await; + assert_eq!(stats0.total_events_created, 0); + assert_eq!(stats0.buffer_events, 0); + + // Act — simulate what the /ingest/file success path does. + journal + .record_ingest("test_dataset", 42, "ingest_api", "probe.csv") + .await + .expect("record_ingest should succeed"); + + // Assert — counter advanced, event exists. With threshold=1 the + // event flushed to store; with threshold>N it would be in-buffer. + let stats1 = journal.stats().await; + assert_eq!(stats1.total_events_created, 1, "counter should reflect one recorded event"); + + // Assert — the event is retrievable by entity. + let history = journal + .get_entity_history("batch:42") + .await + .expect("history lookup"); + assert_eq!(history.len(), 1, "one event should be visible in history"); + let ev = &history[0]; + assert_eq!(ev.action, "ingest"); + assert_eq!(ev.entity_type, "test_dataset"); + assert_eq!(ev.actor, "ingest_api"); + assert!( + ev.new_value.contains("probe.csv"), + "new_value should carry source filename, got: {}", + ev.new_value + ); + } + + #[tokio::test] + async fn optional_journal_field_none_is_valid_back_compat() { + // IngestState.journal is Option. Back-compat path: when + // the field is None, the ingest handler MUST still succeed — the + // journal call is fire-and-forget, never load-bearing. + // + // This test asserts the type shape: Option is what we + // expect. If a refactor makes it mandatory, this test forces an + // explicit re-consideration. + let none_journal: Option = None; + assert!(none_journal.is_none()); + + let some_journal: Option = Some(test_journal()); + assert!(some_journal.is_some()); + } + + #[tokio::test] + async fn journal_record_event_fields_match_adr_012_schema() { + // ADR-012 locks the event schema: entity_type, entity_id, field, + // action, old_value, new_value, actor, source, workspace_id plus + // the auto-assigned event_id + timestamp. This test pins the + // field names so a future refactor can't silently drop one. + let journal = test_journal(); + let base = Event { + event_id: String::new(), + timestamp: chrono::Utc::now(), + entity_type: "candidate".into(), + entity_id: "CAND-0001".into(), + field: "phone".into(), + action: "update".into(), + old_value: "555-0000".into(), + new_value: "555-9999".into(), + actor: "recruiter".into(), + source: "api".into(), + workspace_id: "ws-x".into(), + }; + journal.record(base).await.expect("record should accept full-schema event"); + let h = journal + .get_entity_history("CAND-0001") + .await + .expect("lookup"); + assert_eq!(h.len(), 1); + assert_eq!(h[0].field, "phone"); + assert_eq!(h[0].old_value, "555-0000"); + assert_eq!(h[0].new_value, "555-9999"); + assert_eq!(h[0].workspace_id, "ws-x"); + } +} diff --git a/crates/ingestd/src/watcher.rs b/crates/ingestd/src/watcher.rs index cf342e1..60da955 100644 --- a/crates/ingestd/src/watcher.rs +++ b/crates/ingestd/src/watcher.rs @@ -72,12 +72,14 @@ async fn process_inbox( let path = entry.path(); - // Skip directories and hidden files - if path.is_dir() || path.file_name().map_or(true, |n| n.to_string_lossy().starts_with('.')) { - continue; - } - - let filename = path.file_name().unwrap().to_string_lossy().to_string(); + // Skip directories and hidden files. Bind filename once via + // let-else so the subsequent use is unwrap-free — previous + // version relied on a map_or guard above + an .unwrap() here + // being consistent, which is a fragile invariant. + if path.is_dir() { continue; } + let Some(fn_os) = path.file_name() else { continue; }; + let filename = fn_os.to_string_lossy().to_string(); + if filename.starts_with('.') { continue; } tracing::info!("watcher: found new file '{}'", filename); // Read file diff --git a/crates/journald/src/journal.rs b/crates/journald/src/journal.rs index 12e70a9..9019238 100644 --- a/crates/journald/src/journal.rs +++ b/crates/journald/src/journal.rs @@ -5,7 +5,7 @@ /// Storage: events buffer in memory, flush to Parquet periodically. /// Query: load Parquet files, filter by entity/field/actor/time. -use arrow::array::{ArrayRef, RecordBatch, StringArray, UInt64Array}; +use arrow::array::{ArrayRef, RecordBatch, StringArray}; use arrow::datatypes::{DataType, Field, Schema}; use chrono::{DateTime, Utc}; use object_store::ObjectStore; diff --git a/crates/queryd/Cargo.toml b/crates/queryd/Cargo.toml index 4064f63..be1618f 100644 --- a/crates/queryd/Cargo.toml +++ b/crates/queryd/Cargo.toml @@ -7,6 +7,7 @@ edition = "2024" shared = { path = "../shared" } catalogd = { path = "../catalogd" } storaged = { path = "../storaged" } +truth = { path = "../truth" } tokio = { workspace = true } axum = { workspace = true } serde = { workspace = true } diff --git a/crates/queryd/src/delta.rs b/crates/queryd/src/delta.rs index 30dcc4a..af5ccc8 100644 --- a/crates/queryd/src/delta.rs +++ b/crates/queryd/src/delta.rs @@ -84,14 +84,17 @@ pub async fn compact( // Load deltas let delta_batches = load_deltas(store, dataset_name).await?; let delta_count = delta_batches.len(); + // Row counts captured before extend; previously base_rows subtracted delta_count (files) from rows — unit mismatch. + let base_row_count: usize = base_batches.iter().map(|b| b.num_rows()).sum(); + let delta_row_count: usize = delta_batches.iter().map(|b| b.num_rows()).sum(); let has_tombstones = !tombstones.is_empty(); let nothing_to_do = delta_batches.is_empty() && !has_tombstones; if nothing_to_do { return Ok(CompactResult { - base_rows: base_batches.iter().map(|b| b.num_rows()).sum(), + base_rows: base_row_count, delta_rows: 0, - final_rows: base_batches.iter().map(|b| b.num_rows()).sum(), + final_rows: base_row_count, deltas_merged: 0, tombstones_applied: 0, rows_dropped_by_tombstones: 0, @@ -99,7 +102,7 @@ pub async fn compact( } base_batches.extend(delta_batches); - let pre_filter_rows: usize = base_batches.iter().map(|b| b.num_rows()).sum(); + let pre_filter_rows: usize = base_row_count + delta_row_count; // If primary key specified, deduplicate (keep last occurrence) let merged_batches = if let Some(_pk) = primary_key_col { @@ -183,8 +186,8 @@ pub async fn compact( ); Ok(CompactResult { - base_rows: pre_filter_rows - delta_count, // rough base-before-deltas - delta_rows: delta_count, + base_rows: base_row_count, + delta_rows: delta_row_count, final_rows, deltas_merged: delta_count, tombstones_applied: tombstones.len(), diff --git a/crates/queryd/src/service.rs b/crates/queryd/src/service.rs index 5f1a8bf..5dec8fc 100644 --- a/crates/queryd/src/service.rs +++ b/crates/queryd/src/service.rs @@ -9,7 +9,9 @@ use axum::{ }; use serde::{Deserialize, Serialize}; -use crate::cache::CacheStats; +use std::sync::Arc; +use truth::{RuleAction, TruthStore}; + use crate::context::QueryEngine; use crate::delta; use crate::paged::ResultStore; @@ -18,12 +20,26 @@ use crate::paged::ResultStore; pub struct QueryState { pub engine: QueryEngine, pub result_store: ResultStore, + // Policy gate for incoming SQL. Every /sql and /paged request is + // evaluated against this store before hitting DataFusion. Added for + // P42-002 ("raw SQL forwarded without schema or policy gate") after + // the scrum master's queryd/service.rs finding looped across iters + // 3-5 without ever being reachable by the 6-line auto-applier. + pub truth: Arc, } pub fn router(engine: QueryEngine) -> Router { + router_with_truth(engine, Arc::new(truth::sql_query_guard_store())) +} + +/// Test/integration hook: construct the router with a caller-supplied +/// TruthStore so tests can assert reject/pass behavior deterministically +/// without depending on the default needle list. +pub fn router_with_truth(engine: QueryEngine, truth: Arc) -> Router { let state = QueryState { engine: engine.clone(), result_store: ResultStore::new(100, 50), // 100 rows/page, keep 50 results + truth, }; Router::new() .route("/health", get(health)) @@ -53,6 +69,11 @@ struct QueryResponse { columns: Vec, rows: serde_json::Value, row_count: usize, + // Elapsed wall time from handler entry to response. Required for + // audit-log parity — gateway's audit row previously stored null here. + // Scrum iter 9 finding, populated from std::time::Instant captured + // at the top of execute_query / paged_query. + latency_ms: u64, } #[derive(Serialize)] @@ -72,12 +93,41 @@ fn batches_to_json(batches: &[RecordBatch]) -> Result serde_json::from_slice(&buf).map_err(|e| format!("JSON parse error: {e}")) } +/// Evaluate the request SQL against the configured TruthStore. Returns +/// the Reject/Block message on the first failing mandatory rule so the +/// handler can short-circuit. Returns None when all rules pass (or when +/// the failures' declared action is non-mandatory like Redact/Pass). +fn sql_policy_check(truth: &TruthStore, sql: &str) -> Option { + let ctx = serde_json::json!({ "sql": sql }); + for outcome in truth.evaluate("sql_query", &ctx) { + if !outcome.passed { + // FieldEmpty / FieldContainsAny etc. are enforced only when + // condition HOLDS (i.e. passed=true). Below means "passed=false", + // so the rule condition did not hold — no enforcement. + continue; + } + match &outcome.action { + RuleAction::Reject { message } | RuleAction::Block { message } => { + return Some(message.clone()); + } + _ => {} + } + } + None +} + async fn execute_query( State(state): State, Json(req): Json, ) -> impl IntoResponse { + let started = std::time::Instant::now(); tracing::info!("executing query: {}", req.sql); + if let Some(reason) = sql_policy_check(&state.truth, &req.sql) { + tracing::warn!("sql rejected by truth gate: {reason}"); + return Err((StatusCode::FORBIDDEN, reason)); + } + match state.engine.query(&req.sql).await { Ok(batches) => { if batches.is_empty() { @@ -85,6 +135,7 @@ async fn execute_query( columns: vec![], rows: serde_json::Value::Array(vec![]), row_count: 0, + latency_ms: started.elapsed().as_millis() as u64, })); } @@ -103,6 +154,7 @@ async fn execute_query( columns, rows, row_count, + latency_ms: started.elapsed().as_millis() as u64, })) } Err(e) => Err((StatusCode::BAD_REQUEST, e)), @@ -116,6 +168,10 @@ async fn paged_query( Json(req): Json, ) -> impl IntoResponse { tracing::info!("paged query: {}", req.sql); + if let Some(reason) = sql_policy_check(&state.truth, &req.sql) { + tracing::warn!("paged sql rejected by truth gate: {reason}"); + return Err((StatusCode::FORBIDDEN, reason)); + } match state.result_store.execute_and_store(&state.engine, &req.sql).await { Ok(handle) => Ok(Json(handle)), Err(e) => Err((StatusCode::BAD_REQUEST, e)), @@ -212,3 +268,65 @@ async fn compact_dataset( Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e)), } } + +#[cfg(test)] +mod sql_policy_tests { + use super::*; + use truth::sql_query_guard_store; + + // These tests exercise the policy gate without spinning up a DataFusion + // engine — they only need `TruthStore`. Purpose: prove the P42-002 + // enforcement point actually rejects destructive SQL. This is the + // regression guard for the queryd/service.rs finding that looped + // across scrum iters 3-5. + + #[test] + fn blocks_drop_table() { + let store = sql_query_guard_store(); + let reason = sql_policy_check(&store, "DROP TABLE users").expect("must reject"); + assert!(reason.contains("destructive"), "reason: {reason}"); + } + + #[test] + fn blocks_delete_from() { + let store = sql_query_guard_store(); + assert!(sql_policy_check(&store, "delete from t where 1=1").is_some()); + } + + #[test] + fn blocks_truncate() { + let store = sql_query_guard_store(); + assert!(sql_policy_check(&store, "TRUNCATE workers").is_some()); + } + + #[test] + fn blocks_empty_sql() { + let store = sql_query_guard_store(); + assert!(sql_policy_check(&store, "").is_some()); + } + + #[test] + fn allows_benign_select() { + let store = sql_query_guard_store(); + assert!(sql_policy_check(&store, "SELECT count(*) FROM workers").is_none()); + } + + #[test] + fn allows_select_with_deleted_word_in_column() { + // Substring match is narrow ("delete from", not "delete"), so a + // column named `deleted_at` doesn't trip the guard. Important + // check — false positives on benign queries would make the gate + // unusable in practice. + let store = sql_query_guard_store(); + assert!( + sql_policy_check(&store, "SELECT deleted_at FROM t").is_none(), + "column names containing 'delete' must not be rejected" + ); + } + + #[test] + fn case_insensitive_match_catches_mixed_case() { + let store = sql_query_guard_store(); + assert!(sql_policy_check(&store, "Drop Table X").is_some()); + } +} diff --git a/crates/queryd/src/workspace.rs b/crates/queryd/src/workspace.rs index f127af0..20ed1a6 100644 --- a/crates/queryd/src/workspace.rs +++ b/crates/queryd/src/workspace.rs @@ -2,15 +2,12 @@ /// Each workspace tracks an agent's activity on a specific contract or search, /// with daily/weekly/monthly tiers and instant handoff capability. -use arrow::array::{ArrayRef, RecordBatch, StringArray, Int64Array}; -use arrow::datatypes::{DataType, Field, Schema}; use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::sync::Arc; use tokio::sync::RwLock; -use crate::delta; use object_store::ObjectStore; /// Retention tier for workspace data. diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs index c7e072d..df52168 100644 --- a/crates/shared/src/lib.rs +++ b/crates/shared/src/lib.rs @@ -4,3 +4,5 @@ pub mod arrow_helpers; pub mod config; pub mod pii; pub mod secrets; +pub mod model_matrix; +pub mod profiles; diff --git a/crates/shared/src/model_matrix.rs b/crates/shared/src/model_matrix.rs new file mode 100644 index 0000000..c09af4c --- /dev/null +++ b/crates/shared/src/model_matrix.rs @@ -0,0 +1,69 @@ +//! Per-model token accounting. Entry point for the ModelMatrix work +//! the aibridge `context::estimate_tokens` deprecation has been pointing +//! at. Starts minimal — just `estimate_tokens` — so call sites can +//! migrate off the deprecated helper. Extend with per-model context +//! windows, max_tokens defaults, provider hints, etc. as we move the +//! rest of `aibridge::context::known_windows` over. + +/// Namespace for per-model token + context accounting. Methods are +/// associated functions — no instance required — because the underlying +/// estimates are deterministic and stateless. +pub struct ModelMatrix; + +impl ModelMatrix { + /// Rough token count — char count divided by 4, rounded up. This + /// is the same heuristic OpenAI's cookbook uses for English text; + /// it's within ±15% of BPE tokenizers for code + prose and doesn't + /// require a tokenizer lookup. Good enough for budget math where + /// the goal is "don't blow the context window" rather than exact + /// billing. + /// + /// Moved from `aibridge::context::estimate_tokens` (still there with + /// a `#[deprecated]` pointer — callers should migrate here). Empty + /// string → 0; one char → 1 (ceiling of 1/4 = 1). + pub fn estimate_tokens(text: &str) -> usize { + (text.chars().count() + 3) / 4 + } +} + +#[cfg(test)] +mod tests { + use super::ModelMatrix; + + #[test] + fn empty_string_is_zero_tokens() { + assert_eq!(ModelMatrix::estimate_tokens(""), 0); + } + + #[test] + fn three_chars_is_one_token() { + // 3 → ceil(3/4) = 1. Matches the deprecated helper's behavior + // so the migration is a drop-in replacement. + assert_eq!(ModelMatrix::estimate_tokens("abc"), 1); + } + + #[test] + fn four_chars_is_one_token() { + assert_eq!(ModelMatrix::estimate_tokens("abcd"), 1); + } + + #[test] + fn five_chars_is_two_tokens() { + assert_eq!(ModelMatrix::estimate_tokens("abcde"), 2); + } + + #[test] + fn counts_chars_not_bytes() { + // Multi-byte UTF-8 chars count as 1 char each — important for + // prompts with emoji or non-ASCII text. "héllo" is 5 chars + // (5 unicode scalars) → ceil(5/4) = 2 tokens, same as "hello". + assert_eq!(ModelMatrix::estimate_tokens("héllo"), 2); + assert_eq!(ModelMatrix::estimate_tokens("📚📚📚📚"), 1); // 4 chars + } + + #[test] + fn large_text_scales_linearly() { + assert_eq!(ModelMatrix::estimate_tokens(&"x".repeat(400)), 100); + assert_eq!(ModelMatrix::estimate_tokens(&"x".repeat(401)), 101); + } +} diff --git a/crates/shared/src/profiles/execution.rs b/crates/shared/src/profiles/execution.rs new file mode 100644 index 0000000..d810404 --- /dev/null +++ b/crates/shared/src/profiles/execution.rs @@ -0,0 +1,14 @@ +//! ExecutionProfile — the Phase 41 rename of Phase 17's ModelProfile. +//! +//! Carries what's needed to RUN inference: model tag, dataset bindings, +//! HNSW config, embed model, bucket binding. Today this is a type +//! alias over `crate::types::ModelProfile` — the PRD's +//! "Backward compat: ModelProfile still loads, aliased to +//! ExecutionProfile" line, honored literally. +//! +//! When the migration off the old name finishes, this file can either +//! absorb the full struct definition or continue as an alias. Callers +//! should reference `ExecutionProfile` going forward; `ModelProfile` +//! stays exported from `types` for on-disk schema compat. + +pub use crate::types::ModelProfile as ExecutionProfile; diff --git a/crates/shared/src/profiles/memory.rs b/crates/shared/src/profiles/memory.rs new file mode 100644 index 0000000..2166cfc --- /dev/null +++ b/crates/shared/src/profiles/memory.rs @@ -0,0 +1,38 @@ +//! MemoryProfile — how the agent's execution memory is kept. +//! +//! Phase 41 decomposition: the Phase 19 playbook_memory + Phase 26 +//! successful_playbooks + Phase 45 doc_refs all need per-profile +//! tuning. Rather than bolt those onto ExecutionProfile, they live +//! here so a "thin" execution profile can reuse a "fat" memory +//! profile and vice versa. + +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct MemoryProfile { + pub id: String, + #[serde(default)] + pub description: String, + /// Phase 19: ceiling for playbook_memory boost on retrieval. 0 + /// disables the boost entirely. + #[serde(default = "default_boost_ceiling")] + pub playbook_boost_ceiling: f32, + /// Phase 26: max history entries retained before rotation. + #[serde(default = "default_history_cap")] + pub history_cap: usize, + /// Phase 45: stale threshold for doc_refs before drift check + /// fires (hours). + #[serde(default = "default_stale_hours")] + pub doc_stale_hours: u32, + /// Phase 28: auto-retire playbooks that fail 3+ consecutive runs. + #[serde(default = "default_true")] + pub auto_retire_on_failure: bool, + pub created_at: chrono::DateTime, + #[serde(default)] + pub created_by: String, +} + +fn default_boost_ceiling() -> f32 { 0.35 } +fn default_history_cap() -> usize { 1000 } +fn default_stale_hours() -> u32 { 168 } // one week +fn default_true() -> bool { true } diff --git a/crates/shared/src/profiles/mod.rs b/crates/shared/src/profiles/mod.rs new file mode 100644 index 0000000..97064a0 --- /dev/null +++ b/crates/shared/src/profiles/mod.rs @@ -0,0 +1,28 @@ +//! Phase 41 profile types. +//! +//! The existing `ModelProfile` (Phase 17) is aliased as +//! `ExecutionProfile` here — it continues to carry the model + +//! bindings + HNSW config needed to run inference. Three new profile +//! types land alongside: `RetrievalProfile`, `MemoryProfile`, +//! `ObserverProfile` — each owns a distinct slice of what used to be +//! bundled. +//! +//! Backward-compat rule (PRD Phase 41): existing `ModelProfile` on +//! disk continues to deserialize unchanged. New fields on the new +//! profile types are `#[serde(default)]` so old payloads load with +//! empty defaults. +//! +//! These are the canonical shapes — downstream code converts via +//! `From for ExecutionProfile` (they're the same struct +//! today, just named differently) and constructs the other three +//! as needed. + +pub mod execution; +pub mod retrieval; +pub mod memory; +pub mod observer; + +pub use execution::ExecutionProfile; +pub use memory::MemoryProfile; +pub use observer::ObserverProfile; +pub use retrieval::RetrievalProfile; diff --git a/crates/shared/src/profiles/observer.rs b/crates/shared/src/profiles/observer.rs new file mode 100644 index 0000000..7f05224 --- /dev/null +++ b/crates/shared/src/profiles/observer.rs @@ -0,0 +1,38 @@ +//! ObserverProfile — how loudly the observer logs this workload. +//! +//! Phase 41 decomposition: the observer's alert thresholds, escalation +//! cadence, and log retention need per-workload tuning. Hot-path +//! staffing workflows want aggressive alerting; batch backfills want +//! quieter. This profile is read by mcp-server/observer.ts at +//! activation-time. + +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct ObserverProfile { + pub id: String, + #[serde(default)] + pub description: String, + /// How many consecutive failures trigger a cluster escalation to + /// LLM Team `/v1/chat` (qwen3-coder:480b). + #[serde(default = "default_failure_cluster_size")] + pub failure_cluster_size: u32, + /// Minimum seconds between alert emails for the same sig_hash. + /// Prevents alert storms during a regression. + #[serde(default = "default_alert_cooldown")] + pub alert_cooldown_secs: u32, + /// Observer ring buffer size. Older events fall off when full. + #[serde(default = "default_ring_size")] + pub ring_size: usize, + /// Whether to forward events to external Langfuse + /// (/v1/langfuse_trace). Off by default. + #[serde(default)] + pub forward_to_langfuse: bool, + pub created_at: chrono::DateTime, + #[serde(default)] + pub created_by: String, +} + +fn default_failure_cluster_size() -> u32 { 3 } +fn default_alert_cooldown() -> u32 { 300 } // 5 minutes +fn default_ring_size() -> usize { 2000 } diff --git a/crates/shared/src/profiles/retrieval.rs b/crates/shared/src/profiles/retrieval.rs new file mode 100644 index 0000000..a8bfa3c --- /dev/null +++ b/crates/shared/src/profiles/retrieval.rs @@ -0,0 +1,52 @@ +//! RetrievalProfile — what + how the agent reaches into memory. +//! +//! Phase 41 decomposition: the old ModelProfile bundled "what dataset +//! can I read" (bound_datasets) AND "how do I rank results" +//! (hnsw_config) with the model tag. Retrieval concerns split out here +//! so a profile can swap its retrieval strategy without re-activating +//! the model. +//! +//! Fields chosen for what's actually varied per-workload today: +//! - `top_k` / `rerank_top_k` — how many hits to fetch + rerank +//! - `freshness_cutoff_days` — Phase 45 doc-drift uses this +//! - `boost_playbook_memory` — Phase 19 meta-index feedback +//! - `enforce_sensitivity_gates` — Phase 13 access-control integration +//! +//! All fields are `#[serde(default)]` so loading a profile file that +//! predates Phase 41 works without migration. + +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct RetrievalProfile { + /// Unique id — slug form, separate namespace from ExecutionProfile. + pub id: String, + /// Free-text operator description. + #[serde(default)] + pub description: String, + /// Default top-K for /vectors/search + /vectors/hybrid. + #[serde(default = "default_top_k")] + pub top_k: u32, + /// How many of the top-K to pass through the reranker. 0 disables + /// reranking for this profile. + #[serde(default = "default_rerank_top_k")] + pub rerank_top_k: u32, + /// Don't consider playbooks / docs older than this (days). 0 or + /// absent = no freshness filter. + #[serde(default)] + pub freshness_cutoff_days: u32, + /// Phase 19: boost workers/results by playbook_memory similarity. + #[serde(default)] + pub boost_playbook_memory: bool, + /// Phase 13: apply access-control masking on sensitive columns. + /// Default on — safety-first. + #[serde(default = "default_true")] + pub enforce_sensitivity_gates: bool, + pub created_at: chrono::DateTime, + #[serde(default)] + pub created_by: String, +} + +fn default_top_k() -> u32 { 10 } +fn default_rerank_top_k() -> u32 { 5 } +fn default_true() -> bool { true } diff --git a/crates/truth/Cargo.toml b/crates/truth/Cargo.toml new file mode 100644 index 0000000..756fe2d --- /dev/null +++ b/crates/truth/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "truth" +version = "0.1.0" +edition = "2024" + +[dependencies] +serde = { workspace = true } +serde_json = { workspace = true } +tokio = { workspace = true } +tracing = { workspace = true } +toml = { workspace = true } \ No newline at end of file diff --git a/crates/truth/src/devops.rs b/crates/truth/src/devops.rs new file mode 100644 index 0000000..3c6f7a6 --- /dev/null +++ b/crates/truth/src/devops.rs @@ -0,0 +1,49 @@ +//! DevOps task-class rules — scaffold for the long-horizon phase. +//! +//! Phase 42 PRD: "Terraform/Ansible rule shapes are scaffolded but +//! unpopulated until the long-horizon phase. Keeps the dispatcher +//! signature stable so no refactor needed later." +//! +//! This module is intentionally minimal. It registers no rules yet. +//! The `devops_rules` function exists so callers can compose it onto +//! a store (e.g. `devops_rules(staffing_rules(TruthStore::new()))`) +//! without branching on whether the DevOps phase has landed. +//! +//! When the long-horizon phase fleshes out the DevOps rule set, the +//! implementations drop in here — same `RuleCondition` primitives, same +//! `TruthStore::evaluate` contract, zero upstream refactor. + +use crate::TruthStore; + +/// Register DevOps rules on the store. Currently a no-op scaffold — +/// no rules are added. Safe to compose with other rule-set functions. +/// +/// Planned task classes (not yet populated): +/// - `devops.terraform_plan` — `terraform validate` + pre-plan +/// sanity checks (no destroys without confirm flag, etc.) +/// - `devops.ansible_playbook` — `ansible-lint` + privileged-task +/// gates (no `become: true` on untagged hosts) +/// - `devops.shell_command` — whitelist / blocklist for +/// AI-generated shell invocations (covers what Phase 42 +/// queryd SQL gate does for SQL — same idea, shell surface) +pub fn devops_rules(store: TruthStore) -> TruthStore { + // Intentionally empty. See module-level doc for the phased rollout. + store +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn devops_rules_is_a_noop_for_now() { + // Scaffold guarantee: composing devops_rules onto an empty + // store must not add any rules. Future long-horizon work will + // populate this and the assertion shifts to counting the + // expected additions. + let store = devops_rules(TruthStore::new()); + assert_eq!(store.get_rules("devops.terraform_plan").len(), 0); + assert_eq!(store.get_rules("devops.ansible_playbook").len(), 0); + assert_eq!(store.get_rules("devops.shell_command").len(), 0); + } +} diff --git a/crates/truth/src/lib.rs b/crates/truth/src/lib.rs new file mode 100644 index 0000000..78fb8c5 --- /dev/null +++ b/crates/truth/src/lib.rs @@ -0,0 +1,610 @@ +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; + +pub mod staffing; +pub mod devops; +pub mod loader; + +#[derive(Clone, Debug, Serialize, Deserialize)] +pub struct TruthRule { + pub id: String, + pub task_class: String, + pub description: String, + pub condition: RuleCondition, + pub action: RuleAction, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(tag = "type")] +pub enum RuleCondition { + Always, + FieldEquals { field: String, value: String }, + FieldMismatch { field: String, value: String }, + FieldEmpty { field: String }, + FieldGreater { field: String, threshold: i64 }, + // Case-insensitive substring scan — true if the field value contains + // ANY of `needles`. Added for SQL/command guards where rules of the + // form "sql must not contain DROP/DELETE/TRUNCATE" need to express + // enforcement as a passing precondition being absent. + FieldContainsAny { field: String, needles: Vec }, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(tag = "type")] +pub enum RuleAction { + Pass, + Reject { message: String }, + Redact { fields: Vec }, + Block { message: String }, +} + +#[derive(Default)] +pub struct TruthStore { + rules: HashMap>, +} + +impl TruthStore { + pub fn new() -> Self { + Self::default() + } + + pub fn add_rule(&mut self, rule: TruthRule) { + self.rules + .entry(rule.task_class.clone()) + .or_default() + .push(rule); + } + + /// All rule IDs across every task class. Used by the file loader + /// to detect duplicate-ID collisions before registering new rules. + pub fn all_rule_ids(&self) -> std::collections::HashSet { + self.rules + .values() + .flat_map(|v| v.iter().map(|r| r.id.clone())) + .collect() + } + + pub fn get_rules(&self, task_class: &str) -> Vec<&TruthRule> { + self.rules + .get(task_class) + .map(|v| v.iter().collect()) + .unwrap_or_default() + } + + /// Legacy API: returns the list of actions registered for a task class + /// without evaluating conditions. Retained for backward compatibility + /// with callers that only want the action catalog. New callers should + /// prefer `evaluate()`, which actually walks `RuleCondition` against + /// a context and reports per-rule pass/fail. + pub fn check(&self, task_class: &str) -> Vec { + let rules = self.get_rules(task_class); + rules + .into_iter() + .map(|r| r.action.clone()) + .collect() + } + + /// Evaluate every rule registered for `task_class` against `ctx`, + /// returning one `RuleOutcome` per rule. `passed = true` means the + /// rule's `condition` held; the rule's action is still attached so + /// callers can distinguish "passed and therefore no-op" (RuleAction::Pass) + /// from "passed and apply Redact". `passed = false` means the condition + /// failed — callers should treat the attached action as the enforcement + /// response (Reject/Block). + /// + /// Fixed P42-001 (2026-04-23): previously `check()` returned all actions + /// unconditionally — the `RuleCondition` field was ignored. Now every + /// rule is actually walked against the provided context. + pub fn evaluate(&self, task_class: &str, ctx: &serde_json::Value) -> Vec { + self.get_rules(task_class) + .into_iter() + .map(|r| RuleOutcome { + rule_id: r.id.clone(), + passed: evaluate_condition(&r.condition, ctx), + action: r.action.clone(), + }) + .collect() + } +} + +/// Result of evaluating one rule against a context. `passed` reports +/// whether the condition held; `action` is the rule's declared action +/// regardless (callers decide how to apply it based on `passed`). +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +pub struct RuleOutcome { + pub rule_id: String, + pub passed: bool, + pub action: RuleAction, +} + +fn evaluate_condition(cond: &RuleCondition, ctx: &serde_json::Value) -> bool { + match cond { + RuleCondition::Always => true, + RuleCondition::FieldEquals { field, value } => { + field_as_string(ctx, field) + .map(|s| s == *value) + .unwrap_or(false) + } + RuleCondition::FieldMismatch { field, value } => { + field_as_string(ctx, field) + .map(|s| s != *value) + .unwrap_or(false) + } + RuleCondition::FieldEmpty { field } => { + match lookup(ctx, field) { + None => true, + Some(v) => v.is_null() || v.as_str().map(|s| s.is_empty()).unwrap_or(false), + } + } + RuleCondition::FieldGreater { field, threshold } => { + lookup(ctx, field) + .and_then(|v| v.as_i64().or_else(|| v.as_f64().map(|f| f as i64))) + .map(|n| n > *threshold) + .unwrap_or(false) + } + RuleCondition::FieldContainsAny { field, needles } => { + match field_as_string(ctx, field) { + None => false, + Some(s) => { + let haystack = s.to_ascii_lowercase(); + needles.iter().any(|n| haystack.contains(&n.to_ascii_lowercase())) + } + } + } + } +} + +/// Walk a dot-separated path through a serde_json::Value. `"worker.status"` +/// → `ctx["worker"]["status"]`. Returns None if any segment is missing or +/// a non-object is encountered mid-path. +fn lookup<'a>(ctx: &'a serde_json::Value, path: &str) -> Option<&'a serde_json::Value> { + let mut cur = ctx; + for seg in path.split('.') { + cur = cur.get(seg)?; + } + Some(cur) +} + +fn field_as_string(ctx: &serde_json::Value, path: &str) -> Option { + lookup(ctx, path).and_then(|v| match v { + serde_json::Value::String(s) => Some(s.clone()), + serde_json::Value::Bool(b) => Some(b.to_string()), + serde_json::Value::Number(n) => Some(n.to_string()), + _ => None, + }) +} + +/// Minimal SQL guard — rejects destructive verbs (DROP/TRUNCATE/DELETE). +/// queryd/src/service.rs loads this into its `QueryState` and evaluates +/// every `/sql` request against it before hitting the DataFusion engine. +/// This is the P42-002 enforcement point flagged across scrum iters 3-5 +/// ("raw SQL forwarded without schema or policy gate"). +/// +/// Intentionally narrow: it's a safety net, not a full SQL parser. If +/// callers need richer AST-aware enforcement they should extend this with +/// structured rules rather than new needles. +pub fn sql_query_guard_store() -> TruthStore { + let mut store = TruthStore::new(); + store.add_rule(TruthRule { + id: "no-destructive-sql".to_string(), + task_class: "sql_query".to_string(), + description: "SQL must not contain destructive verbs".to_string(), + condition: RuleCondition::FieldContainsAny { + field: "sql".to_string(), + needles: vec![ + "drop table".to_string(), + "drop schema".to_string(), + "drop database".to_string(), + "truncate".to_string(), + "delete from".to_string(), + ], + }, + action: RuleAction::Reject { + message: "destructive SQL rejected by truth.sql_query_guard".to_string(), + }, + }); + store.add_rule(TruthRule { + id: "sql-not-empty".to_string(), + task_class: "sql_query".to_string(), + description: "SQL must not be empty".to_string(), + condition: RuleCondition::FieldEmpty { + field: "sql".to_string(), + }, + action: RuleAction::Reject { + message: "empty SQL rejected".to_string(), + }, + }); + store +} + +/// Phase 42 default store: staffing rules + DevOps scaffold composed +/// onto an empty TruthStore. Per the PRD: "Staffing rules ship first; +/// Terraform/Ansible rule shapes are scaffolded but unpopulated until +/// the long-horizon phase." The composition order is irrelevant here +/// (DevOps is empty) but preserved so the shape matches the PRD's +/// expected "compose on top" pattern. +/// +/// Moved out of inline in-function rule registration (2026-04-24) to +/// land the Phase 42 module split the PRD called for: `staffing.rs` + +/// `devops.rs` each owns their task-class rule sets. Behavior unchanged +/// for existing callers. +pub fn default_truth_store() -> TruthStore { + devops::devops_rules(staffing::staffing_rules(TruthStore::new())) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn truth_store_new_is_empty() { + let store = TruthStore::new(); + assert!(store.rules.is_empty()); + } + + #[test] + fn add_rule_inserts_into_correct_task_class() { + let mut store = TruthStore::new(); + store.add_rule(TruthRule { + id: "test-rule".to_string(), + task_class: "test.task".to_string(), + description: "Test rule".to_string(), + condition: RuleCondition::Always, + action: RuleAction::Pass, + }); + let rules = store.get_rules("test.task"); + assert_eq!(rules.len(), 1); + assert_eq!(rules[0].id, "test-rule"); + } + + #[test] + fn get_rules_returns_empty_for_unknown_class() { + let store = TruthStore::new(); + let rules = store.get_rules("unknown.class"); + assert!(rules.is_empty()); + } + + #[test] + fn check_returns_actions_for_task_class() { + let mut store = TruthStore::new(); + store.add_rule(TruthRule { + id: "a1".to_string(), + task_class: "test".to_string(), + description: "A1".to_string(), + condition: RuleCondition::Always, + action: RuleAction::Pass, + }); + store.add_rule(TruthRule { + id: "a2".to_string(), + task_class: "test".to_string(), + description: "A2".to_string(), + condition: RuleCondition::Always, + action: RuleAction::Reject { + message: "test reject".to_string(), + }, + }); + let actions = store.check("test"); + assert_eq!(actions.len(), 2); + } + + #[test] + fn rule_condition_serialize_always() { + let cond = RuleCondition::Always; + let json = serde_json::to_string(&cond).unwrap(); + assert!(json.contains(r#""type":"Always"#)); + } + + #[test] + fn rule_condition_serialize_field_equals() { + let cond = RuleCondition::FieldEquals { + field: "foo".to_string(), + value: "bar".to_string(), + }; + let json = serde_json::to_string(&cond).unwrap(); + assert!(json.contains(r#""type":"FieldEquals""#)); + assert!(json.contains(r#""field":"foo""#)); + assert!(json.contains(r#""value":"bar""#)); + } + + #[test] + fn rule_action_serialize_redact() { + let action = RuleAction::Redact { + fields: vec!["ssn".to_string()], + }; + let json = serde_json::to_string(&action).unwrap(); + assert!(json.contains(r#""type":"Redact""#)); + assert!(json.contains("ssn")); + } + + #[test] + fn rule_action_serialize_reject() { + let action = RuleAction::Reject { + message: "test".to_string(), + }; + let json = serde_json::to_string(&action).unwrap(); + assert!(json.contains(r#""type":"Reject""#)); + } + + #[test] + fn default_truth_store_has_staffing_rules() { + let store = default_truth_store(); + let fill_rules = store.get_rules("staffing.fill"); + assert!(!fill_rules.is_empty()); + let any_rules = store.get_rules("staffing.any"); + assert!(!any_rules.is_empty()); + } + + #[test] + fn multiple_rules_same_task_class() { + let mut store = TruthStore::new(); + for i in 0..5 { + store.add_rule(TruthRule { + id: format!("rule-{}", i), + task_class: "test".to_string(), + description: format!("Rule {}", i), + condition: RuleCondition::Always, + action: RuleAction::Pass, + }); + } + let rules = store.get_rules("test"); + assert_eq!(rules.len(), 5); + } + + #[test] + fn truth_rule_clone_preserves_data() { + let rule = TruthRule { + id: "clone-test".to_string(), + task_class: "clone.task".to_string(), + description: "Clone test".to_string(), + condition: RuleCondition::FieldEquals { + field: "x".to_string(), + value: "y".to_string(), + }, + action: RuleAction::Block { + message: "blocked".to_string(), + }, + }; + let cloned = rule.clone(); + assert_eq!(cloned.id, rule.id); + assert_eq!(cloned.condition, rule.condition); + assert_eq!(cloned.action, rule.action); + } + + #[test] + fn field_greater_condition_parse() { + let json = r#"{"type":"FieldGreater","field":"count","threshold":10}"#; + let cond: RuleCondition = serde_json::from_str(json).unwrap(); + match cond { + RuleCondition::FieldGreater { field, threshold } => { + assert_eq!(field, "count"); + assert_eq!(threshold, 10); + } + _ => panic!("Expected FieldGreater"), + } + } + + #[test] + fn block_action_blocks_with_message() { + let action = RuleAction::Block { + message: "Rate limited".to_string(), + }; + let json = serde_json::to_string(&action).unwrap(); + assert!(json.contains("Rate limited")); + } + + #[test] + fn empty_store_check_returns_empty() { + let store = TruthStore::new(); + let actions = store.check("empty.class"); + assert!(actions.is_empty()); + } + + // ── P42-001 evaluate() tests — actually walk RuleCondition ── + + fn fill_store() -> TruthStore { + let mut s = TruthStore::new(); + s.add_rule(TruthRule { + id: "active".into(), + task_class: "t".into(), + description: "must be active".into(), + condition: RuleCondition::FieldEquals { + field: "worker.status".into(), + value: "active".into(), + }, + action: RuleAction::Reject { + message: "worker not active".into(), + }, + }); + s.add_rule(TruthRule { + id: "deadline".into(), + task_class: "t".into(), + description: "deadline required".into(), + condition: RuleCondition::FieldEmpty { + field: "contract.deadline".into(), + }, + action: RuleAction::Reject { + message: "missing deadline".into(), + }, + }); + s.add_rule(TruthRule { + id: "budget".into(), + task_class: "t".into(), + description: "budget positive".into(), + condition: RuleCondition::FieldGreater { + field: "contract.budget".into(), + threshold: 0, + }, + action: RuleAction::Block { + message: "budget must be positive".into(), + }, + }); + s + } + + #[test] + fn evaluate_field_equals_pass_on_match() { + let s = fill_store(); + let ctx = serde_json::json!({"worker": {"status": "active"}}); + let o = s.evaluate("t", &ctx); + let active = o.iter().find(|r| r.rule_id == "active").unwrap(); + assert!(active.passed, "active condition should hold"); + } + + #[test] + fn evaluate_field_equals_fail_on_mismatch() { + let s = fill_store(); + let ctx = serde_json::json!({"worker": {"status": "terminated"}}); + let o = s.evaluate("t", &ctx); + let active = o.iter().find(|r| r.rule_id == "active").unwrap(); + assert!(!active.passed, "terminated should fail active condition"); + } + + #[test] + fn evaluate_field_equals_fail_on_missing() { + let s = fill_store(); + let ctx = serde_json::json!({}); + let o = s.evaluate("t", &ctx); + let active = o.iter().find(|r| r.rule_id == "active").unwrap(); + assert!(!active.passed, "missing worker.status should fail"); + } + + #[test] + fn evaluate_field_empty_pass_when_absent() { + let s = fill_store(); + // FieldEmpty passes when the field is missing/null/empty string. + // Deadline rule says "field empty means action fires" — so passed=true + // here means the rule's condition held (deadline IS empty). + let ctx = serde_json::json!({}); + let o = s.evaluate("t", &ctx); + let deadline = o.iter().find(|r| r.rule_id == "deadline").unwrap(); + assert!(deadline.passed); + } + + #[test] + fn evaluate_field_empty_fail_when_present() { + let s = fill_store(); + let ctx = serde_json::json!({"contract": {"deadline": "2026-05-01"}}); + let o = s.evaluate("t", &ctx); + let deadline = o.iter().find(|r| r.rule_id == "deadline").unwrap(); + assert!(!deadline.passed, "non-empty deadline should fail FieldEmpty check"); + } + + #[test] + fn evaluate_field_greater_pass_and_fail() { + let s = fill_store(); + let ctx_ok = serde_json::json!({"contract": {"budget": 100}}); + let ctx_bad = serde_json::json!({"contract": {"budget": 0}}); + let ok = s.evaluate("t", &ctx_ok); + let bad = s.evaluate("t", &ctx_bad); + assert!(ok.iter().find(|r| r.rule_id == "budget").unwrap().passed); + assert!(!bad.iter().find(|r| r.rule_id == "budget").unwrap().passed); + } + + #[test] + fn evaluate_always_condition_passes_unconditionally() { + let mut s = TruthStore::new(); + s.add_rule(TruthRule { + id: "always".into(), + task_class: "x".into(), + description: "".into(), + condition: RuleCondition::Always, + action: RuleAction::Pass, + }); + let o = s.evaluate("x", &serde_json::json!(null)); + assert!(o[0].passed); + } + + #[test] + fn evaluate_preserves_action_regardless_of_outcome() { + let s = fill_store(); + let ctx = serde_json::json!({"worker": {"status": "active"}}); + let o = s.evaluate("t", &ctx); + let active = o.iter().find(|r| r.rule_id == "active").unwrap(); + // Action is attached whether the rule passed or not — the consumer + // decides how to use it. + assert_eq!( + active.action, + RuleAction::Reject { + message: "worker not active".into() + } + ); + } + + #[test] + fn evaluate_on_unknown_task_class_returns_empty() { + let s = fill_store(); + let o = s.evaluate("nonexistent", &serde_json::json!({})); + assert!(o.is_empty()); + } + + #[test] + fn check_still_returns_actions_unconditionally_for_back_compat() { + // Legacy API should still behave the same — no condition walking. + let s = fill_store(); + let actions = s.check("t"); + assert_eq!(actions.len(), 3, "check returns one action per rule regardless of condition"); + } + + fn sql_guard_store() -> TruthStore { + let mut s = TruthStore::new(); + s.add_rule(TruthRule { + id: "no-destructive".into(), + task_class: "sql_query".into(), + description: "SQL must not contain destructive verbs".into(), + condition: RuleCondition::FieldContainsAny { + field: "sql".into(), + needles: vec![ + "drop table".into(), + "drop schema".into(), + "truncate".into(), + "delete from".into(), + ], + }, + action: RuleAction::Reject { + message: "destructive SQL rejected".into(), + }, + }); + s + } + + #[test] + fn field_contains_any_matches_case_insensitively() { + let s = sql_guard_store(); + let ctx = serde_json::json!({"sql": "SELECT * FROM t; DROP TABLE users;"}); + let o = s.evaluate("sql_query", &ctx); + assert!(o[0].passed, "condition holds when needle present (case-insensitive)"); + } + + #[test] + fn field_contains_any_is_false_when_no_needle_matches() { + let s = sql_guard_store(); + let ctx = serde_json::json!({"sql": "SELECT count(*) FROM workers"}); + let o = s.evaluate("sql_query", &ctx); + assert!(!o[0].passed, "benign SELECT should not match destructive needles"); + } + + #[test] + fn field_contains_any_false_when_field_missing() { + let s = sql_guard_store(); + let ctx = serde_json::json!({}); + let o = s.evaluate("sql_query", &ctx); + assert!(!o[0].passed, "missing field → condition cannot hold"); + } + + #[test] + fn field_contains_any_empty_needles_list_never_matches() { + let mut s = TruthStore::new(); + s.add_rule(TruthRule { + id: "empty".into(), + task_class: "x".into(), + description: "".into(), + condition: RuleCondition::FieldContainsAny { + field: "sql".into(), + needles: vec![], + }, + action: RuleAction::Pass, + }); + let o = s.evaluate("x", &serde_json::json!({"sql": "anything"})); + assert!(!o[0].passed, "no needles → any:: is false"); + } +} \ No newline at end of file diff --git a/crates/truth/src/loader.rs b/crates/truth/src/loader.rs new file mode 100644 index 0000000..79741da --- /dev/null +++ b/crates/truth/src/loader.rs @@ -0,0 +1,187 @@ +//! File-backed TruthRule loader (Phase 42 PRD). +//! +//! PRD: "truth/ dir at repo root — rule files, versioned in git." +//! This module walks a directory, parses every `*.toml` file it finds, +//! and registers the rules into a caller-supplied store. Rule IDs must +//! be unique across the combined set — duplicate-ID collisions are +//! load-time errors. +//! +//! The TOML format matches the shape at `truth/README.md`. The same +//! `RuleCondition` + `RuleAction` enums used by the in-code registrars +//! deserialize directly from `condition = { type = "FieldEquals", ... }` +//! thanks to `#[serde(tag = "type")]`. + +use std::fs; +use std::path::Path; +use serde::Deserialize; + +use crate::{TruthRule, TruthStore}; + +/// Deserialization wrapper — a TOML file is a list of [[rule]] blocks. +#[derive(Deserialize)] +struct RuleFile { + #[serde(default)] + rule: Vec, +} + +/// Load every `*.toml` file in `dir` and add its rules to `store`. +/// Returns the number of rules loaded across all files. +/// +/// Errors: +/// - directory doesn't exist or can't be read +/// - any `.toml` file fails to parse +/// - any rule ID collides with an existing rule (same ID already +/// registered in the store) +/// +/// Non-goals: recursive walk (flat dir only), hot reload (one-shot load). +pub fn load_from_dir(store: &mut TruthStore, dir: impl AsRef) -> Result { + let dir = dir.as_ref(); + let entries = fs::read_dir(dir) + .map_err(|e| format!("read_dir {}: {e}", dir.display()))?; + + let mut loaded_ids = store.all_rule_ids(); + let mut count = 0usize; + + let mut paths: Vec<_> = entries + .filter_map(|e| e.ok()) + .map(|e| e.path()) + .filter(|p| p.extension().and_then(|s| s.to_str()) == Some("toml")) + .collect(); + // Deterministic order — alphabetical by filename. Matters when a + // cross-file ID collision happens; the earlier filename wins + // nothing (both error), but the error message is reproducible. + paths.sort(); + + for path in paths { + let raw = fs::read_to_string(&path) + .map_err(|e| format!("read {}: {e}", path.display()))?; + let file: RuleFile = toml::from_str(&raw) + .map_err(|e| format!("parse {}: {e}", path.display()))?; + for rule in file.rule { + if !loaded_ids.insert(rule.id.clone()) { + return Err(format!( + "duplicate rule id '{}' from {}", + rule.id, + path.display() + )); + } + store.add_rule(rule); + count += 1; + } + } + + Ok(count) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::Write; + + fn write_file(dir: &Path, name: &str, content: &str) { + let path = dir.join(name); + let mut f = fs::File::create(&path).unwrap(); + f.write_all(content.as_bytes()).unwrap(); + } + + #[test] + fn loads_rules_from_toml_files() { + let tmp = tempdir_for("loader_test"); + write_file(&tmp, "a.toml", r#" +[[rule]] +id = "a-rule" +task_class = "test" +description = "test rule" +action = { type = "Pass" } + +[rule.condition] +type = "Always" +"#); + let mut store = TruthStore::new(); + let n = load_from_dir(&mut store, &tmp).unwrap(); + assert_eq!(n, 1); + assert_eq!(store.get_rules("test").len(), 1); + let _ = fs::remove_dir_all(&tmp); + } + + #[test] + fn rejects_duplicate_rule_ids() { + let tmp = tempdir_for("dup_ids"); + write_file(&tmp, "a.toml", r#" +[[rule]] +id = "same" +task_class = "t" +description = "" +action = { type = "Pass" } +[rule.condition] +type = "Always" +"#); + write_file(&tmp, "b.toml", r#" +[[rule]] +id = "same" +task_class = "t" +description = "" +action = { type = "Pass" } +[rule.condition] +type = "Always" +"#); + let mut store = TruthStore::new(); + let err = load_from_dir(&mut store, &tmp).unwrap_err(); + assert!(err.contains("duplicate"), "got: {err}"); + let _ = fs::remove_dir_all(&tmp); + } + + #[test] + fn duplicate_with_in_code_rule_is_rejected() { + // Existing in-store IDs count as "already registered." Operator + // can't shadow an in-code rule by file without changing the ID. + let tmp = tempdir_for("dup_in_code"); + write_file(&tmp, "conflict.toml", r#" +[[rule]] +id = "worker-active" +task_class = "staffing.fill" +description = "file attempt" +action = { type = "Pass" } +[rule.condition] +type = "Always" +"#); + // staffing_rules registers "worker-active" + let mut store = crate::staffing::staffing_rules(TruthStore::new()); + let err = load_from_dir(&mut store, &tmp).unwrap_err(); + assert!(err.contains("duplicate") && err.contains("worker-active")); + let _ = fs::remove_dir_all(&tmp); + } + + #[test] + fn skips_non_toml_files() { + let tmp = tempdir_for("skip_non_toml"); + write_file(&tmp, "a.toml", r#" +[[rule]] +id = "x" +task_class = "t" +description = "" +action = { type = "Pass" } +[rule.condition] +type = "Always" +"#); + write_file(&tmp, "README.md", "not a toml file"); + let mut store = TruthStore::new(); + let n = load_from_dir(&mut store, &tmp).unwrap(); + assert_eq!(n, 1); // README.md ignored + let _ = fs::remove_dir_all(&tmp); + } + + #[test] + fn missing_dir_returns_error() { + let mut store = TruthStore::new(); + let err = load_from_dir(&mut store, "/nonexistent/path/here").unwrap_err(); + assert!(err.contains("read_dir")); + } + + fn tempdir_for(tag: &str) -> std::path::PathBuf { + let dir = std::env::temp_dir().join(format!("truth_loader_{}_{}", tag, + std::process::id())); + fs::create_dir_all(&dir).unwrap(); + dir + } +} diff --git a/crates/truth/src/staffing.rs b/crates/truth/src/staffing.rs new file mode 100644 index 0000000..f8ff7aa --- /dev/null +++ b/crates/truth/src/staffing.rs @@ -0,0 +1,125 @@ +//! Staffing task-class rules for the TruthStore. +//! +//! Phase 42 PRD: "Staffing rules ship first. Terraform/Ansible rule +//! shapes are scaffolded but unpopulated until the long-horizon phase." +//! This module owns the staffing rule set; `devops.rs` holds the +//! matching scaffold for the DevOps long-horizon. +//! +//! Rules registered here live under the task classes `staffing.fill` +//! (fill proposals), `staffing.rescue` (rescue escalations), and +//! `staffing.any` (rules that apply across all staffing task classes — +//! PII redaction being the canonical example). +//! +//! All rules are evaluated via the `TruthStore::evaluate` walk, which +//! pairs each rule's `RuleCondition` against a caller-supplied JSON +//! context and emits a `RuleOutcome { passed, action }` per rule. +//! Downstream enforcement (router gate, SQL gate, execution-loop gate) +//! decides how to apply the action — `Reject` / `Block` shortcircuit, +//! `Redact` mutates, `Pass` is informational. + +use crate::{RuleAction, RuleCondition, TruthRule, TruthStore}; + +/// Register the staffing rule set on an existing store. Returns the +/// store for chaining if the caller wants to fold other rule sets on +/// top (e.g. `staffing_rules(devops_rules(TruthStore::new()))`). +pub fn staffing_rules(mut store: TruthStore) -> TruthStore { + store.add_rule(TruthRule { + id: "worker-active".to_string(), + task_class: "staffing.fill".to_string(), + description: "Worker must be active".to_string(), + condition: RuleCondition::FieldEquals { + field: "worker.status".to_string(), + value: "active".to_string(), + }, + action: RuleAction::Pass, + }); + + store.add_rule(TruthRule { + id: "client-not-blacklisted".to_string(), + task_class: "staffing.fill".to_string(), + description: "Worker cannot be blacklisted for client".to_string(), + condition: RuleCondition::FieldEquals { + field: "worker.client_blacklisted".to_string(), + value: "false".to_string(), + }, + action: RuleAction::Pass, + }); + + store.add_rule(TruthRule { + id: "deadline-required".to_string(), + task_class: "staffing.fill".to_string(), + description: "Contract must have deadline".to_string(), + condition: RuleCondition::FieldEmpty { + field: "contract.deadline".to_string(), + }, + action: RuleAction::Reject { + message: "Contract deadline is required".to_string(), + }, + }); + + store.add_rule(TruthRule { + id: "budget-required".to_string(), + task_class: "staffing.fill".to_string(), + description: "Budget must be non-negative".to_string(), + condition: RuleCondition::FieldGreater { + field: "contract.budget_per_hour_max".to_string(), + threshold: 0, + }, + action: RuleAction::Pass, + }); + + store.add_rule(TruthRule { + id: "pii-redact".to_string(), + task_class: "staffing.any".to_string(), + description: "Redact PII before cloud calls".to_string(), + condition: RuleCondition::Always, + action: RuleAction::Redact { + fields: vec!["ssn".to_string(), "salary".to_string()], + }, + }); + + store +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn staffing_rules_registers_five_rules() { + // 4 staffing.fill rules + 1 staffing.any rule = 5 total. + // Regression guard: if someone adds a rule to this module + // without updating the count, this test surfaces it. + let store = staffing_rules(TruthStore::new()); + let fill = store.get_rules("staffing.fill").len(); + let any = store.get_rules("staffing.any").len(); + assert_eq!(fill, 4); + assert_eq!(any, 1); + } + + #[test] + fn blacklisted_worker_fails_the_rule() { + let store = staffing_rules(TruthStore::new()); + let ctx = serde_json::json!({ + "worker": { "client_blacklisted": "true" } + }); + let outcomes = store.evaluate("staffing.fill", &ctx); + let blk = outcomes.iter().find(|o| o.rule_id == "client-not-blacklisted").unwrap(); + assert!(!blk.passed, "blacklisted worker must fail the rule"); + } + + #[test] + fn missing_deadline_fires_reject_via_empty_condition() { + let store = staffing_rules(TruthStore::new()); + // FieldEmpty passes when the field is missing — and the rule's + // action is Reject, so enforcement should fire. + let ctx = serde_json::json!({}); + let outcomes = store.evaluate("staffing.fill", &ctx); + let deadline = outcomes.iter().find(|o| o.rule_id == "deadline-required").unwrap(); + assert!(deadline.passed); + match &deadline.action { + RuleAction::Reject { message } => assert!(message.contains("deadline")), + _ => panic!("expected Reject action"), + } + } +} diff --git a/crates/ui/src/main.rs b/crates/ui/src/main.rs index 53c9ad2..436421f 100644 --- a/crates/ui/src/main.rs +++ b/crates/ui/src/main.rs @@ -1238,13 +1238,13 @@ fn IngestPanel() -> Element { pg_tables.set(Some(tables)); } } - Err(e) => pg_tables.set(None), + Err(_) => pg_tables.set(None), } pg_loading.set(false); }); }; - let mut import_table = move |table: String| { + let import_table = move |table: String| { let host = pg_host.read().clone(); let db = pg_db.read().clone(); spawn(async move { diff --git a/crates/validator/Cargo.toml b/crates/validator/Cargo.toml new file mode 100644 index 0000000..b135bba --- /dev/null +++ b/crates/validator/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "validator" +version = "0.1.0" +edition = "2024" + +[dependencies] +serde = { workspace = true } +serde_json = { workspace = true } +thiserror = { workspace = true } +tokio = { workspace = true } +tracing = { workspace = true } +# Parquet loader for ParquetWorkerLookup (Phase 43 v3 — production +# WorkerLookup backed by workers_500k.parquet snapshot). +arrow = { workspace = true } +parquet = { workspace = true } diff --git a/crates/validator/src/devops.rs b/crates/validator/src/devops.rs new file mode 100644 index 0000000..796b448 --- /dev/null +++ b/crates/validator/src/devops.rs @@ -0,0 +1,44 @@ +//! DevOps validator scaffold — long-horizon. +//! +//! PRD: "scaffold only: stubbed Terraform/Ansible validators +//! (`terraform validate`, `ansible-lint`) for the long-horizon phase." +//! Shipped as Unimplemented stubs so the execution-loop dispatcher +//! has a consistent failure shape to surface ("phase 43 not wired") +//! instead of a missing-impl panic. + +use crate::{Artifact, Report, Validator, ValidationError}; + +pub struct TerraformValidator; + +impl Validator for TerraformValidator { + fn name(&self) -> &'static str { "devops.terraform" } + fn validate(&self, _artifact: &Artifact) -> Result { + Err(ValidationError::Unimplemented { artifact: "terraform_plan" }) + } +} + +pub struct AnsibleValidator; + +impl Validator for AnsibleValidator { + fn name(&self) -> &'static str { "devops.ansible" } + fn validate(&self, _artifact: &Artifact) -> Result { + Err(ValidationError::Unimplemented { artifact: "ansible_playbook" }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn terraform_scaffold_returns_unimplemented() { + let r = TerraformValidator.validate(&Artifact::TerraformPlan(serde_json::json!({}))); + assert!(matches!(r, Err(ValidationError::Unimplemented { .. }))); + } + + #[test] + fn ansible_scaffold_returns_unimplemented() { + let r = AnsibleValidator.validate(&Artifact::AnsiblePlaybook(serde_json::json!({}))); + assert!(matches!(r, Err(ValidationError::Unimplemented { .. }))); + } +} diff --git a/crates/validator/src/lib.rs b/crates/validator/src/lib.rs new file mode 100644 index 0000000..e646dd2 --- /dev/null +++ b/crates/validator/src/lib.rs @@ -0,0 +1,181 @@ +//! Phase 43 Validation Pipeline. +//! +//! PRD: "Staffing outputs run through schema / completeness / +//! consistency / policy gates. Plug into Layer 5 execution loop — +//! failure triggers observer-correction iteration." +//! +//! This crate provides the `Validator` trait + `Artifact` enum + +//! Report/ValidationError types. Staffing validators (fill, email, +//! playbook) and the DevOps scaffold live in submodules. +//! +//! Landed 2026-04-24 as a scaffold — the trait + types + module +//! layout match the PRD; individual validator implementations are +//! `Unimplemented` stubs that return a clear "phase 43 not wired" +//! error rather than silently passing. The execution-loop integration +//! (generate → validate → correct → retry) comes in a follow-up +//! commit once the stubs are filled. + +use serde::{Deserialize, Serialize}; +use thiserror::Error; + +pub mod staffing; +pub mod devops; + +/// What a validator saw. One variant per artifact class we validate. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "kind")] +pub enum Artifact { + /// A fill proposal from the staffing executor — shape is + /// `{fills: [{candidate_id, name}]}` per PRD. + FillProposal(serde_json::Value), + /// An email/SMS draft for outreach. + EmailDraft(serde_json::Value), + /// A playbook being sealed for memory. + Playbook(serde_json::Value), + /// Terraform plan output (scaffold, long-horizon). + TerraformPlan(serde_json::Value), + /// Ansible playbook (scaffold, long-horizon). + AnsiblePlaybook(serde_json::Value), +} + +/// Success report. Empty `findings` means a clean pass. Populated +/// findings with `Severity::Warning` means "acceptable but notable" — +/// the artifact passes. `Severity::Error` means validation failed; +/// the validator should return `Err(...)` in that case, not `Ok`. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Report { + pub findings: Vec, + pub elapsed_ms: u64, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Finding { + pub field: String, + pub severity: Severity, + pub message: String, +} + +#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)] +#[serde(rename_all = "snake_case")] +pub enum Severity { + Warning, + Error, +} + +/// Validation failure — what went wrong + where + why. Returned as +/// `Err` from `validate`. Execution loop catches these and feeds them +/// to the observer-correction retry loop. +#[derive(Debug, Clone, Error, Serialize, Deserialize)] +pub enum ValidationError { + /// Artifact schema doesn't match what we expected. + #[error("schema mismatch at {field}: {reason}")] + Schema { field: String, reason: String }, + /// Required data missing (e.g. endorsed count != target count). + #[error("completeness: {reason}")] + Completeness { reason: String }, + /// Data that's inconsistent with another source of truth + /// (e.g. worker_id doesn't exist in the workers table). + #[error("consistency: {reason}")] + Consistency { reason: String }, + /// Policy violation — truth rule or access control said no. + #[error("policy: {reason}")] + Policy { reason: String }, + /// Validator hasn't been implemented yet — scaffold stub. + #[error("validator not yet implemented for {artifact} — phase 43 scaffold")] + Unimplemented { artifact: &'static str }, +} + +/// Core validation contract. Implementations live in `staffing::*` and +/// `devops::*`. The execution loop dispatches to the right impl based +/// on the Artifact variant. +pub trait Validator: Send + Sync { + fn validate(&self, artifact: &Artifact) -> Result; + /// Human-readable name for logs + Langfuse traces. + fn name(&self) -> &'static str; +} + +// ─── Worker lookup (Phase 43 v2) ──────────────────────────────────────── +// +// Validators that cross-check artifacts against the worker roster +// (FillValidator, EmailValidator) take an `Arc` at +// construction. Keeping the trait sync + in-memory mirrors the +// lakehouse pattern of "load truth into memory, validate against +// snapshot, refresh periodically" rather than per-call DB hits. +// +// Production impl: wrap a parquet snapshot loaded from +// `data/datasets/workers_500k.parquet` (or its safe view counterpart +// once Track A.B lands). Tests use `InMemoryWorkerLookup`. + +/// One worker row from the staffing roster — the fields validators +/// actually read. Anything not on this struct (resume_text, scores, +/// communications) is intentionally hidden from the validator path. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct WorkerRecord { + pub candidate_id: String, + pub name: String, + /// Free-form. Validators check for `"active"` (any other value + /// fails the status check). Common values from existing data: + /// "active", "inactive", "placed", "blacklisted". + pub status: String, + pub city: Option, + pub state: Option, + pub role: Option, + /// Client ids this worker has been blacklisted from. Populated + /// from joining a blacklist table; empty when not provided. + #[serde(default)] + pub blacklisted_clients: Vec, +} + +/// Worker lookup contract. Sync by design — implementations should +/// hold an in-memory snapshot, not perform per-call I/O. +pub trait WorkerLookup: Send + Sync { + fn find(&self, candidate_id: &str) -> Option; + /// Number of workers in the snapshot. Default 0 for impls that + /// genuinely don't know (e.g. a future SQL-backed lookup that + /// counts on demand). InMemoryWorkerLookup overrides with the + /// HashMap size; ParquetWorkerLookup constructs an + /// InMemoryWorkerLookup so it inherits the override. Used by + /// /v1/health to report data-load status during production + /// switchover (the Chicago dataset replaces synthetic test data; + /// the health endpoint is how operators verify the new file + /// loaded correctly without restart-and-pray). + fn len(&self) -> usize { 0 } +} + +/// HashMap-backed lookup. Used by validator unit tests + as a +/// reasonable bootstrap impl for production once the parquet loader +/// fills it on startup. +pub struct InMemoryWorkerLookup { + rows: std::collections::HashMap, +} + +impl InMemoryWorkerLookup { + pub fn new() -> Self { + Self { rows: Default::default() } + } + pub fn from_records(records: Vec) -> Self { + let mut rows = std::collections::HashMap::with_capacity(records.len()); + for r in records { + rows.insert(r.candidate_id.clone(), r); + } + Self { rows } + } + pub fn insert(&mut self, record: WorkerRecord) { + self.rows.insert(record.candidate_id.clone(), record); + } + pub fn len(&self) -> usize { self.rows.len() } + pub fn is_empty(&self) -> bool { self.rows.is_empty() } +} + +impl Default for InMemoryWorkerLookup { + fn default() -> Self { Self::new() } +} + +impl WorkerLookup for InMemoryWorkerLookup { + fn find(&self, candidate_id: &str) -> Option { + self.rows.get(candidate_id).cloned() + } + fn len(&self) -> usize { + self.rows.len() + } +} diff --git a/crates/validator/src/staffing/email.rs b/crates/validator/src/staffing/email.rs new file mode 100644 index 0000000..ae96c06 --- /dev/null +++ b/crates/validator/src/staffing/email.rs @@ -0,0 +1,370 @@ +//! Email/SMS draft validator (Phase 43 v2 — real PII + name checks). +//! +//! PRD checks: +//! - Schema (TO/BODY fields present) +//! - Length (SMS ≤ 160 chars; email subject ≤ 78 chars) +//! - PII absence (no SSN / salary leaked into outgoing text) +//! - Worker-name consistency (name in message matches worker record) +//! +//! Like FillValidator, EmailValidator takes `Arc` at +//! construction. The contract metadata (which worker the message is +//! about) travels under `_context.candidate_id` in the JSON payload. +//! When `_context.candidate_id` is present and resolves, the validator +//! cross-checks that the worker's name appears verbatim in the body. +//! +//! PII detection is std-only (no regex dep) — a hand-rolled scan +//! covers the patterns we actually care about: SSN (NNN-NN-NNNN), +//! salary statements ("salary" / "compensation" near a $ amount). + +use crate::{ + Artifact, Report, Validator, ValidationError, WorkerLookup, +}; +use std::sync::Arc; +use std::time::Instant; + +pub struct EmailValidator { + workers: Arc, +} + +impl EmailValidator { + pub fn new(workers: Arc) -> Self { + Self { workers } + } +} + +const SMS_MAX_CHARS: usize = 160; +const EMAIL_SUBJECT_MAX_CHARS: usize = 78; + +impl Validator for EmailValidator { + fn name(&self) -> &'static str { "staffing.email" } + + fn validate(&self, artifact: &Artifact) -> Result { + let started = Instant::now(); + let value = match artifact { + Artifact::EmailDraft(v) => v, + other => return Err(ValidationError::Schema { + field: "artifact".into(), + reason: format!("EmailValidator expects EmailDraft, got {other:?}"), + }), + }; + + let _to = value.get("to").and_then(|v| v.as_str()).ok_or( + ValidationError::Schema { + field: "to".into(), + reason: "missing or not a string".into(), + }, + )?; + let body = value.get("body").and_then(|v| v.as_str()).ok_or( + ValidationError::Schema { + field: "body".into(), + reason: "missing or not a string".into(), + }, + )?; + + let is_sms = value.get("kind").and_then(|k| k.as_str()) == Some("sms"); + if is_sms && body.len() > SMS_MAX_CHARS { + return Err(ValidationError::Completeness { + reason: format!("SMS body is {} chars, max {SMS_MAX_CHARS}", body.len()), + }); + } + + if let Some(subject) = value.get("subject").and_then(|v| v.as_str()) { + if subject.len() > EMAIL_SUBJECT_MAX_CHARS { + return Err(ValidationError::Completeness { + reason: format!( + "email subject is {} chars, max {EMAIL_SUBJECT_MAX_CHARS}", + subject.len() + ), + }); + } + } + + // ── PII scan on body + subject combined ── + let scanned = format!( + "{} {}", + value.get("subject").and_then(|v| v.as_str()).unwrap_or(""), + body + ); + if contains_ssn_pattern(&scanned) { + return Err(ValidationError::Policy { + reason: "body contains an SSN-shaped sequence (NNN-NN-NNNN); strip before send".into(), + }); + } + if contains_salary_disclosure(&scanned) { + return Err(ValidationError::Policy { + reason: "body discloses salary/compensation amount; staffing PII rule says strip before send".into(), + }); + } + + // ── Worker-name consistency ── + let candidate_id = value.get("_context") + .and_then(|c| c.get("candidate_id")) + .and_then(|v| v.as_str()); + let mut findings: Vec = vec![]; + if let Some(cid) = candidate_id { + match self.workers.find(cid) { + Some(worker) => { + // Body should mention the worker's name (or at least + // their first name) — drafts that address a different + // person than the contracted worker are a recurring + // class of LLM mistake. + let first = worker.name.split_whitespace().next().unwrap_or(&worker.name); + let body_lower = body.to_lowercase(); + let first_lower = first.to_lowercase(); + if !first_lower.is_empty() && !body_lower.contains(&first_lower) { + findings.push(crate::Finding { + field: "body".into(), + severity: crate::Severity::Warning, + message: format!( + "body doesn't mention worker first name {first:?} (candidate_id {cid:?})" + ), + }); + } + // Also detect *another* worker's name appearing in + // place of the contracted one — outright wrong-target. + // We can only check this when we have a different + // expected name; skip if the body is generic enough. + } + None => { + return Err(ValidationError::Consistency { + reason: format!( + "_context.candidate_id {cid:?} not found in worker roster" + ), + }); + } + } + } + + Ok(Report { + findings, + elapsed_ms: started.elapsed().as_millis() as u64, + }) + } +} + +// ─── PII scanners (std-only) ──────────────────────────────────────────── + +/// Detects an SSN-shaped sequence: 3 digits, dash, 2 digits, dash, 4 digits. +/// Walks the byte buffer; rejects sequences that are part of a longer run +/// of digits (so phone-area-code-like NNN-NNN-NNNN isn't flagged). Tight +/// false-positive surface: it's specifically the NNN-NN-NNNN shape. +fn contains_ssn_pattern(s: &str) -> bool { + let bytes = s.as_bytes(); + if bytes.len() < 11 { return false; } + for i in 0..=bytes.len().saturating_sub(11) { + let win = &bytes[i..i + 11]; + let shape = win.iter().enumerate().all(|(j, &b)| match j { + 0 | 1 | 2 | 4 | 5 | 7 | 8 | 9 | 10 => b.is_ascii_digit(), + 3 | 6 => b == b'-', + _ => unreachable!(), + }); + if !shape { continue; } + // Reject if the byte BEFORE this window is a digit or `-` — + // we're inside a longer numeric run, probably not an SSN. + if i > 0 { + let prev = bytes[i - 1]; + if prev.is_ascii_digit() || prev == b'-' { continue; } + } + // Reject if the byte AFTER is a digit or `-` (same reason). + if i + 11 < bytes.len() { + let next = bytes[i + 11]; + if next.is_ascii_digit() || next == b'-' { continue; } + } + return true; + } + false +} + +/// Detects salary/compensation disclosure: the keywords "salary", +/// "compensation", "pay rate", "bill rate", "hourly rate" appearing +/// within ~40 chars of a `$` followed by digits. Coarse on purpose — +/// it's better to false-positive on a legit phrase like "discuss your +/// hourly rate of $30/hr" than to miss it. +fn contains_salary_disclosure(s: &str) -> bool { + let lower = s.to_lowercase(); + const KEYWORDS: &[&str] = &[ + "salary", "compensation", "pay rate", "bill rate", "hourly rate", + ]; + let mut keyword_positions: Vec = vec![]; + for kw in KEYWORDS { + let mut start = 0; + while let Some(found) = lower[start..].find(kw) { + let abs = start + found; + keyword_positions.push(abs); + start = abs + kw.len(); + } + } + if keyword_positions.is_empty() { return false; } + + // Find every `$NNN+` in the text. + let bytes = lower.as_bytes(); + let mut dollar_positions: Vec = vec![]; + for (i, &b) in bytes.iter().enumerate() { + if b == b'$' && i + 1 < bytes.len() && bytes[i + 1].is_ascii_digit() { + dollar_positions.push(i); + } + } + if dollar_positions.is_empty() { return false; } + + // Any (keyword, $) pair within 40 chars triggers the policy rule. + for &kp in &keyword_positions { + for &dp in &dollar_positions { + if kp.abs_diff(dp) <= 40 { + return true; + } + } + } + false +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{InMemoryWorkerLookup, WorkerRecord}; + use serde_json::json; + + fn lookup(records: Vec) -> Arc { + Arc::new(InMemoryWorkerLookup::from_records(records)) + } + + fn worker(id: &str, name: &str) -> WorkerRecord { + WorkerRecord { + candidate_id: id.into(), + name: name.into(), + status: "active".into(), + city: None, state: None, role: None, + blacklisted_clients: vec![], + } + } + + #[test] + fn long_sms_fails_completeness() { + let v = EmailValidator::new(lookup(vec![])); + let body = "x".repeat(200); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "+15555550123", "body": body, "kind": "sms" + }))); + assert!(matches!(r, Err(ValidationError::Completeness { .. }))); + } + + #[test] + fn long_email_subject_fails_completeness() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "a@b.com", "body": "hi", "subject": "x".repeat(100) + }))); + assert!(matches!(r, Err(ValidationError::Completeness { .. }))); + } + + #[test] + fn missing_to_fails_schema() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({"body": "hi"}))); + assert!(matches!(r, Err(ValidationError::Schema { field, .. }) if field == "to")); + } + + #[test] + fn well_formed_email_passes() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "hiring@example.com", + "subject": "Interview: Friday 10am", + "body": "Hi Jane — confirming interview Friday 10am." + }))); + assert!(r.is_ok(), "well-formed email should pass: {:?}", r); + } + + #[test] + fn ssn_in_body_fails_policy() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "x@y.com", + "body": "Hi Jane — your file shows 123-45-6789 on record." + }))); + match r { + Err(ValidationError::Policy { reason }) => assert!(reason.contains("SSN")), + other => panic!("expected Policy SSN error, got {other:?}"), + } + } + + #[test] + fn ssn_in_subject_fails_policy() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "x@y.com", + "subject": "Re: ID 123-45-6789", + "body": "details inside" + }))); + assert!(matches!(r, Err(ValidationError::Policy { .. }))); + } + + #[test] + fn phone_number_does_not_trigger_ssn_false_positive() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "x@y.com", + "body": "Call me at 555-123-4567 to confirm." + }))); + assert!(r.is_ok(), "phone NNN-NNN-NNNN should NOT match SSN NNN-NN-NNNN: {:?}", r); + } + + #[test] + fn salary_disclosure_fails_policy() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "x@y.com", + "body": "Confirming your hourly rate of $32.50 per hour." + }))); + assert!(matches!(r, Err(ValidationError::Policy { .. }))); + } + + #[test] + fn discussing_dollars_without_salary_keyword_passes() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "x@y.com", + "body": "The $20 parking pass is at the front desk." + }))); + assert!(r.is_ok(), "non-salary $ should pass: {:?}", r); + } + + #[test] + fn unknown_candidate_id_fails_consistency() { + let v = EmailValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "x@y.com", + "body": "Hi Jane", + "_context": {"candidate_id": "W-FAKE"} + }))); + match r { + Err(ValidationError::Consistency { reason }) => assert!(reason.contains("not found")), + other => panic!("expected Consistency, got {other:?}"), + } + } + + #[test] + fn missing_first_name_in_body_is_warning() { + let v = EmailValidator::new(lookup(vec![worker("W-1", "Jane Doe")])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "x@y.com", + "body": "Hi there — confirming your interview Friday.", + "_context": {"candidate_id": "W-1"} + }))); + let report = r.expect("missing name should be warning, not error"); + assert_eq!(report.findings.len(), 1); + assert_eq!(report.findings[0].severity, crate::Severity::Warning); + assert!(report.findings[0].message.to_lowercase().contains("first name")); + } + + #[test] + fn matching_first_name_passes_clean() { + let v = EmailValidator::new(lookup(vec![worker("W-1", "Jane Doe")])); + let r = v.validate(&Artifact::EmailDraft(json!({ + "to": "x@y.com", + "body": "Hi Jane — confirming your interview Friday.", + "_context": {"candidate_id": "W-1"} + }))); + let report = r.expect("matching name should pass"); + assert!(report.findings.is_empty(), "expected no findings, got {:?}", report.findings); + } +} diff --git a/crates/validator/src/staffing/fill.rs b/crates/validator/src/staffing/fill.rs new file mode 100644 index 0000000..8b69804 --- /dev/null +++ b/crates/validator/src/staffing/fill.rs @@ -0,0 +1,383 @@ +//! Fill-proposal validator (Phase 43 v2 — real consistency checks). +//! +//! PRD checks: +//! - Schema compliance (propose_done shape: `{fills: [{candidate_id, name}]}`) +//! - Completeness (endorsed count == target_count) +//! - Worker existence (every candidate_id present in workers roster) +//! - Status check (worker.status == "active") +//! - Client blacklist (worker NOT in client.blacklisted_clients) +//! - Geo/role match (worker city/state/role matches contract) +//! +//! The contract metadata (target_count, city, state, role, client_id) +//! travels alongside the JSON payload under a `_context` key: +//! `{"_context": {"target_count": 2, "city": "Toledo", "state": "OH", +//! "role": "Welder", "client_id": "CLI-00099"}, "fills": [...]}`. +//! This keeps the Validator trait signature stable while letting the +//! validator cross-check fills against contract truth. +//! +//! Worker-existence + status + geo + blacklist all share a single +//! lookup trait (`WorkerLookup`) so the validator stays decoupled +//! from queryd / parquet / catalogd transport details. + +use crate::{ + Artifact, Report, Validator, ValidationError, WorkerLookup, WorkerRecord, +}; +use std::sync::Arc; +use std::time::Instant; + +pub struct FillValidator { + workers: Arc, +} + +impl FillValidator { + pub fn new(workers: Arc) -> Self { + Self { workers } + } +} + +#[derive(Debug, Default)] +struct FillContext { + target_count: Option, + city: Option, + state: Option, + role: Option, + client_id: Option, +} + +fn extract_context(value: &serde_json::Value) -> FillContext { + let ctx_obj = value.get("_context").and_then(|c| c.as_object()); + let ctx = match ctx_obj { + Some(o) => o, + None => return FillContext::default(), + }; + FillContext { + target_count: ctx.get("target_count").and_then(|v| v.as_u64()).map(|n| n as usize), + city: ctx.get("city").and_then(|v| v.as_str()).map(String::from), + state: ctx.get("state").and_then(|v| v.as_str()).map(String::from), + role: ctx.get("role").and_then(|v| v.as_str()).map(String::from), + client_id: ctx.get("client_id").and_then(|v| v.as_str()).map(String::from), + } +} + +fn eq_ci(a: &str, b: &str) -> bool { + a.trim().eq_ignore_ascii_case(b.trim()) +} + +impl Validator for FillValidator { + fn name(&self) -> &'static str { "staffing.fill" } + + fn validate(&self, artifact: &Artifact) -> Result { + let started = Instant::now(); + let value = match artifact { + Artifact::FillProposal(v) => v, + other => return Err(ValidationError::Schema { + field: "artifact".into(), + reason: format!("FillValidator expects FillProposal, got {other:?}"), + }), + }; + + // ── Schema check ── + let fills = value.get("fills").and_then(|f| f.as_array()).ok_or( + ValidationError::Schema { + field: "fills".into(), + reason: "expected top-level `fills` array".into(), + }, + )?; + for (i, fill) in fills.iter().enumerate() { + if fill.get("candidate_id").is_none() { + return Err(ValidationError::Schema { + field: format!("fills[{i}].candidate_id"), + reason: "missing".into(), + }); + } + if fill.get("name").is_none() { + return Err(ValidationError::Schema { + field: format!("fills[{i}].name"), + reason: "missing".into(), + }); + } + } + + let ctx = extract_context(value); + + // ── Completeness: count match ── + if let Some(target) = ctx.target_count { + if fills.len() != target { + return Err(ValidationError::Completeness { + reason: format!( + "endorsed count {} != target_count {target}", + fills.len() + ), + }); + } + } + + // ── Cross-roster checks ── + let mut findings: Vec = vec![]; + let mut seen_ids = std::collections::HashSet::new(); + for (i, fill) in fills.iter().enumerate() { + let candidate_id = fill.get("candidate_id").and_then(|v| v.as_str()).unwrap_or(""); + let proposed_name = fill.get("name").and_then(|v| v.as_str()).unwrap_or(""); + + // Duplicate-ID guard inside one fill. + if !seen_ids.insert(candidate_id.to_string()) { + return Err(ValidationError::Consistency { + reason: format!( + "duplicate candidate_id {candidate_id:?} appears multiple times in fills" + ), + }); + } + + // Worker existence — the gate that catches phantom IDs the + // model fabricates. This is the load-bearing check for + // the 0→85% pattern. + let worker: WorkerRecord = match self.workers.find(candidate_id) { + Some(w) => w, + None => return Err(ValidationError::Consistency { + reason: format!( + "fills[{i}].candidate_id {candidate_id:?} does not exist in worker roster" + ), + }), + }; + + // Status — only "active" workers can be endorsed. + if !eq_ci(&worker.status, "active") { + return Err(ValidationError::Consistency { + reason: format!( + "fills[{i}] worker {candidate_id:?} has status {:?}, expected \"active\"", + worker.status + ), + }); + } + + // Client blacklist. + if let Some(client) = ctx.client_id.as_deref() { + if worker.blacklisted_clients.iter().any(|b| eq_ci(b, client)) { + return Err(ValidationError::Policy { + reason: format!( + "fills[{i}] worker {candidate_id:?} blacklisted for client {client:?}" + ), + }); + } + } + + // Geo / role match — warn-level when missing context, hard + // fail on mismatch with explicit contract values. + if let (Some(want_city), Some(have_city)) = (ctx.city.as_deref(), worker.city.as_deref()) { + if !eq_ci(want_city, have_city) { + return Err(ValidationError::Consistency { + reason: format!( + "fills[{i}] worker {candidate_id:?} city {have_city:?} doesn't match contract city {want_city:?}" + ), + }); + } + } + if let (Some(want_state), Some(have_state)) = (ctx.state.as_deref(), worker.state.as_deref()) { + if !eq_ci(want_state, have_state) { + return Err(ValidationError::Consistency { + reason: format!( + "fills[{i}] worker {candidate_id:?} state {have_state:?} doesn't match contract state {want_state:?}" + ), + }); + } + } + if let (Some(want_role), Some(have_role)) = (ctx.role.as_deref(), worker.role.as_deref()) { + if !eq_ci(want_role, have_role) { + return Err(ValidationError::Consistency { + reason: format!( + "fills[{i}] worker {candidate_id:?} role {have_role:?} doesn't match contract role {want_role:?}" + ), + }); + } + } + + // Name-mismatch is a warning, not an error — recruiters + // sometimes send updated names through the proposal layer + // before the roster is updated. + if !proposed_name.is_empty() && !eq_ci(proposed_name, &worker.name) { + findings.push(crate::Finding { + field: format!("fills[{i}].name"), + severity: crate::Severity::Warning, + message: format!( + "proposed name {proposed_name:?} differs from roster name {:?} for {candidate_id:?}", + worker.name + ), + }); + } + } + + Ok(Report { + findings, + elapsed_ms: started.elapsed().as_millis() as u64, + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::InMemoryWorkerLookup; + use serde_json::json; + + fn lookup(records: Vec) -> Arc { + Arc::new(InMemoryWorkerLookup::from_records(records)) + } + + fn worker(id: &str, name: &str, status: &str, city: &str, state: &str, role: &str) -> WorkerRecord { + WorkerRecord { + candidate_id: id.into(), + name: name.into(), + status: status.into(), + city: Some(city.into()), + state: Some(state.into()), + role: Some(role.into()), + blacklisted_clients: vec![], + } + } + + #[test] + fn wrong_artifact_type_fails_schema() { + let v = FillValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::EmailDraft(json!({}))); + assert!(matches!(r, Err(ValidationError::Schema { .. }))); + } + + #[test] + fn missing_fills_array_fails_schema() { + let v = FillValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::FillProposal(json!({}))); + assert!(matches!(r, Err(ValidationError::Schema { field, .. }) if field == "fills")); + } + + #[test] + fn fill_without_candidate_id_fails() { + let v = FillValidator::new(lookup(vec![])); + let r = v.validate(&Artifact::FillProposal(json!({"fills": [{"name": "Jane"}]}))); + assert!(matches!(r, Err(ValidationError::Schema { field, .. }) if field.contains("candidate_id"))); + } + + #[test] + fn well_formed_proposal_with_real_workers_passes() { + let v = FillValidator::new(lookup(vec![ + worker("W-1", "Jane Doe", "active", "Toledo", "OH", "Welder"), + worker("W-2", "John Smith", "active", "Toledo", "OH", "Welder"), + ])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 2, "city": "Toledo", "state": "OH", "role": "Welder"}, + "fills": [ + {"candidate_id": "W-1", "name": "Jane Doe"}, + {"candidate_id": "W-2", "name": "John Smith"} + ] + }))); + assert!(r.is_ok(), "expected pass, got {:?}", r); + } + + #[test] + fn phantom_candidate_id_fails_consistency() { + let v = FillValidator::new(lookup(vec![worker("W-1", "Jane", "active", "Toledo", "OH", "Welder")])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 1, "city": "Toledo", "state": "OH", "role": "Welder"}, + "fills": [{"candidate_id": "W-FAKE-99999", "name": "Imaginary"}] + }))); + match r { + Err(ValidationError::Consistency { reason }) => assert!(reason.contains("does not exist")), + other => panic!("expected Consistency error, got {other:?}"), + } + } + + #[test] + fn inactive_worker_fails_consistency() { + let v = FillValidator::new(lookup(vec![worker("W-1", "Jane", "inactive", "Toledo", "OH", "Welder")])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 1}, + "fills": [{"candidate_id": "W-1", "name": "Jane"}] + }))); + match r { + Err(ValidationError::Consistency { reason }) => assert!(reason.contains("inactive")), + other => panic!("expected Consistency error, got {other:?}"), + } + } + + #[test] + fn wrong_city_fails_consistency() { + let v = FillValidator::new(lookup(vec![worker("W-1", "Jane", "active", "Cincinnati", "OH", "Welder")])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 1, "city": "Toledo", "state": "OH", "role": "Welder"}, + "fills": [{"candidate_id": "W-1", "name": "Jane"}] + }))); + match r { + Err(ValidationError::Consistency { reason }) => assert!(reason.to_lowercase().contains("city")), + other => panic!("expected Consistency error, got {other:?}"), + } + } + + #[test] + fn wrong_role_fails_consistency() { + let v = FillValidator::new(lookup(vec![worker("W-1", "Jane", "active", "Toledo", "OH", "Driver")])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 1, "city": "Toledo", "state": "OH", "role": "Welder"}, + "fills": [{"candidate_id": "W-1", "name": "Jane"}] + }))); + match r { + Err(ValidationError::Consistency { reason }) => assert!(reason.to_lowercase().contains("role")), + other => panic!("expected Consistency error, got {other:?}"), + } + } + + #[test] + fn count_mismatch_fails_completeness() { + let v = FillValidator::new(lookup(vec![ + worker("W-1", "Jane", "active", "Toledo", "OH", "Welder"), + ])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 2, "city": "Toledo", "state": "OH", "role": "Welder"}, + "fills": [{"candidate_id": "W-1", "name": "Jane"}] + }))); + assert!(matches!(r, Err(ValidationError::Completeness { .. }))); + } + + #[test] + fn duplicate_candidate_id_fails_consistency() { + let v = FillValidator::new(lookup(vec![ + worker("W-1", "Jane", "active", "Toledo", "OH", "Welder"), + ])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 2, "city": "Toledo", "state": "OH", "role": "Welder"}, + "fills": [ + {"candidate_id": "W-1", "name": "Jane"}, + {"candidate_id": "W-1", "name": "Jane"} + ] + }))); + match r { + Err(ValidationError::Consistency { reason }) => assert!(reason.contains("duplicate")), + other => panic!("expected Consistency error, got {other:?}"), + } + } + + #[test] + fn blacklisted_worker_fails_policy() { + let mut w = worker("W-1", "Jane", "active", "Toledo", "OH", "Welder"); + w.blacklisted_clients = vec!["CLI-00099".into()]; + let v = FillValidator::new(lookup(vec![w])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 1, "city": "Toledo", "state": "OH", "role": "Welder", "client_id": "CLI-00099"}, + "fills": [{"candidate_id": "W-1", "name": "Jane"}] + }))); + assert!(matches!(r, Err(ValidationError::Policy { .. }))); + } + + #[test] + fn name_mismatch_is_warning_not_error() { + let v = FillValidator::new(lookup(vec![ + worker("W-1", "Jane Doe", "active", "Toledo", "OH", "Welder"), + ])); + let r = v.validate(&Artifact::FillProposal(json!({ + "_context": {"target_count": 1, "city": "Toledo", "state": "OH", "role": "Welder"}, + "fills": [{"candidate_id": "W-1", "name": "Janet Doe"}] + }))); + let report = r.expect("name mismatch should be warning, not error"); + assert_eq!(report.findings.len(), 1); + assert_eq!(report.findings[0].severity, crate::Severity::Warning); + assert!(report.findings[0].message.contains("differs from roster")); + } +} diff --git a/crates/validator/src/staffing/mod.rs b/crates/validator/src/staffing/mod.rs new file mode 100644 index 0000000..dbf33ac --- /dev/null +++ b/crates/validator/src/staffing/mod.rs @@ -0,0 +1,9 @@ +//! Staffing validators — fill proposals, email/SMS drafts, sealed +//! playbooks. Phase 43 PRD: "the 0→85% pattern reproduces on real +//! staffing tasks — the iteration loop with validation in place is +//! what made small models successful." + +pub mod fill; +pub mod email; +pub mod playbook; +pub mod parquet_lookup; diff --git a/crates/validator/src/staffing/parquet_lookup.rs b/crates/validator/src/staffing/parquet_lookup.rs new file mode 100644 index 0000000..0009b98 --- /dev/null +++ b/crates/validator/src/staffing/parquet_lookup.rs @@ -0,0 +1,165 @@ +//! Production WorkerLookup backed by a workers_500k.parquet snapshot. +//! +//! Loads the full roster into memory at startup (one-shot). 500K rows +//! at ~150 bytes per WorkerRecord ≈ 75 MB resident — fine for any +//! production lakehouse process. Refresh is intentionally +//! caller-driven (call `from_parquet` again to rebuild) rather than +//! automatic — operators decide when staffing data has changed enough +//! to justify the few-second reload. +//! +//! Schema mapping (workers_500k.parquet → WorkerRecord): +//! worker_id (int64) → candidate_id = "W-{id}" +//! name (string) → name +//! role (string) → role +//! city (string) → city +//! state (string) → state +//! availability (double) → status: "active" if >0 else "inactive" +//! +//! No status column on workers_500k, so we derive from availability — +//! the floor convention used elsewhere in the lakehouse staffing +//! pipeline. Workers with availability=0.0 are treated as inactive +//! (vacation, suspended, etc.). Once the Track-A.B `_safe` view ships +//! with proper `status`, switch this loader to read it directly. +//! +//! Blacklist join is not done here — caller is expected to populate +//! `blacklisted_clients` from a separate source (Phase 43 PRD says +//! `client_blacklist` table; not yet defined). Default empty. + +use crate::{InMemoryWorkerLookup, WorkerLookup, WorkerRecord}; +use parquet::file::reader::{FileReader, SerializedFileReader}; +use parquet::record::Field; +use std::fs::File; +use std::path::Path; +use std::sync::Arc; + +#[derive(Debug, thiserror::Error)] +pub enum LookupLoadError { + #[error("opening parquet at {path}: {source}")] + Open { path: String, #[source] source: std::io::Error }, + #[error("parsing parquet at {path}: {source}")] + Parse { path: String, #[source] source: parquet::errors::ParquetError }, + #[error("missing required column {column}")] + MissingColumn { column: String }, + #[error("row {row}: {reason}")] + BadRow { row: usize, reason: String }, +} + +/// Build an `InMemoryWorkerLookup` from a workers_500k-shaped parquet +/// file. Returned as `Arc` to drop into validator +/// constructors. +pub fn load_workers_parquet(path: &Path) -> Result, LookupLoadError> { + let file = File::open(path).map_err(|e| LookupLoadError::Open { + path: path.display().to_string(), + source: e, + })?; + let reader = SerializedFileReader::new(file).map_err(|e| LookupLoadError::Parse { + path: path.display().to_string(), + source: e, + })?; + + // Validate schema covers what we need before iterating rows. + let schema = reader.metadata().file_metadata().schema(); + let column_names: Vec<&str> = schema.get_fields().iter().map(|f| f.name()).collect(); + for required in &["worker_id", "name", "role", "city", "state", "availability"] { + if !column_names.contains(required) { + return Err(LookupLoadError::MissingColumn { column: (*required).to_string() }); + } + } + + let row_iter = reader.get_row_iter(None).map_err(|e| LookupLoadError::Parse { + path: path.display().to_string(), + source: e, + })?; + + let mut records: Vec = Vec::with_capacity(reader.metadata().file_metadata().num_rows() as usize); + let mut row_idx = 0usize; + for row_result in row_iter { + let row = row_result.map_err(|e| LookupLoadError::Parse { + path: path.display().to_string(), + source: e, + })?; + let mut worker_id: Option = None; + let mut name: Option = None; + let mut role: Option = None; + let mut city: Option = None; + let mut state: Option = None; + let mut availability: f64 = 0.0; + for (col_name, field) in row.get_column_iter() { + match (col_name.as_str(), field) { + ("worker_id", Field::Long(v)) => worker_id = Some(*v), + ("worker_id", Field::Int(v)) => worker_id = Some(*v as i64), + ("name", Field::Str(v)) => name = Some(v.clone()), + ("role", Field::Str(v)) => role = Some(v.clone()), + ("city", Field::Str(v)) => city = Some(v.clone()), + ("state", Field::Str(v)) => state = Some(v.clone()), + ("availability", Field::Double(v)) => availability = *v, + ("availability", Field::Float(v)) => availability = *v as f64, + _ => { /* extra columns ignored */ } + } + } + let id = worker_id.ok_or_else(|| LookupLoadError::BadRow { + row: row_idx, + reason: "worker_id missing or non-integer".into(), + })?; + let nm = name.ok_or_else(|| LookupLoadError::BadRow { + row: row_idx, + reason: "name missing".into(), + })?; + records.push(WorkerRecord { + candidate_id: format!("W-{id}"), + name: nm, + // status derived from availability (workers_500k has no + // status column). 0.0 → inactive, >0.0 → active. + status: if availability > 0.0 { "active".into() } else { "inactive".into() }, + city, + state, + role, + blacklisted_clients: vec![], + }); + row_idx += 1; + } + + tracing::info!( + target: "validator.parquet_lookup", + rows = records.len(), + path = %path.display(), + "loaded workers parquet snapshot" + ); + + Ok(Arc::new(InMemoryWorkerLookup::from_records(records))) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::path::PathBuf; + + /// Smoke test against the live workers_500k.parquet on disk. + /// Skipped automatically if the file isn't present (CI / sparse + /// checkouts) so the test suite stays portable. + #[test] + fn load_real_workers_500k() { + let path = PathBuf::from("/home/profit/lakehouse/data/datasets/workers_500k.parquet"); + if !path.exists() { + eprintln!("skip: {} not present", path.display()); + return; + } + let lookup = load_workers_parquet(&path).expect("load"); + // Basic shape: at least one worker resolves and has the + // expected fields populated. + let probe = lookup.find("W-1"); + assert!(probe.is_some(), "W-1 should exist in 500K-row parquet"); + let w = probe.unwrap(); + assert!(!w.name.is_empty(), "name should be populated"); + assert!(w.status == "active" || w.status == "inactive"); + assert!(w.role.is_some()); + assert!(w.city.is_some()); + assert!(w.state.is_some()); + } + + #[test] + fn missing_file_returns_error() { + let r = load_workers_parquet(Path::new("/nonexistent.parquet")); + assert!(matches!(r, Err(LookupLoadError::Open { .. }))); + } +} diff --git a/crates/validator/src/staffing/playbook.rs b/crates/validator/src/staffing/playbook.rs new file mode 100644 index 0000000..0f8bb5d --- /dev/null +++ b/crates/validator/src/staffing/playbook.rs @@ -0,0 +1,134 @@ +//! Sealed playbook validator. +//! +//! PRD checks: +//! - Operation format (`fill: Role xN in City, ST`) +//! - endorsed_names non-empty, ≤ target_count × 2 +//! - fingerprint populated (Phase 25 validity window requirement) + +use crate::{Artifact, Report, Validator, ValidationError}; +use std::time::Instant; + +pub struct PlaybookValidator; + +impl Validator for PlaybookValidator { + fn name(&self) -> &'static str { "staffing.playbook" } + + fn validate(&self, artifact: &Artifact) -> Result { + let started = Instant::now(); + let value = match artifact { + Artifact::Playbook(v) => v, + other => return Err(ValidationError::Schema { + field: "artifact".into(), + reason: format!("PlaybookValidator expects Playbook, got {other:?}"), + }), + }; + + // Operation format: "fill: Role xN in City, ST" — at minimum + // we check the string-shape. Fuller grammar parse lives in + // phase 25 code where operations are structured beyond strings. + let op = value.get("operation").and_then(|v| v.as_str()).ok_or( + ValidationError::Schema { + field: "operation".into(), + reason: "missing or not a string".into(), + }, + )?; + if !op.starts_with("fill:") { + return Err(ValidationError::Schema { + field: "operation".into(), + reason: format!("expected `fill: ...` prefix, got {op:?}"), + }); + } + + let endorsed = value.get("endorsed_names").and_then(|v| v.as_array()).ok_or( + ValidationError::Schema { + field: "endorsed_names".into(), + reason: "missing or not an array".into(), + }, + )?; + if endorsed.is_empty() { + return Err(ValidationError::Completeness { + reason: "endorsed_names must be non-empty".into(), + }); + } + + if let Some(target) = value.get("target_count").and_then(|v| v.as_u64()) { + let max = (target * 2) as usize; + if endorsed.len() > max { + return Err(ValidationError::Completeness { + reason: format!( + "endorsed_names ({}) exceeds target_count × 2 ({max})", + endorsed.len() + ), + }); + } + } + + if value.get("fingerprint").and_then(|v| v.as_str()).map_or(true, |s| s.is_empty()) { + return Err(ValidationError::Schema { + field: "fingerprint".into(), + reason: "missing — required for Phase 25 validity window".into(), + }); + } + + Ok(Report { + findings: vec![], + elapsed_ms: started.elapsed().as_millis() as u64, + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn well_formed_playbook_passes() { + let r = PlaybookValidator.validate(&Artifact::Playbook(serde_json::json!({ + "operation": "fill: Welder x2 in Toledo, OH", + "endorsed_names": ["W-123", "W-456"], + "target_count": 2, + "fingerprint": "abc123" + }))); + assert!(r.is_ok(), "got {:?}", r); + } + + #[test] + fn empty_endorsed_names_fails_completeness() { + let r = PlaybookValidator.validate(&Artifact::Playbook(serde_json::json!({ + "operation": "fill: Welder x2 in Toledo, OH", + "endorsed_names": [], + "fingerprint": "abc" + }))); + assert!(matches!(r, Err(ValidationError::Completeness { .. }))); + } + + #[test] + fn overfull_endorsed_names_fails_completeness() { + let r = PlaybookValidator.validate(&Artifact::Playbook(serde_json::json!({ + "operation": "fill: Welder x1 in Toledo, OH", + "endorsed_names": ["a", "b", "c"], + "target_count": 1, + "fingerprint": "abc" + }))); + assert!(matches!(r, Err(ValidationError::Completeness { .. }))); + } + + #[test] + fn missing_fingerprint_fails_schema() { + let r = PlaybookValidator.validate(&Artifact::Playbook(serde_json::json!({ + "operation": "fill: X x1 in A, B", + "endorsed_names": ["a"] + }))); + assert!(matches!(r, Err(ValidationError::Schema { field, .. }) if field == "fingerprint")); + } + + #[test] + fn wrong_operation_prefix_fails_schema() { + let r = PlaybookValidator.validate(&Artifact::Playbook(serde_json::json!({ + "operation": "sms_draft: hello", + "endorsed_names": ["a"], + "fingerprint": "x" + }))); + assert!(matches!(r, Err(ValidationError::Schema { .. }))); + } +} diff --git a/crates/vectord/src/activation.rs b/crates/vectord/src/activation.rs new file mode 100644 index 0000000..5fd99f9 --- /dev/null +++ b/crates/vectord/src/activation.rs @@ -0,0 +1,118 @@ +//! Profile activation tracking (Phase 41 PRD). +//! +//! Phase 41 PRD called out `crates/vectord/src/activation.rs` with +//! `ActivationTracker` + background-job pattern. The activation +//! handler itself lives in `service.rs::activate_profile` (200+ lines +//! of warm-up + bucket binding that's wired to VectorState); this +//! module provides the type the PRD named and a single-flight guard +//! that satisfies the PRD gate "refuse new activation if one is +//! pending/running." +//! +//! Handler extraction (moving the body of `activate_profile` here) +//! is deliberately NOT in this commit — it's a module-structure +//! refactor, not a semantic change. When that lands, the inline +//! `tokio::spawn` in `service.rs` moves into `ActivationTracker::start` +//! and the HTTP handler shrinks to ~20 lines of validate + start + +//! respond-202. + +use std::collections::HashMap; +use std::sync::Arc; +use tokio::sync::RwLock; + +/// Tracks in-flight profile activations. The PRD's "single-flight guard" +/// lives here: callers check `is_pending` before starting a new activation +/// and register via `mark_pending` if they proceed. On completion, they +/// call `mark_complete` so the next caller can start. +/// +/// Per-profile granularity — activating profile A doesn't block B. +#[derive(Clone, Default)] +pub struct ActivationTracker { + pending: Arc>>, // profile_id → job_id +} + +impl ActivationTracker { + pub fn new() -> Self { + Self::default() + } + + /// Check if a profile has an activation already running. Returns the + /// in-flight job_id if so. Safe to call without holding a lock. + pub async fn is_pending(&self, profile_id: &str) -> Option { + self.pending.read().await.get(profile_id).cloned() + } + + /// Register a new activation as pending. Returns false if an + /// activation is already running for the same profile (caller should + /// return 409 Conflict or surface the existing job_id). Returns true + /// on successful registration. + pub async fn mark_pending(&self, profile_id: &str, job_id: &str) -> bool { + let mut guard = self.pending.write().await; + if guard.contains_key(profile_id) { + return false; + } + guard.insert(profile_id.to_string(), job_id.to_string()); + true + } + + /// Remove the pending marker when activation finishes (success OR + /// failure — both free the slot for the next caller). + pub async fn mark_complete(&self, profile_id: &str) { + self.pending.write().await.remove(profile_id); + } + + /// How many activations are currently in-flight across all profiles. + pub async fn in_flight_count(&self) -> usize { + self.pending.read().await.len() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn empty_tracker_has_no_pending() { + let t = ActivationTracker::new(); + assert_eq!(t.in_flight_count().await, 0); + assert!(t.is_pending("any-profile").await.is_none()); + } + + #[tokio::test] + async fn mark_pending_registers_the_job() { + let t = ActivationTracker::new(); + assert!(t.mark_pending("profile-A", "job-1").await); + assert_eq!(t.in_flight_count().await, 1); + assert_eq!(t.is_pending("profile-A").await, Some("job-1".into())); + } + + #[tokio::test] + async fn single_flight_guard_refuses_second_activation_same_profile() { + // PRD Phase 41 gate: "refuse new activation if one is + // pending/running." Same profile twice → second call returns + // false, caller must surface the in-flight job_id. + let t = ActivationTracker::new(); + assert!(t.mark_pending("profile-A", "job-1").await); + assert!(!t.mark_pending("profile-A", "job-2").await); + // Still the first job — second registration didn't overwrite. + assert_eq!(t.is_pending("profile-A").await, Some("job-1".into())); + } + + #[tokio::test] + async fn different_profiles_dont_block_each_other() { + // Per-profile granularity — activating A doesn't block B. + let t = ActivationTracker::new(); + assert!(t.mark_pending("profile-A", "job-1").await); + assert!(t.mark_pending("profile-B", "job-2").await); + assert_eq!(t.in_flight_count().await, 2); + } + + #[tokio::test] + async fn mark_complete_frees_the_slot() { + let t = ActivationTracker::new(); + t.mark_pending("profile-A", "job-1").await; + t.mark_complete("profile-A").await; + assert_eq!(t.in_flight_count().await, 0); + // Next activation can now proceed. + assert!(t.mark_pending("profile-A", "job-2").await); + } +} diff --git a/crates/vectord/src/index_registry.rs b/crates/vectord/src/index_registry.rs index cc94139..d7d2d9b 100644 --- a/crates/vectord/src/index_registry.rs +++ b/crates/vectord/src/index_registry.rs @@ -46,6 +46,21 @@ pub struct IndexMeta { /// Existing indexes: "W-", "CAND-", "W500K-", etc. #[serde(default)] pub id_prefix: Option, + /// PRD 11.3 — when this index was last searched against. `None` = + /// never used since registration (or pre-field-existed metadata). + /// Incremental re-embed walks this to skip cold indexes. + /// Scrum iter 11 flagged the missing field as a UnitMismatch + /// because callers were reading `created_at` as a proxy for + /// liveness, which conflated "built" with "used." + #[serde(default)] + pub last_used: Option>, + /// PRD 11.3 — SHA-256 of (sorted source file list + chunk_size + + /// overlap + model_version). Lets incremental re-embed detect + /// "no change since last build" without scanning the source + /// Parquet. None = signature not computed yet (pre-existing + /// indexes before this field landed). + #[serde(default)] + pub build_signature: Option, } fn default_bucket() -> String { "primary".to_string() } @@ -128,4 +143,139 @@ impl IndexRegistry { self.indexes.write().await.remove(index_name); Ok(()) } + + /// Stamp `last_used = now()` on an index. Search handlers call this + /// on every hit so incremental re-embed (PRD 11.3) can tell live + /// indexes from cold ones. Silently no-ops if the index is unknown + /// — callers get best-effort behavior, not a 500 on a missing row. + pub async fn touch_used(&self, index_name: &str) { + if let Some(m) = self.indexes.write().await.get_mut(index_name) { + m.last_used = Some(Utc::now()); + } + } +} + +/// Compute a stable build_signature for PRD 11.3 incremental re-embed. +/// Hashes (sorted source file list, chunk_size, overlap, model_version) +/// so a caller can ask "has anything we built from changed?" without +/// re-scanning the source parquet. Same inputs always produce the +/// same hash. +pub fn compute_build_signature( + source_files: &[impl AsRef], + chunk_size: usize, + overlap: usize, + model_version: &str, +) -> String { + use sha2::{Digest, Sha256}; + let mut sorted: Vec<&str> = source_files.iter().map(|s| s.as_ref()).collect(); + sorted.sort(); + let mut hasher = Sha256::new(); + for f in &sorted { + hasher.update(f.as_bytes()); + hasher.update(b"\n"); + } + hasher.update(chunk_size.to_le_bytes()); + hasher.update(overlap.to_le_bytes()); + hasher.update(model_version.as_bytes()); + format!("{:x}", hasher.finalize()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn build_signature_is_deterministic() { + let sig1 = compute_build_signature(&["a.parquet", "b.parquet"], 800, 80, "v1"); + let sig2 = compute_build_signature(&["a.parquet", "b.parquet"], 800, 80, "v1"); + assert_eq!(sig1, sig2, "same inputs → same hash"); + } + + #[test] + fn build_signature_order_invariant() { + // Files get sorted internally so caller's order doesn't matter. + let sig_a = compute_build_signature(&["a.parquet", "b.parquet"], 800, 80, "v1"); + let sig_b = compute_build_signature(&["b.parquet", "a.parquet"], 800, 80, "v1"); + assert_eq!(sig_a, sig_b, "file list order must not affect hash"); + } + + #[test] + fn build_signature_changes_on_chunk_param() { + let sig_a = compute_build_signature(&["a.parquet"], 800, 80, "v1"); + let sig_b = compute_build_signature(&["a.parquet"], 900, 80, "v1"); + assert_ne!(sig_a, sig_b, "chunk_size change → different hash"); + } + + #[test] + fn build_signature_changes_on_model_version() { + let sig_a = compute_build_signature(&["a.parquet"], 800, 80, "v1"); + let sig_b = compute_build_signature(&["a.parquet"], 800, 80, "v2"); + assert_ne!(sig_a, sig_b, "model version change → different hash"); + } + + #[tokio::test] + async fn touch_used_updates_last_used() { + use object_store::memory::InMemory; + let store: Arc = Arc::new(InMemory::new()); + let reg = IndexRegistry::new(store); + let meta = IndexMeta { + index_name: "test".into(), + source: "s".into(), + model_name: "m".into(), + model_version: "v1".into(), + dimensions: 768, + chunk_count: 0, + doc_count: 0, + chunk_size: 800, + overlap: 80, + storage_key: "k".into(), + created_at: Utc::now(), + build_time_secs: 0.0, + chunks_per_sec: 0.0, + bucket: "primary".into(), + vector_backend: Default::default(), + id_prefix: None, + last_used: None, + build_signature: None, + }; + reg.register(meta).await.unwrap(); + assert!(reg.get("test").await.unwrap().last_used.is_none()); + reg.touch_used("test").await; + assert!(reg.get("test").await.unwrap().last_used.is_some()); + } + + #[tokio::test] + async fn touch_used_is_noop_on_missing_index() { + use object_store::memory::InMemory; + let store: Arc = Arc::new(InMemory::new()); + let reg = IndexRegistry::new(store); + // No panic — unknown index just doesn't get touched. + reg.touch_used("nonexistent").await; + } + + #[test] + fn index_meta_deserializes_without_new_fields_backcompat() { + // Pre-field-existence metadata files on disk must still load. + // Critical — we have ~40 .json meta files under vectors/meta/ + // that predate these fields. + let json = r#"{ + "index_name": "resumes_v1", + "source": "resumes", + "model_name": "nomic-embed-text", + "model_version": "latest", + "dimensions": 768, + "chunk_count": 100, + "doc_count": 10, + "chunk_size": 800, + "overlap": 80, + "storage_key": "vectors/resumes_v1.parquet", + "created_at": "2026-04-20T00:00:00Z", + "build_time_secs": 1.0, + "chunks_per_sec": 100.0 + }"#; + let meta: IndexMeta = serde_json::from_str(json).expect("must deserialize pre-field meta"); + assert!(meta.last_used.is_none()); + assert!(meta.build_signature.is_none()); + assert_eq!(meta.bucket, "primary"); + } } diff --git a/crates/vectord/src/lib.rs b/crates/vectord/src/lib.rs index c937fc5..6416af5 100644 --- a/crates/vectord/src/lib.rs +++ b/crates/vectord/src/lib.rs @@ -7,7 +7,9 @@ pub mod harness; pub mod hnsw; pub mod index_registry; pub mod jobs; +pub mod activation; pub mod playbook_memory; +pub mod pathway_memory; pub mod doc_drift; pub mod promotion; pub mod refresh; diff --git a/crates/vectord/src/pathway_memory.rs b/crates/vectord/src/pathway_memory.rs new file mode 100644 index 0000000..603dfa4 --- /dev/null +++ b/crates/vectord/src/pathway_memory.rs @@ -0,0 +1,1354 @@ +//! Pathway memory — full backtrack-able context for scrum/auditor reviews. +//! +//! Consensus-designed (10-probe N=3 ensemble, see +//! `data/_kb/consensus_reducer_design_*.json`). The reducer emits a +//! `PathwayTrace` sidecar alongside its legacy summary. Traces are +//! fingerprinted narrowly (`task_class + file_prefix + signal_class`) for +//! generalizing hot-swap, and embedded via normalized-metadata-token +//! concatenation so the HNSW similarity search can discriminate between +//! pathways that share a fingerprint but diverged in ladder/KB choices. +//! +//! The hot-swap decision requires four conditions in AND: +//! 1. narrow fingerprint match +//! 2. audit_consensus.pass == true +//! 3. replay_count >= 3 +//! 4. replays_succeeded / replay_count >= 0.80 +//! 5. NOT retired +//! 6. similarity(new, stored) >= 0.90 +//! +//! Any replay reports its outcome via `record_replay_outcome`; pathways +//! whose success rate drops below 0.80 after >=3 replays are marked +//! retired and excluded from further hot-swap consideration. This is the +//! self-correcting learning loop — a pathway that worked once but breaks +//! under distribution shift removes itself automatically. + +use std::collections::HashMap; +use std::sync::Arc; + +use chrono::{DateTime, Utc}; +use object_store::ObjectStore; +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; +use storaged::ops; +use tokio::sync::RwLock; + +const STATE_KEY: &str = "_pathway_memory/state.json"; + +/// Outcome of one ladder rung attempt. Captured for every attempt, +/// regardless of whether it was accepted — rejections are signal too. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct LadderAttempt { + pub rung: u8, + pub model: String, + pub latency_ms: u64, + pub accepted: bool, + pub reject_reason: Option, +} + +/// Provenance of a RAG chunk retrieved for this review. The +/// `cosine_score` is the similarity as returned by the index; `rank` is +/// 0-indexed order in the top-K result list. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct KbChunkRef { + pub source_doc: String, + pub chunk_id: String, + pub cosine_score: f32, + pub rank: u8, +} + +/// Signal emitted by mcp-server/observer classifier. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct ObserverSignal { + pub class: String, + pub priors: Vec, + pub prior_iter_outcomes: Vec, +} + +/// Context7-bridge lookup snapshot. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct BridgeHit { + pub library: String, + pub version: String, +} + +/// Call to LLM Team (/api/run?mode=extract) or auditor N=3 consensus. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct SubPipelineCall { + pub pipeline: String, // "llm_team_extract" / "audit_consensus" / etc. + pub result_summary: String, +} + +/// N=3 independent consensus re-check result. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct AuditConsensus { + pub pass: bool, + pub models: Vec, + pub disagreements: u32, +} + +// ─── ADR-021: Semantic correctness layer ──────────────────────────── +// +// SemanticFlag names the CATEGORY of bug found. Scrum reviewer attaches +// these to findings (via prompt instruction to tag); the matrix index +// uses them for "same crate has seen N unit mismatches" preemption. +// +// Discipline: extend this enum only when a real bug is found that +// doesn't fit an existing variant. Avoid the "add a vague variant just +// in case" anti-pattern — it dilutes the grammar the index learns from. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)] +#[serde(tag = "kind")] +pub enum SemanticFlag { + /// Operation combines values with different units (e.g. + /// `row_count - file_count`, `bytes - rows`). Instance that motivated + /// ADR-021: queryd/delta.rs base_rows = pre_filter_rows - delta_count. + UnitMismatch, + /// Same type, wrong role (e.g. treating a PK as a row index). + TypeConfusion, + /// Unwrap-without-check or nullable-treated-as-non-null paths. + NullableConfusion, + /// Off-by-one in loops / ranges / slice bounds. + OffByOne, + /// Reference to a deprecated / removed / moved symbol that the + /// compiler hasn't flagged (trait method shadowing, feature flags). + StaleReference, + /// Pseudo-implementation: stub body, `todo!()`, or function named + /// for work it doesn't actually do. Distinct from DeadCode — pseudo + /// is CALLED but doesn't do its job. + PseudoImpl, + /// Unreachable or uncalled code that compiles but serves no purpose. + DeadCode, + /// Code compiles green but emits a warning the workspace baseline + /// didn't have. The applier's new-warning gate already catches these + /// at commit time; flagging at review time lets the matrix index + /// surface "this file area tends to produce warning noise." + WarningNoise, + /// Operation crosses a layer/crate boundary it shouldn't (e.g. a + /// hot-path function calling a cloud API, or a catalog op mutating + /// storage directly). + BoundaryViolation, +} + +/// What schema/type context was surfaced to the reviewer when this +/// pathway was produced. Empty = bootstrap path (reviewer got no +/// type context); populated = we fed the model typed info to work with. +/// Drift in this field over time is the feedback signal for "are we +/// getting smarter at enriching prompts?" +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct TypeHint { + /// Where the hint came from: "catalogd" | "arrow_schema" | + /// "rust_struct" | "truth_rule" | "manual". + pub source: String, + /// The identifier being typed (field name, variable, column). + pub symbol: String, + /// The type as extracted (stringly-typed is fine — this is a + /// retrieval key, not a compiler representation). + pub type_repr: String, +} + +/// Stable hash of a bug pattern. Used by the matrix index to retrieve +/// "similar-shaped bugs" across files. The `pattern_key` is the field +/// that's semantically load-bearing; `occurrences` is how many times +/// this exact signature has appeared in this pathway's file history. +/// `example` is one representative code snippet so the prompt can +/// quote it back to future reviewers. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct BugFingerprint { + pub flag: SemanticFlag, + /// SHA256 of the structural pattern (e.g. for UnitMismatch: + /// `"row_count-file_count"` → its hash). Stable across minor + /// token-level variation so the same bug shape clusters. + pub pattern_key: String, + pub example: String, + pub occurrences: u32, +} + +/// Full backtrack-able context for one reviewed file. Lives alongside +/// the reducer's summary — summary is what the reviewer LLM sees, this +/// is what the auditor / future iterations / hot-swap use. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +pub struct PathwayTrace { + pub pathway_id: String, // SHA256(task_class|file_prefix|signal_class) + pub task_class: String, + pub file_path: String, + pub signal_class: Option, + pub created_at: DateTime, + + pub ladder_attempts: Vec, + pub kb_chunks: Vec, + pub observer_signals: Vec, + pub bridge_hits: Vec, + pub sub_pipeline_calls: Vec, + pub audit_consensus: Option, + + pub reducer_summary: String, + pub final_verdict: String, + + /// Normalized-metadata-token embedding. Dimension fixed per index + /// version (current: 32, sufficient to distinguish task/file/signal + /// combinations without requiring an external embedding model — + /// round-3 consensus said "small metadata tokens", not "full JSON"). + pub pathway_vec: Vec, + + /// Number of times this pathway has been replayed via hot-swap. + /// Replay only begins after first insert; initial insert itself is + /// NOT a replay. Probation of ≥3 replays is required before the + /// success-rate gate can fire. + pub replay_count: u32, + pub replays_succeeded: u32, + /// ADR-021 semantic-correctness layer. Populated by scrum reviewer + /// via explicit prompt-level tagging of findings. Empty on existing + /// traces (pre-ADR-021 inserts); additive field so back-compat + /// deserialization works via serde default. + #[serde(default)] + pub semantic_flags: Vec, + /// Schema/type context fed to the reviewer during this pathway's + /// review. Starts empty (bootstrap); fills as we wire catalogd + + /// arrow_schema + truth_rule enrichment into the prompt pipeline. + #[serde(default)] + pub type_hints_used: Vec, + /// Bug patterns caught on this file/pathway — the matrix index's + /// retrieval key for "have we seen this shape here before?" + #[serde(default)] + pub bug_fingerprints: Vec, + + /// Marked true when replay_count >= 3 AND success_rate < 0.80. + /// Retired pathways are excluded from hot-swap forever. (If the + /// underlying file / task / signal characteristics genuinely change + /// such that a retired pathway would work again, a new PathwayTrace + /// with a fresh id will be inserted — retirement is per-id.) + pub retired: bool, + + // ─── Mem0 versioning + deletion (J 2026-04-25 directive, mirrors + // playbook_memory's Phase 25/27 patterns) ─── + /// UUID for THIS specific trace. pathway_id is the bucket key + /// (shared by traces of the same task/file_prefix/signal); trace_uid + /// addresses an individual trace within that bucket so retire/revise + /// can target it precisely. Empty on legacy traces; populated by + /// upsert/insert callers (or filled with a generated UUID on insert). + #[serde(default)] + pub trace_uid: String, + /// Mem0-style version chain. v1 for original traces; bumped on + /// `revise()`. Legacy traces deserialize as version=1 via default. + #[serde(default = "default_version")] + pub version: u32, + /// trace_uid of the trace this one supersedes (None = root version). + #[serde(default)] + pub parent_trace_uid: Option, + /// Set when a newer version supersedes this trace. Excluded from + /// retrieval (hot-swap, bug_fingerprints_for) once set. + #[serde(default)] + pub superseded_at: Option, + /// trace_uid of the new version. Pairs with superseded_at. + #[serde(default)] + pub superseded_by_trace_uid: Option, + /// Human-readable reason recorded with retire(). Pairs with + /// `retired: true`. Empty on probation-driven retirements (those + /// just set retired=true without a textual reason). + #[serde(default)] + pub retirement_reason: Option, +} + +fn default_version() -> u32 { 1 } + +impl PathwayTrace { + /// Compute the narrow fingerprint id from task_class + file_prefix + /// + signal_class. `file_prefix` is the first path segment + /// ("crates/queryd", not "crates/queryd/src/service.rs") so that + /// related files in the same crate share pathways. + pub fn compute_id(task_class: &str, file_path: &str, signal_class: Option<&str>) -> String { + let prefix = file_prefix(file_path); + let sig = signal_class.unwrap_or(""); + let mut hasher = Sha256::new(); + hasher.update(task_class.as_bytes()); + hasher.update(b"|"); + hasher.update(prefix.as_bytes()); + hasher.update(b"|"); + hasher.update(sig.as_bytes()); + format!("{:x}", hasher.finalize()) + } + + pub fn success_rate(&self) -> f32 { + if self.replay_count == 0 { + return 0.0; + } + self.replays_succeeded as f32 / self.replay_count as f32 + } +} + +/// First two path segments, so `crates/queryd/src/service.rs` → +/// `crates/queryd`. This is intentional — similar files in the same +/// crate often share task characteristics (e.g., all files in +/// `crates/queryd/` are SQL-path Rust code), so fingerprinting on the +/// crate-level prefix lets the hot-swap generalize across files within +/// the crate. Exactly-matching file paths still match (same prefix). +pub fn file_prefix(path: &str) -> String { + let parts: Vec<&str> = path.split('/').take(2).collect(); + parts.join("/") +} + +/// Build the pathway vector from trace metadata. Intentionally simple — +/// deterministic bag-of-tokens hash into 32 buckets, normalized. Round-3 +/// consensus said "small metadata tokens, not full JSON." An external +/// embedding model would work too but adds a dependency, failure mode, +/// and drift risk the consensus flagged. +pub fn build_pathway_vec(trace: &PathwayTrace) -> Vec { + let mut buckets = vec![0f32; 32]; + let mut tokens: Vec = Vec::new(); + tokens.push(trace.task_class.clone()); + tokens.push(trace.file_path.clone()); + if let Some(s) = &trace.signal_class { + tokens.push(format!("signal:{s}")); + } + for a in &trace.ladder_attempts { + tokens.push(format!("rung:{}", a.rung)); + tokens.push(format!("model:{}", a.model)); + tokens.push(format!("accepted:{}", a.accepted)); + } + for k in &trace.kb_chunks { + tokens.push(format!("kb:{}", k.source_doc)); + } + for o in &trace.observer_signals { + tokens.push(format!("class:{}", o.class)); + } + for b in &trace.bridge_hits { + tokens.push(format!("lib:{}", b.library)); + } + for s in &trace.sub_pipeline_calls { + tokens.push(format!("pipeline:{}", s.pipeline)); + } + // ADR-021: include semantic flags + bug fingerprints in the + // embedding so pathways with the same narrow fingerprint but + // different bug histories cluster separately. "This file has + // had 3 unit mismatches" is a different pathway from "this file + // is clean" — similarity gate should see them as distinct. + for f in &trace.semantic_flags { + tokens.push(format!("flag:{:?}", f)); + } + for bp in &trace.bug_fingerprints { + tokens.push(format!("bug:{:?}:{}", bp.flag, bp.pattern_key)); + } + + for t in &tokens { + let mut h = Sha256::new(); + h.update(t.as_bytes()); + let d = h.finalize(); + // Two bucket writes per token: use different byte windows to + // spread probability across buckets even when tokens share a + // common prefix. + let b1 = (d[0] as usize) % 32; + let b2 = (d[8] as usize) % 32; + buckets[b1] += 1.0; + buckets[b2] += 1.0; + } + + // L2 normalize so cosine similarity becomes a dot product. + let norm: f32 = buckets.iter().map(|v| v * v).sum::().sqrt(); + if norm > 0.0 { + for v in &mut buckets { + *v /= norm; + } + } + buckets +} + +pub fn cosine(a: &[f32], b: &[f32]) -> f32 { + if a.len() != b.len() { + return 0.0; + } + a.iter().zip(b.iter()).map(|(x, y)| x * y).sum::() +} + +#[derive(Default, Clone, Serialize, Deserialize)] +struct PathwayMemoryState { + pathways: HashMap>, // key = pathway_id (narrow fingerprint) + last_updated_at: i64, +} + +#[derive(Clone)] +pub struct PathwayMemory { + state: Arc>, + store: Arc, +} + +#[derive(Debug, Serialize)] +pub struct HotSwapCandidate { + pub pathway_id: String, + /// trace_uid of the SPECIFIC trace this hot-swap recommendation + /// came from. Lets a caller call /pathway/retire with single-trace + /// precision when observer rejects the result — the audit-consensus + /// → retire wire (HANDOVER §queued, ADR-021). + pub trace_uid: String, + pub similarity: f32, + pub replay_count: u32, + pub success_rate: f32, + pub recommended_rung: u8, + pub recommended_model: String, +} + +/// Mem0-style outcome of an upsert. Mirrors playbook_memory::UpsertOutcome +/// but adapts the UPDATE semantic to PathwayTrace's bucket model: there +/// is no notion of merging endorsed_names — each trace is an immutable +/// run record. UPDATE here means "we found a non-retired non-superseded +/// trace with the same workflow shape; bumped its replay_count instead +/// of appending a duplicate." NOOP is reserved for the case where the +/// caller asked for an upsert that would change nothing observable. +#[derive(Debug, Serialize)] +pub enum PathwayUpsertOutcome { + Added { pathway_id: String, trace_uid: String }, + Updated { pathway_id: String, trace_uid: String, replay_count: u32 }, + Noop { pathway_id: String, trace_uid: String }, +} + +/// Mem0-style outcome of revise — chains versions across traces. +#[derive(Debug, Serialize)] +pub struct PathwayReviseOutcome { + pub parent_trace_uid: String, + pub parent_version: u32, + pub new_trace_uid: String, + pub new_version: u32, + pub superseded_at: String, +} + +/// Compute a stable fingerprint for upsert dedup. Captures the +/// workflow shape: the sequence of (rung, model) pairs from +/// ladder_attempts, plus the final_verdict. Two traces with the same +/// fingerprint represent the same proven approach on the same task — +/// don't store duplicates. +fn workflow_fingerprint(trace: &PathwayTrace) -> String { + let mut h = Sha256::new(); + h.update(trace.final_verdict.as_bytes()); + h.update(b"|"); + for a in &trace.ladder_attempts { + h.update(a.model.as_bytes()); + h.update(b":"); + h.update(a.rung.to_string().as_bytes()); + h.update(b";"); + } + format!("{:x}", h.finalize()) +} + +impl PathwayMemory { + pub fn new(store: Arc) -> Self { + Self { + state: Arc::new(RwLock::new(PathwayMemoryState::default())), + store, + } + } + + pub async fn load_from_storage(&self) -> Result { + let data = match ops::get(&self.store, STATE_KEY).await { + Ok(d) => d, + Err(_) => return Ok(0), + }; + let persisted: PathwayMemoryState = serde_json::from_slice(&data) + .map_err(|e| format!("parse pathway_memory state: {e}"))?; + let n: usize = persisted.pathways.values().map(|v| v.len()).sum(); + *self.state.write().await = persisted; + tracing::info!("pathway_memory: loaded {n} traces from {STATE_KEY}"); + Ok(n) + } + + async fn persist(&self) -> Result<(), String> { + let snapshot = self.state.read().await.clone(); + let bytes = serde_json::to_vec_pretty(&snapshot).map_err(|e| e.to_string())?; + ops::put(&self.store, STATE_KEY, bytes.into()).await + } + + /// Insert a new pathway trace. Called by scrum_master_pipeline at + /// the end of each file's review. Computes the pathway_vec from + /// metadata if the caller didn't supply one. Appends to the bucket + /// for this pathway_id — multiple traces can share a fingerprint + /// (each represents one review of the same file/task/signal combo). + pub async fn insert(&self, mut trace: PathwayTrace) -> Result<(), String> { + if trace.pathway_vec.is_empty() { + trace.pathway_vec = build_pathway_vec(&trace); + } + if trace.trace_uid.is_empty() { + trace.trace_uid = uuid::Uuid::new_v4().to_string(); + } + if trace.version == 0 { trace.version = 1; } + let mut s = self.state.write().await; + s.pathways + .entry(trace.pathway_id.clone()) + .or_default() + .push(trace); + s.last_updated_at = Utc::now().timestamp_millis(); + drop(s); + self.persist().await + } + + /// Mem0-style upsert. ADD if no existing live trace in the bucket + /// matches this trace's workflow fingerprint. UPDATE (bump + /// replay_count) if a match exists. NOOP semantically equivalent + /// to UPDATE here — kept for symmetry with playbook_memory and + /// future-proofing if we add merge logic. + /// + /// "Live" means: not retired, not superseded. + /// + /// Replaces raw `insert` for callers that want dedup. Existing + /// `insert` callers (scrum_master) keep raw-append semantics so + /// behavior is back-compat. + pub async fn upsert(&self, mut trace: PathwayTrace) -> Result { + if trace.pathway_vec.is_empty() { + trace.pathway_vec = build_pathway_vec(&trace); + } + if trace.trace_uid.is_empty() { + trace.trace_uid = uuid::Uuid::new_v4().to_string(); + } + if trace.version == 0 { trace.version = 1; } + let new_fp = workflow_fingerprint(&trace); + + let mut s = self.state.write().await; + let bucket = s.pathways.entry(trace.pathway_id.clone()).or_default(); + // Find a live trace (not retired, not superseded) with same workflow. + let mut existing_idx: Option = None; + for (i, t) in bucket.iter().enumerate() { + if t.retired { continue; } + if t.superseded_at.is_some() { continue; } + if workflow_fingerprint(t) == new_fp { + existing_idx = Some(i); + break; + } + } + let pathway_id = trace.pathway_id.clone(); + + let outcome = match existing_idx { + None => { + let trace_uid = trace.trace_uid.clone(); + bucket.push(trace); + PathwayUpsertOutcome::Added { pathway_id, trace_uid } + } + Some(i) => { + // UPDATE: bump replay counters on the existing trace + // instead of duplicating. Replays_succeeded only bumps + // on accepted final_verdict (mirror record_replay logic). + let existing = &mut bucket[i]; + existing.replay_count = existing.replay_count.saturating_add(1); + if trace.final_verdict == "accepted" { + existing.replays_succeeded = existing.replays_succeeded.saturating_add(1); + } + PathwayUpsertOutcome::Updated { + pathway_id, + trace_uid: existing.trace_uid.clone(), + replay_count: existing.replay_count, + } + } + }; + s.last_updated_at = Utc::now().timestamp_millis(); + drop(s); + self.persist().await?; + Ok(outcome) + } + + /// Mem0-style retire. Marks a specific trace (by trace_uid) retired + /// with a human-readable reason. Retired traces are excluded from + /// hot-swap and bug_fingerprints retrieval. Idempotent: retiring an + /// already-retired trace returns Ok(false) without modification. + pub async fn retire(&self, trace_uid: &str, reason: &str) -> Result { + let mut touched = false; + { + let mut s = self.state.write().await; + 'outer: for traces in s.pathways.values_mut() { + for t in traces.iter_mut() { + if t.trace_uid == trace_uid && !t.retired { + t.retired = true; + t.retirement_reason = Some(reason.to_string()); + touched = true; + break 'outer; + } + } + } + if touched { + s.last_updated_at = Utc::now().timestamp_millis(); + } + } + if touched { self.persist().await?; } + Ok(touched) + } + + /// Mem0-style revise. Supersedes parent trace, chains the new + /// version. New version inherits parent_trace_uid; parent gets + /// superseded_at + superseded_by_trace_uid stamped. Rejects if + /// parent is retired or already superseded (revise the tip, not + /// the middle of the chain). + pub async fn revise( + &self, + parent_trace_uid: &str, + mut new_trace: PathwayTrace, + ) -> Result { + let now = Utc::now().to_rfc3339(); + if new_trace.pathway_vec.is_empty() { + new_trace.pathway_vec = build_pathway_vec(&new_trace); + } + if new_trace.trace_uid.is_empty() { + new_trace.trace_uid = uuid::Uuid::new_v4().to_string(); + } + + let mut s = self.state.write().await; + // Locate parent across all buckets + let mut parent_loc: Option<(String, usize)> = None; + for (bucket_key, traces) in s.pathways.iter() { + for (i, t) in traces.iter().enumerate() { + if t.trace_uid == parent_trace_uid { + parent_loc = Some((bucket_key.clone(), i)); + break; + } + } + if parent_loc.is_some() { break; } + } + let (parent_bucket, parent_idx) = parent_loc + .ok_or_else(|| format!("parent trace_uid '{parent_trace_uid}' not found"))?; + + // Validate parent state + { + let parent = &s.pathways[&parent_bucket][parent_idx]; + if parent.retired { + return Err(format!( + "cannot revise retired trace '{parent_trace_uid}' — retirement is terminal" + )); + } + if parent.superseded_at.is_some() { + return Err(format!( + "trace '{parent_trace_uid}' already superseded; revise the tip of the chain" + )); + } + } + + let parent_version = s.pathways[&parent_bucket][parent_idx].version; + let new_version = parent_version.saturating_add(1); + let new_uid = new_trace.trace_uid.clone(); + + new_trace.version = new_version; + new_trace.parent_trace_uid = Some(parent_trace_uid.to_string()); + new_trace.superseded_at = None; + new_trace.superseded_by_trace_uid = None; + + // Stamp parent + { + let parent_mut = &mut s.pathways.get_mut(&parent_bucket).unwrap()[parent_idx]; + parent_mut.superseded_at = Some(now.clone()); + parent_mut.superseded_by_trace_uid = Some(new_uid.clone()); + } + + // Append new version (same bucket if same pathway_id) + s.pathways + .entry(new_trace.pathway_id.clone()) + .or_default() + .push(new_trace); + + s.last_updated_at = Utc::now().timestamp_millis(); + drop(s); + self.persist().await?; + + Ok(PathwayReviseOutcome { + parent_trace_uid: parent_trace_uid.to_string(), + parent_version, + new_trace_uid: new_uid, + new_version, + superseded_at: now, + }) + } + + /// Walk the version chain containing trace_uid. Returns root→tip. + /// Empty if trace_uid not found. Cycle-safe. + pub async fn history(&self, trace_uid: &str) -> Vec { + let s = self.state.read().await; + // Build trace_uid → trace map across all buckets + let mut by_uid: HashMap = HashMap::new(); + for traces in s.pathways.values() { + for t in traces { + if !t.trace_uid.is_empty() { + by_uid.insert(t.trace_uid.clone(), t.clone()); + } + } + } + let Some(seed) = by_uid.get(trace_uid).cloned() else { + return Vec::new(); + }; + // Walk back to root + let mut visited: std::collections::HashSet = std::collections::HashSet::new(); + let mut root = seed.clone(); + while let Some(parent_id) = root.parent_trace_uid.clone() { + if !visited.insert(parent_id.clone()) { break; } + match by_uid.get(&parent_id) { + Some(p) => root = p.clone(), + None => break, + } + } + // Walk forward to tip + let mut chain = vec![root.clone()]; + let mut visited_fwd: std::collections::HashSet = std::collections::HashSet::new(); + visited_fwd.insert(root.trace_uid.clone()); + let mut current = root; + while let Some(succ) = current.superseded_by_trace_uid.clone() { + if !visited_fwd.insert(succ.clone()) { break; } + match by_uid.get(&succ) { + Some(n) => { + chain.push(n.clone()); + current = n.clone(); + } + None => break, + } + } + chain + } + + /// Query for a hot-swap candidate. Returns `None` if no eligible + /// pathway exists — caller should run the full ladder. Returns + /// `Some(cand)` if all gates pass — caller can short-circuit to + /// `cand.recommended_rung` / `cand.recommended_model`. + /// + /// Gates (all must hold): + /// - narrow fingerprint match (same task/file_prefix/signal) + /// - audit_consensus.pass == true on the stored trace + /// - replay_count >= 3 (probation) + /// - success_rate >= 0.80 + /// - NOT retired + /// - similarity(query_vec, stored.pathway_vec) >= 0.90 + pub async fn query_hot_swap( + &self, + task_class: &str, + file_path: &str, + signal_class: Option<&str>, + query_vec: &[f32], + ) -> Option { + let id = PathwayTrace::compute_id(task_class, file_path, signal_class); + let s = self.state.read().await; + let candidates = s.pathways.get(&id)?; + let mut best: Option<(f32, &PathwayTrace)> = None; + for p in candidates { + if p.retired { + continue; + } + // Mem0 versioning: superseded traces are excluded from + // retrieval — only the tip of each version chain counts. + if p.superseded_at.is_some() { + continue; + } + // audit_consensus gate: explicit FAIL blocks hot-swap. A null + // audit_consensus (auditor hasn't seen this pathway yet) is + // NOT a block — the success_rate gate below still requires + // ≥3 real-world replays at ≥80% success before a pathway + // becomes hot-swap eligible, so the learning loop itself + // provides the safety net during bootstrap. Once the auditor + // pipeline wires pathway audit updates, this gate tightens + // automatically: any explicit audit_consensus.pass == false + // here will skip the candidate. + if let Some(ac) = &p.audit_consensus { + if !ac.pass { + continue; + } + } + if p.replay_count < 3 { + continue; + } + if p.success_rate() < 0.80 { + continue; + } + let sim = cosine(query_vec, &p.pathway_vec); + if sim < 0.90 { + continue; + } + if best.as_ref().map(|(b, _)| sim > *b).unwrap_or(true) { + best = Some((sim, p)); + } + } + let (similarity, p) = best?; + // The "recommended" rung is the first accepted attempt in the + // stored pathway — that's the one the ladder converged on. + let accepted = p.ladder_attempts.iter().find(|a| a.accepted)?; + Some(HotSwapCandidate { + pathway_id: p.pathway_id.clone(), + trace_uid: p.trace_uid.clone(), + similarity, + replay_count: p.replay_count, + success_rate: p.success_rate(), + recommended_rung: accepted.rung, + recommended_model: accepted.model.clone(), + }) + } + + /// Record the outcome of a hot-swap replay. Increments replay_count + /// unconditionally; increments replays_succeeded iff succeeded; + /// retires the pathway if replay_count >= 3 and success_rate falls + /// below 0.80. Mistral's learning loop in code. + pub async fn record_replay_outcome( + &self, + pathway_id: &str, + succeeded: bool, + ) -> Result<(), String> { + let mut s = self.state.write().await; + // Find the specific pathway across the bucket that matches by + // full id (the bucket key is already the narrow id, but in case + // of future multi-trace-per-id we take the most recent). + let bucket = s + .pathways + .iter_mut() + .find(|(k, _)| k.as_str() == pathway_id) + .map(|(_, v)| v) + .ok_or_else(|| format!("pathway {pathway_id} not found"))?; + let p = bucket + .last_mut() + .ok_or_else(|| format!("pathway {pathway_id} has empty bucket"))?; + p.replay_count = p.replay_count.saturating_add(1); + if succeeded { + p.replays_succeeded = p.replays_succeeded.saturating_add(1); + } + if p.replay_count >= 3 && p.success_rate() < 0.80 { + p.retired = true; + } + s.last_updated_at = Utc::now().timestamp_millis(); + drop(s); + self.persist().await + } + + /// ADR-021 Phase C: retrieve aggregated bug fingerprints for a + /// narrow fingerprint (task_class + file_prefix + signal_class). + /// Scrum pipeline calls this BEFORE running the ladder and prepends + /// the result to the reviewer prompt as historical context. + /// + /// Returns at most `limit` most-frequent patterns across all traces + /// sharing the narrow id. Frequency is summed `occurrences` — a + /// fingerprint seen in 3 traces with occurrences 2/1/1 comes back + /// as occurrences=4 so the preempt-prompt can say "this pattern + /// appeared 4 times on this crate." + pub async fn bug_fingerprints_for( + &self, + task_class: &str, + file_path: &str, + signal_class: Option<&str>, + limit: usize, + ) -> Vec { + let id = PathwayTrace::compute_id(task_class, file_path, signal_class); + let s = self.state.read().await; + let Some(traces) = s.pathways.get(&id) else { return Vec::new(); }; + // Aggregate by (flag, pattern_key) and sum occurrences. Keep a + // representative example (first one seen is fine — bug examples + // are semantically equivalent within a pattern_key by design). + let mut agg: HashMap<(String, String), (SemanticFlag, String, u32)> = HashMap::new(); + for t in traces { + // Mem0 versioning: skip retired + superseded traces so + // their bug patterns don't leak into future retrievals. + if t.retired || t.superseded_at.is_some() { + continue; + } + for bp in &t.bug_fingerprints { + let key = (format!("{:?}", bp.flag), bp.pattern_key.clone()); + let entry = agg.entry(key).or_insert_with(|| { + (bp.flag.clone(), bp.example.clone(), 0) + }); + entry.2 = entry.2.saturating_add(bp.occurrences); + } + } + let mut out: Vec = agg + .into_iter() + .map(|((_, pk), (flag, ex, occ))| BugFingerprint { + flag, + pattern_key: pk, + example: ex, + occurrences: occ, + }) + .collect(); + out.sort_by(|a, b| b.occurrences.cmp(&a.occurrences)); + out.truncate(limit); + out + } + + pub async fn stats(&self) -> PathwayMemoryStats { + let s = self.state.read().await; + let mut total = 0usize; + let mut retired = 0usize; + let mut with_audit_pass = 0usize; + let mut total_replays = 0u64; + let mut successful_replays = 0u64; + for bucket in s.pathways.values() { + for p in bucket { + total += 1; + if p.retired { + retired += 1; + } + if p.audit_consensus.as_ref().map(|a| a.pass).unwrap_or(false) { + with_audit_pass += 1; + } + total_replays += p.replay_count as u64; + successful_replays += p.replays_succeeded as u64; + } + } + PathwayMemoryStats { + total_pathways: total, + retired, + with_audit_pass, + total_replays, + successful_replays, + reuse_rate: if total == 0 { + 0.0 + } else { + total_replays as f32 / total as f32 + }, + replay_success_rate: if total_replays == 0 { + 0.0 + } else { + successful_replays as f32 / total_replays as f32 + }, + } + } +} + +#[derive(Debug, Serialize, Deserialize)] +pub struct PathwayMemoryStats { + pub total_pathways: usize, + pub retired: usize, + pub with_audit_pass: usize, + pub total_replays: u64, + pub successful_replays: u64, + pub reuse_rate: f32, // total_replays / total_pathways + pub replay_success_rate: f32, // successful_replays / total_replays +} + +#[cfg(test)] +mod tests { + use super::*; + use object_store::memory::InMemory; + + fn mk_store() -> Arc { + Arc::new(InMemory::new()) + } + + fn mk_trace(id_tag: &str, audit_pass: bool, replays: u32, succ: u32) -> PathwayTrace { + let pathway_id = + PathwayTrace::compute_id("scrum_review", &format!("crates/{id_tag}/src/x.rs"), Some("CONVERGING")); + let attempts = vec![LadderAttempt { + rung: 2, + model: "qwen3-coder:480b".into(), + latency_ms: 1000, + accepted: true, + reject_reason: None, + }]; + let mut trace = PathwayTrace { + pathway_id, + task_class: "scrum_review".into(), + file_path: format!("crates/{id_tag}/src/x.rs"), + signal_class: Some("CONVERGING".into()), + created_at: Utc::now(), + ladder_attempts: attempts, + kb_chunks: vec![KbChunkRef { + source_doc: "PRD.md".into(), + chunk_id: "c1".into(), + cosine_score: 0.88, + rank: 0, + }], + observer_signals: vec![], + bridge_hits: vec![], + sub_pipeline_calls: vec![], + audit_consensus: Some(AuditConsensus { + pass: audit_pass, + models: vec!["qwen3-coder:480b".into(), "gpt-oss:120b".into(), "kimi-k2:1t".into()], + disagreements: 0, + }), + reducer_summary: "ok".into(), + final_verdict: "accepted".into(), + pathway_vec: vec![], + semantic_flags: vec![], + type_hints_used: vec![], + bug_fingerprints: vec![], + replay_count: replays, + replays_succeeded: succ, + retired: false, + }; + trace.pathway_vec = build_pathway_vec(&trace); + trace + } + + #[test] + fn file_prefix_takes_first_two_segments() { + assert_eq!(file_prefix("crates/queryd/src/service.rs"), "crates/queryd"); + assert_eq!(file_prefix("crates/gateway"), "crates/gateway"); + assert_eq!(file_prefix("README.md"), "README.md"); + assert_eq!(file_prefix(""), ""); + } + + #[test] + fn compute_id_is_deterministic() { + let a = PathwayTrace::compute_id("scrum", "crates/queryd/src/x.rs", Some("LOOPING")); + let b = PathwayTrace::compute_id("scrum", "crates/queryd/src/x.rs", Some("LOOPING")); + assert_eq!(a, b); + } + + #[test] + fn compute_id_generalizes_across_same_prefix() { + // Same prefix + task + signal → same id. That IS the narrow + // generalization — it's what lets hot-swap fire for different + // files in the same crate that share the task/signal profile. + let a = PathwayTrace::compute_id("scrum", "crates/queryd/src/a.rs", Some("L")); + let b = PathwayTrace::compute_id("scrum", "crates/queryd/src/b.rs", Some("L")); + assert_eq!(a, b); + } + + #[test] + fn compute_id_differs_on_signal_class() { + let a = PathwayTrace::compute_id("scrum", "crates/q/s", Some("CONVERGING")); + let b = PathwayTrace::compute_id("scrum", "crates/q/s", Some("LOOPING")); + assert_ne!(a, b); + } + + #[test] + fn cosine_handles_mismatched_lengths() { + assert_eq!(cosine(&[1.0, 0.0], &[1.0]), 0.0); + } + + #[test] + fn cosine_of_identical_normalized_is_one() { + let v = vec![0.6, 0.8]; + let c = cosine(&v, &v); + assert!((c - 1.0).abs() < 1e-5); + } + + #[test] + fn success_rate_is_zero_before_any_replay() { + let t = mk_trace("a", true, 0, 0); + assert_eq!(t.success_rate(), 0.0); + } + + #[test] + fn success_rate_ratio() { + let t = mk_trace("a", true, 4, 3); + assert!((t.success_rate() - 0.75).abs() < 1e-5); + } + + #[tokio::test] + async fn insert_and_stats_roundtrip() { + let mem = PathwayMemory::new(mk_store()); + mem.insert(mk_trace("a", true, 0, 0)).await.unwrap(); + let stats = mem.stats().await; + assert_eq!(stats.total_pathways, 1); + assert_eq!(stats.retired, 0); + assert_eq!(stats.with_audit_pass, 1); + } + + #[tokio::test] + async fn hot_swap_rejects_when_probation_not_met() { + // Probation: replay_count must be >= 3 before success-rate gate + // can fire. A fresh pathway with 0 replays must NEVER hot-swap + // even if its similarity is 1.0 and audit passes. + let mem = PathwayMemory::new(mk_store()); + let trace = mk_trace("a", true, 0, 0); + let qvec = trace.pathway_vec.clone(); + mem.insert(trace).await.unwrap(); + let got = mem + .query_hot_swap("scrum_review", "crates/a/src/x.rs", Some("CONVERGING"), &qvec) + .await; + assert!(got.is_none(), "fresh pathway must not hot-swap"); + } + + #[tokio::test] + async fn hot_swap_rejects_when_audit_explicitly_fails() { + let mem = PathwayMemory::new(mk_store()); + let trace = mk_trace("a", false, 5, 5); // audit FAILED explicitly + let qvec = trace.pathway_vec.clone(); + mem.insert(trace).await.unwrap(); + let got = mem + .query_hot_swap("scrum_review", "crates/a/src/x.rs", Some("CONVERGING"), &qvec) + .await; + assert!(got.is_none(), "pathway with explicit audit FAIL must not hot-swap"); + } + + #[tokio::test] + async fn hot_swap_accepts_unaudited_pathway_for_bootstrap() { + // v1 bootstrap: auditor doesn't update pathway audit_consensus + // until Phase N+1 wires it. Until then, null audit_consensus + // must NOT block hot-swap — the success_rate + probation gates + // alone prove safety. Once auditor wires up, explicit audit + // failures will re-introduce the block (see previous test). + let mem = PathwayMemory::new(mk_store()); + let mut trace = mk_trace("a", true, 5, 5); + trace.audit_consensus = None; // bootstrap path + trace.pathway_vec = build_pathway_vec(&trace); + let qvec = trace.pathway_vec.clone(); + mem.insert(trace).await.unwrap(); + let got = mem + .query_hot_swap("scrum_review", "crates/a/src/x.rs", Some("CONVERGING"), &qvec) + .await; + assert!(got.is_some(), "unaudited pathway with good replay history must hot-swap"); + } + + #[tokio::test] + async fn hot_swap_rejects_when_success_rate_below_80pct() { + // 10 replays, 7 succeeded = 70% — below the 0.80 threshold. + let mem = PathwayMemory::new(mk_store()); + let trace = mk_trace("a", true, 10, 7); + let qvec = trace.pathway_vec.clone(); + mem.insert(trace).await.unwrap(); + let got = mem + .query_hot_swap("scrum_review", "crates/a/src/x.rs", Some("CONVERGING"), &qvec) + .await; + assert!(got.is_none()); + } + + #[tokio::test] + async fn hot_swap_accepts_when_all_gates_pass() { + let mem = PathwayMemory::new(mk_store()); + let trace = mk_trace("a", true, 5, 5); // 100% success after 5 replays + let qvec = trace.pathway_vec.clone(); + mem.insert(trace).await.unwrap(); + let got = mem + .query_hot_swap("scrum_review", "crates/a/src/x.rs", Some("CONVERGING"), &qvec) + .await; + let cand = got.expect("should hot-swap"); + assert!(cand.similarity >= 0.90); + assert_eq!(cand.recommended_rung, 2); + assert_eq!(cand.recommended_model, "qwen3-coder:480b"); + } + + #[tokio::test] + async fn record_replay_retires_pathway_on_failure_pattern() { + let mem = PathwayMemory::new(mk_store()); + let trace = mk_trace("a", true, 0, 0); + let pid = trace.pathway_id.clone(); + mem.insert(trace).await.unwrap(); + // Three replays, all fail → success_rate = 0.0 → retired. + mem.record_replay_outcome(&pid, false).await.unwrap(); + mem.record_replay_outcome(&pid, false).await.unwrap(); + mem.record_replay_outcome(&pid, false).await.unwrap(); + let stats = mem.stats().await; + assert_eq!(stats.retired, 1, "3 failures after insert must retire"); + } + + #[tokio::test] + async fn record_replay_does_not_retire_before_probation() { + let mem = PathwayMemory::new(mk_store()); + let trace = mk_trace("a", true, 0, 0); + let pid = trace.pathway_id.clone(); + mem.insert(trace).await.unwrap(); + // Two replays (below probation of 3), both fail. Should NOT + // retire yet — probation requires minimum 3 data points. + mem.record_replay_outcome(&pid, false).await.unwrap(); + mem.record_replay_outcome(&pid, false).await.unwrap(); + let stats = mem.stats().await; + assert_eq!(stats.retired, 0, "only 2 replays → below probation floor"); + } + + #[tokio::test] + async fn retired_pathway_never_hot_swaps_again() { + let mem = PathwayMemory::new(mk_store()); + let trace = mk_trace("a", true, 0, 0); + let pid = trace.pathway_id.clone(); + let qvec = trace.pathway_vec.clone(); + mem.insert(trace).await.unwrap(); + for _ in 0..3 { + mem.record_replay_outcome(&pid, false).await.unwrap(); + } + // Now record 10 successes to push success_rate well above 0.80. + // Pathway is still retired — retirement is sticky by design, to + // prevent oscillation on noise. + for _ in 0..10 { + mem.record_replay_outcome(&pid, true).await.unwrap(); + } + let got = mem + .query_hot_swap("scrum_review", "crates/a/src/x.rs", Some("CONVERGING"), &qvec) + .await; + assert!(got.is_none(), "retirement must be sticky"); + } + + #[tokio::test] + async fn pathway_vec_differs_for_different_models() { + // Two pathways with same fingerprint but different ladder + // models should have different embeddings so the similarity + // gate can discriminate. This is what enables narrow fingerprint + // + similarity-vec to cluster correctly. + let a = mk_trace("a", true, 5, 5); + let mut b = a.clone(); + b.ladder_attempts[0].model = "kimi-k2:1t".into(); + b.pathway_vec = build_pathway_vec(&b); + let sim = cosine(&a.pathway_vec, &b.pathway_vec); + assert!(sim < 1.0, "different models → different embeddings"); + assert!(sim > 0.5, "shared fingerprint → embeddings still related"); + } + + // ─── ADR-021 semantic-correctness layer tests ─────────────────── + + #[test] + fn pathway_trace_deserializes_without_new_fields_backcompat() { + // Critical: existing traces on disk (persisted before ADR-021) + // must still deserialize. serde(default) on the three new fields + // is the back-compat mechanism — verify it holds. + let json = r#"{ + "pathway_id": "abc", + "task_class": "scrum_review", + "file_path": "crates/x/y.rs", + "signal_class": null, + "created_at": "2026-04-24T00:00:00Z", + "ladder_attempts": [], + "kb_chunks": [], + "observer_signals": [], + "bridge_hits": [], + "sub_pipeline_calls": [], + "audit_consensus": null, + "reducer_summary": "old trace", + "final_verdict": "accepted", + "pathway_vec": [], + "replay_count": 0, + "replays_succeeded": 0, + "retired": false + }"#; + let t: PathwayTrace = serde_json::from_str(json).expect("must deserialize pre-ADR-021 trace"); + assert!(t.semantic_flags.is_empty()); + assert!(t.type_hints_used.is_empty()); + assert!(t.bug_fingerprints.is_empty()); + assert_eq!(t.reducer_summary, "old trace"); + } + + #[test] + fn semantic_flag_serializes_as_tagged_enum() { + // Verifying the wire format — the tag field "kind" lets TS/JSON + // clients pattern-match without needing to know variant ordering. + let s = serde_json::to_string(&SemanticFlag::UnitMismatch).unwrap(); + assert!(s.contains("UnitMismatch"), "got: {s}"); + assert!(s.contains("kind"), "must be tagged enum for TS interop, got: {s}"); + } + + #[test] + fn bug_fingerprint_roundtrips_through_serde() { + let bp = BugFingerprint { + flag: SemanticFlag::UnitMismatch, + pattern_key: "row_count-file_count".into(), + example: "base_rows = pre_filter_rows - delta_count".into(), + occurrences: 1, + }; + let s = serde_json::to_string(&bp).unwrap(); + let parsed: BugFingerprint = serde_json::from_str(&s).unwrap(); + assert_eq!(parsed, bp); + } + + #[test] + fn pathway_vec_differs_when_bug_fingerprint_added() { + // A trace with a known bug history should embed differently + // from a clean trace with the same ladder/KB. This is the + // compounding signal: "same file, different bug history." + let clean = mk_trace("a", true, 5, 5); + let mut flagged = clean.clone(); + flagged.semantic_flags.push(SemanticFlag::UnitMismatch); + flagged.bug_fingerprints.push(BugFingerprint { + flag: SemanticFlag::UnitMismatch, + pattern_key: "row_count-file_count".into(), + example: "x = y - z".into(), + occurrences: 1, + }); + flagged.pathway_vec = build_pathway_vec(&flagged); + let sim = cosine(&clean.pathway_vec, &flagged.pathway_vec); + assert!(sim < 1.0, "bug history must shift the embedding"); + assert!(sim > 0.3, "shared fingerprint should keep them loosely related"); + } + + #[test] + fn semantic_flag_discriminates_by_variant() { + // Two traces with different flag classes should embed to + // different points. Validates that the index can retrieve + // "files with UnitMismatch history" separately from + // "files with NullableConfusion history." + let mut a = mk_trace("x", true, 5, 5); + a.semantic_flags.push(SemanticFlag::UnitMismatch); + a.pathway_vec = build_pathway_vec(&a); + let mut b = a.clone(); + b.semantic_flags = vec![SemanticFlag::NullableConfusion]; + b.pathway_vec = build_pathway_vec(&b); + let sim = cosine(&a.pathway_vec, &b.pathway_vec); + assert!(sim < 1.0, "different flag variants → different embeddings"); + } + + #[tokio::test] + async fn bug_fingerprints_aggregate_by_pattern_key() { + // Three traces on the same narrow fingerprint — two with the + // same bug pattern, one with a different pattern. The aggregator + // must sum occurrences for the shared key and sort by count. + let mem = PathwayMemory::new(mk_store()); + let mut t1 = mk_trace("q", true, 0, 0); + t1.bug_fingerprints.push(BugFingerprint { + flag: SemanticFlag::UnitMismatch, + pattern_key: "row-file".into(), + example: "a - b".into(), + occurrences: 2, + }); + let mut t2 = mk_trace("q", true, 0, 0); + t2.bug_fingerprints.push(BugFingerprint { + flag: SemanticFlag::UnitMismatch, + pattern_key: "row-file".into(), + example: "x - y".into(), + occurrences: 1, + }); + let mut t3 = mk_trace("q", true, 0, 0); + t3.bug_fingerprints.push(BugFingerprint { + flag: SemanticFlag::OffByOne, + pattern_key: "len-1".into(), + example: "items[len]".into(), + occurrences: 1, + }); + mem.insert(t1).await.unwrap(); + mem.insert(t2).await.unwrap(); + mem.insert(t3).await.unwrap(); + let fps = mem + .bug_fingerprints_for("scrum_review", "crates/q/src/x.rs", Some("CONVERGING"), 10) + .await; + assert_eq!(fps.len(), 2, "two distinct patterns after aggregation"); + // First should be the aggregated UnitMismatch (3 total occurrences) + assert_eq!(fps[0].pattern_key, "row-file"); + assert_eq!(fps[0].occurrences, 3); + assert_eq!(fps[1].pattern_key, "len-1"); + assert_eq!(fps[1].occurrences, 1); + } + + #[tokio::test] + async fn bug_fingerprints_empty_for_unseen_fingerprint() { + let mem = PathwayMemory::new(mk_store()); + let fps = mem + .bug_fingerprints_for("scrum_review", "crates/never_seen/x.rs", None, 5) + .await; + assert!(fps.is_empty()); + } + + #[tokio::test] + async fn bug_fingerprints_respects_limit() { + let mem = PathwayMemory::new(mk_store()); + for i in 0..10 { + let mut t = mk_trace("q", true, 0, 0); + t.bug_fingerprints.push(BugFingerprint { + flag: SemanticFlag::OffByOne, + pattern_key: format!("p{i}"), + example: "".into(), + occurrences: (10 - i) as u32, // decreasing so sort matters + }); + mem.insert(t).await.unwrap(); + } + let fps = mem + .bug_fingerprints_for("scrum_review", "crates/q/src/x.rs", Some("CONVERGING"), 3) + .await; + assert_eq!(fps.len(), 3); + // Highest occurrences first. + assert_eq!(fps[0].pattern_key, "p0"); + assert_eq!(fps[0].occurrences, 10); + } + + #[tokio::test] + async fn insert_preserves_semantic_fields() { + let mem = PathwayMemory::new(mk_store()); + let mut t = mk_trace("a", true, 0, 0); + t.semantic_flags.push(SemanticFlag::UnitMismatch); + t.type_hints_used.push(TypeHint { + source: "arrow_schema".into(), + symbol: "pre_filter_rows".into(), + type_repr: "usize (sum of batch.num_rows)".into(), + }); + t.bug_fingerprints.push(BugFingerprint { + flag: SemanticFlag::UnitMismatch, + pattern_key: "row-minus-file".into(), + example: "pre_filter_rows - delta_count".into(), + occurrences: 1, + }); + mem.insert(t).await.unwrap(); + // Reload from store via a fresh handle — proves persistence + // roundtrips the new fields as well as the old ones. + let mem2 = PathwayMemory::new(mem.store.clone()); + mem2.load_from_storage().await.unwrap(); + let stats = mem2.stats().await; + assert_eq!(stats.total_pathways, 1); + } +} diff --git a/crates/vectord/src/playbook_memory.rs b/crates/vectord/src/playbook_memory.rs index b8c4fd9..f407c55 100644 --- a/crates/vectord/src/playbook_memory.rs +++ b/crates/vectord/src/playbook_memory.rs @@ -1647,7 +1647,7 @@ mod validity_window_tests { let past = (chrono::Utc::now() - chrono::Duration::days(1)).to_rfc3339(); let future = (chrono::Utc::now() + chrono::Duration::days(1)).to_rfc3339(); let e_expired = mkentry("pb-expired", "Nashville", "TN", None, Some(past)); - let e_alive = { let mut e = mkentry("pb-alive", "Nashville", "TN", None, Some(future)); e }; + let e_alive = mkentry("pb-alive", "Nashville", "TN", None, Some(future)); pm.set_entries(vec![e_expired, e_alive]).await.unwrap(); let boosts = pm.compute_boost_for_filtered_with_role( &[1.0, 0.0, 0.0], 100, 0.5, diff --git a/crates/vectord/src/promotion.rs b/crates/vectord/src/promotion.rs index 579b7fe..084c065 100644 --- a/crates/vectord/src/promotion.rs +++ b/crates/vectord/src/promotion.rs @@ -131,6 +131,11 @@ impl PromotionRegistry { file.history.drain(0..drop); } } + // Bind `entry` ref-captured for the log line below so the log + // doesn't double-unwrap file.current — entry is Some-by-construction + // at the function boundary; past versions reached in via + // `.as_ref().unwrap()` twice, which compiled but would panic if + // the construction above ever changed. file.current = Some(entry); file.index_name = index_name.to_string(); @@ -140,10 +145,12 @@ impl PromotionRegistry { ops::put(&store, &key, json.into()).await?; self.cache.write().await.insert(index_name.to_string(), file.clone()); - tracing::info!( - "promoted '{}' to config {:?} (trial={})", - index_name, file.current.as_ref().unwrap().config, file.current.as_ref().unwrap().trial_id, - ); + if let Some(cur) = &file.current { + tracing::info!( + "promoted '{}' to config {:?} (trial={})", + index_name, cur.config, cur.trial_id, + ); + } Ok(file) } diff --git a/crates/vectord/src/refresh.rs b/crates/vectord/src/refresh.rs index 627fd7f..8f0df4d 100644 --- a/crates/vectord/src/refresh.rs +++ b/crates/vectord/src/refresh.rs @@ -308,6 +308,8 @@ async fn try_update_index_meta( bucket: "primary".to_string(), vector_backend: shared::types::VectorBackend::Parquet, id_prefix: None, + last_used: None, + build_signature: None, }; index_registry.register(meta).await } diff --git a/crates/vectord/src/service.rs b/crates/vectord/src/service.rs index 2f54920..20fe7bd 100644 --- a/crates/vectord/src/service.rs +++ b/crates/vectord/src/service.rs @@ -13,7 +13,7 @@ use std::sync::Arc; use aibridge::client::{AiClient, EmbedRequest, GenerateRequest}; use catalogd::registry::Registry as CatalogRegistry; use storaged::registry::BucketRegistry; -use crate::{agent, autotune, chunker, embedding_cache, harness, hnsw, index_registry, jobs, lance_backend, playbook_memory, promotion, rag, refresh, search, store, supervisor, trial}; +use crate::{agent, autotune, chunker, embedding_cache, harness, hnsw, index_registry, jobs, lance_backend, pathway_memory, playbook_memory, promotion, rag, refresh, search, store, supervisor, trial}; use tokio::sync::Semaphore; #[derive(Clone)] @@ -55,6 +55,11 @@ pub struct VectorState { /// and, when `use_playbook_memory` is set on /vectors/hybrid, boosts /// workers that were actually filled in semantically-similar past ops. pub playbook_memory: playbook_memory::PlaybookMemory, + /// Pathway memory — consensus-designed sidecar for full-context + /// backtracking + hot-swap of successful review pathways. See + /// crates/vectord/src/pathway_memory.rs for the design rationale + /// (10-probe N=3 ensemble, locked 2026-04-24). + pub pathway_memory: pathway_memory::PathwayMemory, /// Serializes embed calls from seed_playbook_memory to avoid /// concurrent socket collisions with the Python sidecar. pub embed_semaphore: Arc, @@ -78,6 +83,10 @@ pub fn router(state: VectorState) -> Router { .route("/indexes/{name}/bucket", axum::routing::patch(migrate_index_bucket)) .route("/jobs", get(list_jobs)) .route("/jobs/{id}", get(get_job)) + // PRD Phase 41 alias — docs/CONTROL_PLANE_PRD.md specifies + // GET /vectors/profile/jobs/{id} for polling profile activations. + // Same handler as /jobs/{id}; the alias just matches the PRD URL. + .route("/profile/jobs/{id}", get(get_job)) .route("/search", post(search_index)) .route("/rag", post(rag_query)) .route("/hybrid", post(hybrid_search)) @@ -137,6 +146,27 @@ pub fn router(state: VectorState) -> Router { // Phase 45 slice 3 — doc drift detection + human re-admission. .route("/playbook_memory/doc_drift/check/{id}", post(check_doc_drift)) .route("/playbook_memory/doc_drift/resolve/{id}", post(resolve_doc_drift)) + // Phase 45 closure (2026-04-27) — batch scan across all active + // playbooks. Operator runs this on a schedule (cron or manual); + // each newly-detected drift writes a row to + // data/_kb/doc_drift_corrections.jsonl for downstream review. + .route("/playbook_memory/doc_drift/scan", post(scan_doc_drift)) + // Pathway memory — consensus-designed sidecar (2026-04-24). + // scrum_master_pipeline POSTs /pathway/insert at the end of each + // review, calls /pathway/query before running the ladder for a + // potential hot-swap, and posts /pathway/record_replay after a + // hot-swap succeeds or fails. + .route("/pathway/insert", post(pathway_insert)) + .route("/pathway/query", post(pathway_query)) + .route("/pathway/record_replay", post(pathway_record_replay)) + .route("/pathway/stats", get(pathway_stats)) + // ADR-021 Phase C: pre-review bug-fingerprint retrieval. + .route("/pathway/bug_fingerprints", post(pathway_bug_fingerprints)) + // Mem0 ops (J 2026-04-25): upsert/retire/revise/history. + .route("/pathway/upsert", post(pathway_upsert)) + .route("/pathway/retire", post(pathway_retire)) + .route("/pathway/revise", post(pathway_revise)) + .route("/pathway/history/{trace_uid}", get(pathway_history)) .with_state(state) } @@ -237,7 +267,9 @@ async fn create_index( chunks_per_sec: rate, bucket: bucket.clone(), vector_backend: shared::types::VectorBackend::Parquet, - id_prefix: None, + id_prefix: None, + last_used: None, + build_signature: None, }; let _ = registry.register(meta).await; @@ -454,51 +486,6 @@ async fn copy_key( storaged::ops::put(dst, key, data).await } -// --- unused legacy function below, kept for reference --- - -#[allow(dead_code)] -/// Legacy single-pipeline embedding (replaced by supervisor). -async fn _run_embedding_job_legacy( - job_id: &str, - index_name: &str, - chunks: &[chunker::TextChunk], - ai_client: &AiClient, - store: &Arc, - tracker: &jobs::JobTracker, -) -> Result { - let batch_size = 32; - let mut all_vectors: Vec> = Vec::new(); - let start = std::time::Instant::now(); - - for (i, batch) in chunks.chunks(batch_size).enumerate() { - let texts: Vec = batch.iter().map(|c| c.text.clone()).collect(); - - let embed_resp = ai_client.embed(EmbedRequest { - texts, - model: None, - }).await.map_err(|e| format!("embed batch {} error: {e}", i))?; - - all_vectors.extend(embed_resp.embeddings); - - // Update progress - let elapsed = start.elapsed().as_secs_f32(); - let rate = if elapsed > 0.0 { all_vectors.len() as f32 / elapsed } else { 0.0 }; - tracker.update_embed_progress(job_id, all_vectors.len(), rate).await; - - // Log every 100 batches - if (i + 1) % 100 == 0 { - let pct = (all_vectors.len() as f32 / chunks.len() as f32) * 100.0; - let eta = if rate > 0.0 { (chunks.len() - all_vectors.len()) as f32 / rate } else { 0.0 }; - tracing::info!("job {job_id}: {}/{} chunks ({pct:.0}%), {rate:.0}/sec, ETA {eta:.0}s", - all_vectors.len(), chunks.len()); - } - } - - // Store - let key = store::store_embeddings(store, index_name, chunks, &all_vectors).await?; - Ok(key) -} - // --- Job Status --- async fn list_jobs(State(state): State) -> impl IntoResponse { @@ -1381,7 +1368,7 @@ async fn activate_profile( let job_id = state.job_tracker.create_profile_activation(&profile_id).await; let job_id_for_response = job_id.clone(); let tracker = state.job_tracker.clone(); - let catalog = state.catalog.clone(); + let _catalog = state.catalog.clone(); let index_registry = state.index_registry.clone(); let bucket_registry = state.bucket_registry.clone(); let lance = state.lance.clone(); @@ -1396,7 +1383,7 @@ async fn activate_profile( let profile_bound = profile.bound_datasets.clone(); let profile_hnsw = profile.hnsw_config.clone(); let profile_backend = profile.vector_backend.clone(); - let profile_full = profile.clone(); + let _profile_full = profile.clone(); tokio::spawn(async move { let t0 = std::time::Instant::now(); @@ -1580,10 +1567,13 @@ async fn activate_profile( tracker.complete(&job_id, result).await; }); - Ok(Json(json!({ + // PRD Phase 41 gate: "Activate a profile → returns 202 in <100ms + // → job completes in background". 202 ACCEPTED signals async-work + // started; clients poll /vectors/jobs/{job_id} for progress. + Ok((StatusCode::ACCEPTED, Json(json!({ "job_id": job_id_for_response, "message": format!("profile activation started — poll /vectors/jobs/{} for progress", job_id_for_response), - }))) + })))) } /// Unload this profile's model and clear the active slot. No-op if the @@ -2554,6 +2544,119 @@ async fn check_doc_drift( }))) } +/// Phase 45 closure (2026-04-27) — POST /playbook_memory/doc_drift/scan +/// +/// Iterates all active playbooks (non-retired, has doc_refs), runs +/// drift check against context7 for each, flags drifted entries via +/// PlaybookMemory::flag_doc_drift, and appends a row to +/// data/_kb/doc_drift_corrections.jsonl for each drift detected. +/// +/// Returns aggregate stats so an operator can see at-a-glance how +/// many playbooks drifted and which tools moved. +/// +/// Honors entries already flagged: they're counted in `already_flagged` +/// (no double-flag, no duplicate corrections.jsonl row). +async fn scan_doc_drift( + State(state): State, +) -> Result, (StatusCode, String)> { + use crate::doc_drift::{check_all_refs, DriftCheckerConfig, DriftOutcome}; + + let entries = state.playbook_memory.snapshot().await; + let now = chrono::Utc::now().to_rfc3339(); + let cfg = DriftCheckerConfig::default(); + + let mut scanned = 0usize; + let mut newly_flagged = 0usize; + let mut already_flagged = 0usize; + let mut skipped_no_refs = 0usize; + let mut skipped_retired = 0usize; + let mut tool_counts: std::collections::HashMap = Default::default(); + let mut corrections_rows: Vec = vec![]; + + for e in entries.iter() { + if e.retired_at.is_some() { skipped_retired += 1; continue; } + if e.doc_refs.is_empty() { skipped_no_refs += 1; continue; } + if e.doc_drift_flagged_at.is_some() && e.doc_drift_reviewed_at.is_none() { + already_flagged += 1; + continue; + } + scanned += 1; + let results = check_all_refs(&cfg, &e.doc_refs).await; + let drifted_tools: Vec<&str> = results.iter() + .filter(|r| matches!(r.outcome, DriftOutcome::Drifted { .. })) + .map(|r| r.tool.as_str()) + .collect(); + if drifted_tools.is_empty() { continue; } + + // Flag the entry. + let flagged = state.playbook_memory.flag_doc_drift(&e.playbook_id).await + .unwrap_or(false); + if flagged { newly_flagged += 1; } + for t in &drifted_tools { + *tool_counts.entry(t.to_string()).or_insert(0) += 1; + } + + // Build corrections.jsonl row — one per drifted playbook with + // the tool list inline. Downstream consumers (overview model, + // operator dashboard) read this to decide reviews + revisions. + let row = serde_json::json!({ + "playbook_id": e.playbook_id, + "scanned_at": now, + "drifted_tools": drifted_tools, + "per_tool": results.iter().map(|r| { + let (drifted, current, src) = match &r.outcome { + DriftOutcome::Drifted { current_snippet_hash, source_url } => + (true, Some(current_snippet_hash.clone()), source_url.clone()), + _ => (false, None, None), + }; + serde_json::json!({ + "tool": r.tool, "version_seen": r.version_seen, + "drifted": drifted, "current_snippet_hash": current, "source_url": src, + }) + }).collect::>(), + "recommended_action": "review-and-resolve", + }); + corrections_rows.push(row.to_string()); + } + + // Persist corrections.jsonl row(s) for the operator/overview model. + if !corrections_rows.is_empty() { + let path = std::path::PathBuf::from("/home/profit/lakehouse/data/_kb/doc_drift_corrections.jsonl"); + if let Some(parent) = path.parent() { + if let Err(e) = tokio::fs::create_dir_all(parent).await { + tracing::warn!(target: "vectord.doc_drift", "create_dir_all {parent:?}: {e}"); + } + } + let body = corrections_rows.join("\n") + "\n"; + if let Err(e) = tokio::fs::OpenOptions::new() + .create(true).append(true).open(&path).await + { + tracing::warn!(target: "vectord.doc_drift", "open {path:?}: {e}"); + } else { + use tokio::io::AsyncWriteExt; + match tokio::fs::OpenOptions::new().create(true).append(true).open(&path).await { + Ok(mut f) => { + if let Err(e) = f.write_all(body.as_bytes()).await { + tracing::warn!(target: "vectord.doc_drift", "append {path:?}: {e}"); + } + } + Err(e) => tracing::warn!(target: "vectord.doc_drift", "reopen {path:?}: {e}"), + } + } + } + + Ok(Json(serde_json::json!({ + "scanned_at": now, + "scanned": scanned, + "newly_flagged": newly_flagged, + "already_flagged": already_flagged, + "skipped_retired": skipped_retired, + "skipped_no_refs": skipped_no_refs, + "drifted_by_tool": tool_counts, + "corrections_written": corrections_rows.len(), + }))) +} + /// Phase 45 slice 3 — POST /playbook_memory/doc_drift/resolve/{id} /// /// Human-in-the-loop re-admission. Stamps `doc_drift_reviewed_at`. @@ -2833,6 +2936,149 @@ async fn lance_build_scalar_index( } } +// ─── Pathway memory handlers ────────────────────────────────────────── +// +// Thin wrappers around pathway_memory::PathwayMemory. HTTP surface is +// deliberately small — four endpoints cover the full lifecycle: +// insert at end-of-review, query before running the ladder, +// record_replay after a hot-swap, and stats for the VCP UI. + +#[derive(Deserialize)] +struct PathwayQueryRequest { + task_class: String, + file_path: String, + signal_class: Option, + query_vec: Vec, +} + +async fn pathway_insert( + State(state): State, + Json(trace): Json, +) -> impl IntoResponse { + match state.pathway_memory.insert(trace).await { + Ok(()) => Ok(Json(json!({"ok": true}))), + Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e)), + } +} + +async fn pathway_query( + State(state): State, + Json(req): Json, +) -> impl IntoResponse { + let cand = state + .pathway_memory + .query_hot_swap( + &req.task_class, + &req.file_path, + req.signal_class.as_deref(), + &req.query_vec, + ) + .await; + // 200 with null candidate means "no hot-swap"; this is a normal + // path, not an error — callers should proceed with the full ladder. + Json(json!({ "candidate": cand })) +} + +#[derive(Deserialize)] +struct PathwayReplayRequest { + pathway_id: String, + succeeded: bool, +} + +async fn pathway_record_replay( + State(state): State, + Json(req): Json, +) -> impl IntoResponse { + match state + .pathway_memory + .record_replay_outcome(&req.pathway_id, req.succeeded) + .await + { + Ok(()) => Ok(Json(json!({"ok": true}))), + Err(e) => Err((StatusCode::NOT_FOUND, e)), + } +} + +async fn pathway_stats(State(state): State) -> impl IntoResponse { + Json(state.pathway_memory.stats().await) +} + +#[derive(Deserialize)] +struct PathwayBugFingerprintsRequest { + task_class: String, + file_path: String, + signal_class: Option, + limit: Option, +} + +async fn pathway_bug_fingerprints( + State(state): State, + Json(req): Json, +) -> impl IntoResponse { + let fps = state + .pathway_memory + .bug_fingerprints_for( + &req.task_class, + &req.file_path, + req.signal_class.as_deref(), + req.limit.unwrap_or(5), + ) + .await; + Json(json!({ "fingerprints": fps })) +} + +// ─── Mem0 ops endpoints (J 2026-04-25) ─── + +async fn pathway_upsert( + State(state): State, + Json(trace): Json, +) -> impl IntoResponse { + match state.pathway_memory.upsert(trace).await { + Ok(outcome) => Ok(Json(json!({"ok": true, "outcome": outcome}))), + Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e)), + } +} + +#[derive(Deserialize)] +struct PathwayRetireRequest { + trace_uid: String, + reason: String, +} + +async fn pathway_retire( + State(state): State, + Json(req): Json, +) -> impl IntoResponse { + match state.pathway_memory.retire(&req.trace_uid, &req.reason).await { + Ok(touched) => Ok(Json(json!({"ok": true, "retired": touched}))), + Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e)), + } +} + +#[derive(Deserialize)] +struct PathwayReviseRequest { + parent_trace_uid: String, + new_trace: pathway_memory::PathwayTrace, +} + +async fn pathway_revise( + State(state): State, + Json(req): Json, +) -> impl IntoResponse { + match state.pathway_memory.revise(&req.parent_trace_uid, req.new_trace).await { + Ok(outcome) => Ok(Json(json!({"ok": true, "outcome": outcome}))), + Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e)), + } +} + +async fn pathway_history( + State(state): State, + axum::extract::Path(trace_uid): axum::extract::Path, +) -> impl IntoResponse { + let chain = state.pathway_memory.history(&trace_uid).await; + Json(json!({"trace_uid": trace_uid, "chain_len": chain.len(), "chain": chain})) +} + #[cfg(test)] mod extractor_tests { use super::*; diff --git a/crates/vectord/src/store.rs b/crates/vectord/src/store.rs index c220263..85269ef 100644 --- a/crates/vectord/src/store.rs +++ b/crates/vectord/src/store.rs @@ -2,9 +2,8 @@ /// Each embedding index is stored as: source, doc_id, chunk_idx, chunk_text, vector (binary blob). /// Vectors are stored as raw f32 bytes for compact storage and fast loading. -use arrow::array::{ArrayRef, BinaryArray, Float32Array, Int32Array, RecordBatch, StringArray}; +use arrow::array::{ArrayRef, BinaryArray, Int32Array, RecordBatch, StringArray}; use arrow::datatypes::{DataType, Field, Schema}; -use bytes::Bytes; use object_store::ObjectStore; use std::sync::Arc; diff --git a/crates/vectord/src/trial.rs b/crates/vectord/src/trial.rs index 75add9a..9c4b767 100644 --- a/crates/vectord/src/trial.rs +++ b/crates/vectord/src/trial.rs @@ -10,7 +10,6 @@ /// JSONL on every event. See `append_log.rs` for the full rationale. use chrono::{DateTime, Utc}; -use object_store::ObjectStore; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::sync::Arc; diff --git a/data/_catalog/views/candidates_safe.json b/data/_catalog/views/candidates_safe.json new file mode 100644 index 0000000..98686cb --- /dev/null +++ b/data/_catalog/views/candidates_safe.json @@ -0,0 +1,24 @@ +{ + "name": "candidates_safe", + "base_dataset": "candidates", + "columns": [ + "candidate_id", + "first_name", + "city", + "state", + "skills", + "years_experience", + "status" + ], + "row_filter": "status != 'blocked'", + "column_redactions": { + "candidate_id": { + "kind": "mask", + "keep_prefix": 3, + "keep_suffix": 2 + } + }, + "created_at": "2026-04-27T15:42:00Z", + "created_by": "j", + "description": "PII-free candidate projection — drops last_name, email, phone, hourly_rate_usd. candidate_id masked (keep first 3, last 2). Visible to recruiter / mode-runner agents." +} diff --git a/data/_catalog/views/jobs_safe.json b/data/_catalog/views/jobs_safe.json new file mode 100644 index 0000000..1e0f3c1 --- /dev/null +++ b/data/_catalog/views/jobs_safe.json @@ -0,0 +1,26 @@ +{ + "name": "jobs_safe", + "base_dataset": "job_orders", + "columns": [ + "job_order_id", + "client_id", + "title", + "vertical", + "status", + "city", + "state", + "zip", + "bill_rate", + "pay_rate" + ], + "column_redactions": { + "client_id": { + "kind": "mask", + "keep_prefix": 3, + "keep_suffix": 2 + } + }, + "created_at": "2026-04-27T15:42:00Z", + "created_by": "j", + "description": "Job-order projection with client_id masked. Drops description (often quotes client names verbatim, no text-scrubber available). bill_rate / pay_rate kept — commercial info, not PII per staffing PRD." +} diff --git a/data/_catalog/views/workers_safe.json b/data/_catalog/views/workers_safe.json new file mode 100644 index 0000000..224ecf6 --- /dev/null +++ b/data/_catalog/views/workers_safe.json @@ -0,0 +1,22 @@ +{ + "name": "workers_safe", + "base_dataset": "workers_500k", + "columns": [ + "worker_id", + "role", + "city", + "state", + "skills", + "certifications", + "archetype", + "reliability", + "responsiveness", + "engagement", + "compliance", + "availability" + ], + "column_redactions": {}, + "created_at": "2026-04-27T15:42:00Z", + "created_by": "j", + "description": "PII-free worker projection — drops name, email, phone, zip, communications, resume_text. resume_text + communications carry verbatim PII (full names) and there's no in-view text scrubber, so they're dropped wholesale. Skills + certifications + scores carry the matching signal for staffing inference. Source for workers_500k_v9 vector corpus rebuild." +} diff --git a/data/datasets/fill_events.parquet b/data/datasets/fill_events.parquet new file mode 100644 index 0000000..15cf4ff Binary files /dev/null and b/data/datasets/fill_events.parquet differ diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md index e8ef0de..3cafa35 100644 --- a/docs/DECISIONS.md +++ b/docs/DECISIONS.md @@ -99,3 +99,8 @@ **Date:** 2026-04-19 **Decision:** `catalogd::Registry::register(name, fingerprint, objects)` is idempotent on `name`. If no manifest for `name` exists, create one. If one exists with the same `schema_fingerprint`, reuse its `DatasetId`, replace `objects`, bump `updated_at`, and write through. If one exists with a different `schema_fingerprint`, reject with `409 Conflict` (HTTP) / `FAILED_PRECONDITION` (gRPC). A one-shot operator endpoint `POST /catalog/dedupe` collapses any pre-existing duplicates (preferring the manifest with a non-null `row_count`, then the most recently updated). **Rationale:** Registry was keyed by surrogate `DatasetId` with no uniqueness constraint on `name`, so every caller that re-registered (re-ingest, external cron, gRPC retry) silently created a parallel manifest pointing at the same parquet — accumulating 308× `successful_playbooks` in live state before detection. The fingerprint gate turns re-ingest into an explicit no-op (matching PRD invariant #5 "ingestd is idempotent — re-ingesting the same file is a no-op") while forcing schema drift to be visible instead of silently clobbering. 409 status separates policy rejections from server errors, which matters for the Phase 12 tool-consumer ecosystem. Concurrency: the write lock is held across the storage write to close the check→insert TOCTOU window; serializing registers is acceptable because registers-per-second is low on the ingest path. Audit: idempotent-register events are visible as bumps to the stored manifest's `updated_at` field and in `catalogd` tracing output (tracing is non-durable, operator view only); `DedupeReport` is the return-value audit for cleanup runs. No event-journal entries are emitted — ADR-012 scopes the journal to row-level mutations, not catalog-manifest operations. + +## ADR-021: Semantic-correctness layer on pathway_memory — matrix-indexed bug grammar +**Date:** 2026-04-24 +**Decision:** Extend `pathway_memory::PathwayTrace` (ADR added 2026-04-24 in same commit as this one) with a semantic-correctness layer so the matrix index compounds recognition of unit/type/shape bugs across iterations. Three new fields: `semantic_flags: Vec` (enum: `UnitMismatch`, `TypeConfusion`, `NullableConfusion`, `OffByOne`, `StaleReference`, `PseudoImpl`, `DeadCode`, `WarningNoise`, `BoundaryViolation`), `type_hints_used: Vec` (schema/type context the reviewer was given — catalogd column types for SQL-touching code, Arrow `RecordBatch.schema()` accessors for Rust, Rust struct field types for everything else), and `bug_fingerprints: Vec` (structural pattern hash, e.g. `{lhs_unit: "rows", rhs_unit: "files", op: "-"}` → stable SHA for similarity retrieval). Scrum pipeline pre-review: query matrix index for bug fingerprints flagged on this file's narrow fingerprint (same `task_class + file_prefix + signal_class` as hot-swap) and prepend them to the reviewer prompt as "watch for these patterns historically found here." Reviewer prompt explicitly tags each finding with a `semantic_flag`. `truth::evaluate()` gets a review-time task_class (`code_review.unit_check`) that consumes parsed-fact rules like `FieldContainsAny { field: "code_expression", needles: ["row_count - file_count", "bytes_read - row_count"] }` — the same primitive we use for SQL guard in P42-002. +**Rationale:** The 2026-04-24 `queryd/src/delta.rs` `base_rows = pre_filter_rows - delta_count` bug (86901f8) was found by a human reading the code and noticing units didn't match. The hardened mechanical applier *cannot* catch this — its gates are syntactic (warning count, patch size, rationale-token alignment) not semantic. At 100 bugs this deep, no human catches them all; the signal→commit loop is capped by what humans can notice per iteration. We already ship the primitives: `catalogd` knows column types per dataset, Arrow `RecordBatch.schema()` is on every hot-path call, `truth::evaluate()` runs arbitrary field conditions at runtime, `shared/arrow_helpers` has typed row/byte/file accessors. All of this is used at RUNTIME; none is fed into the REVIEW pipeline. Semantic flags + bug fingerprints turn the matrix index from "what review happened" (current) into "what category of bug appeared where" (compounding) — so iter-20 scrum on `crates/queryd/src/` preempts review prompts with "this crate had a row/file unit mismatch in iter 7 (delta.rs:189); check every arithmetic on `*_count` variables." Non-goals: we are NOT building a full type-inference engine (reuse Rust's `rustdoc`-level type info for structs, Arrow's schema for RecordBatch, catalogd's column types for SQL — everything beyond is Phase 3). Non-goals: this is not a linter — clippy/rustc already catch syntactic issues; this catches SEMANTIC ones (same type, wrong units/role). Bootstrap path: start with the 9 `SemanticFlag` variants above; add new variants only when a bug is found that doesn't fit an existing one. Gate alignment with hot-swap: a pathway that repeatedly produces bugs of the same `SemanticFlag` variant on the same narrow fingerprint is more valuable as a "watch this file for X" signal than as a hot-swap candidate — retirement logic needs to consider both replay success_rate AND whether the pathway is serving as a bug-pattern beacon. diff --git a/docs/MATRIX_AGENT_HANDOVER.md b/docs/MATRIX_AGENT_HANDOVER.md new file mode 100644 index 0000000..2004962 --- /dev/null +++ b/docs/MATRIX_AGENT_HANDOVER.md @@ -0,0 +1,103 @@ +# Matrix Agent Validated — Handover Notes + +**Date created:** 2026-04-25 +**Status:** active checkpoint with rolling fixes + +This doc explains the relationship between the lakehouse repo (this one) +and the standalone `matrix-agent-validated` checkpoint that was carved +out on 2026-04-25 to give a fresh Claude Code session a clean entry +point on a fresh box. + +## The two repos + +| Repo | Purpose | Branch | +|---|---|---| +| `https://git.agentview.dev/profit/lakehouse` (this) | Full project history, ~12 months, 15 crates, all phases. Source of truth for active development. | `scrum/auto-apply-19814` (PR #11) | +| `https://git.agentview.dev/profit/matrix-agent-validated` | Standalone checkpoint of the matrix-driven agent loop + Mem0-versioned pathway_memory. Single deploy unit. | `main` | + +The checkpoint repo is **not a fork** — it's a deliberate snapshot. It +carries the bare minimum needed to run the agent loop on a fresh box +with no lakehouse history baggage. Bug fixes that apply to both should +land in lakehouse first, then cherry-pick (or be re-snapshotted) to +matrix-agent-validated. + +## The Ansible playbook + +`/home/profit/handover/ansible/` on the source box (192.168.1.176) +provisions a fresh Debian 13 box end-to-end: + +``` +swap → system → postgres → minio → repo → test_data → build → services → handover_note +``` + +The `handover_note` role renders `HANDOVER.md` on the destination from +`roles/handover_note/templates/HANDOVER.md.j2` — this is THE entry-point +file a fresh Claude Code session should read first when landing on a +deployed box. If it is missing, re-run `ansible-playbook -i inventory.ini +playbook.yml --tags handover_note`. + +## Destinations — what is real, what is test + +### `matrix-test` — REAL destination +- Incus container on the source machine (192.168.1.176). +- Reachable on `10.111.129.50` (incusbr0 tunnel, used by Ansible inventory), + `192.168.2.112`, `192.168.1.32`. +- SSH: `profit:profit13`, sudo via password, key at `/root/.ssh/ironclaw`. +- Install dir: `/home/profit/matrix-agent-validated/`. +- All four services running: gateway/sidecar/observer/postgres. +- Pathway memory: 82+ traces (don't wipe `data/_pathway_memory/state.json`). +- Treat any work landing here as canonical for the checkpoint. + +### `192.168.1.145` — TEST VENV ONLY, NOT A DEPLOY TARGET +- Separate VPS, hostname `ironclaw` — that's the preinstalled + community-scripts daemon, **NOT** what this project is. +- The Ansible playbook ran here once on 2026-04-25 ~20:02 to verify + the repo would boot on a fresh box. Got partway through the `system` + role (swap + apt + ollama + bun + adduser) and stopped. +- **No matrix-agent-validated dir exists here.** No lakehouse services. + No HANDOVER.md. +- **Do not push fixes here. Do not treat it as production.** If you + find yourself debugging .145, you're in the wrong place — pivot to + matrix-test. + +## What landed today (2026-04-25 evening) + +1. **Observer health-probe bug fixed** (`mcp-server/observer.ts:645`) — + `r.json()` on the gateway's `text/plain "lakehouse ok"` response was + throwing, causing the observer service to crash-loop every 5s. + Fix: `r.ok ? r.text() : null`. Sealed in pathway_memory as + `TypeConfusion:fetch-health-json`. Committed both repos. + +2. **HANDOVER.md rendered on matrix-test** — the `handover_note` role + was previously missed; one re-run rendered the doc + backed up + `state.json` for safety. + +3. **Relevance filter shipped** — `mcp-server/relevance.ts` (heuristic + scorer) + observer `/relevance` endpoint + `scrum_master_pipeline.ts` + wiring (env opt-out via `LH_RELEVANCE_FILTER=0`, threshold via + `LH_RELEVANCE_THRESHOLD`). 9 unit tests green. Drops adjacency-pollution + chunks from matrix retrieval before the reviewer LLM sees them. + +## Still queued (from the rendered HANDOVER.md on matrix-test) + +- Audit-consensus → retire wire (auto-retire poisoned pathways when + observer rejects) +- Mode router (port LLM Team patterns from source `/root/llm_team_ui.py`) +- Pgvector backend (third option alongside Parquet + Lance, RAG/training + focused) +- Local-model scratchpad daemon (continuous summarizer for active context) + +## Commands a fresh session should run first + +```bash +# On the source box (192.168.1.176) +git -C /home/profit/lakehouse log --oneline -10 # what's recent +cat /home/profit/lakehouse/docs/MATRIX_AGENT_HANDOVER.md # this file +cat /home/profit/lakehouse/docs/SCRUM_MASTER_SPEC.md # scrum loop spec + +# On matrix-test (real destination) +ssh -i /root/.ssh/ironclaw profit@10.111.129.50 \ + 'cat /home/profit/matrix-agent-validated/HANDOVER.md' # cold-start guide +ssh -i /root/.ssh/ironclaw profit@10.111.129.50 \ + 'curl -s http://localhost:3100/health' # smoke test +``` diff --git a/docs/MODE_RUNNER_TUNING_PLAN.md b/docs/MODE_RUNNER_TUNING_PLAN.md new file mode 100644 index 0000000..3554f8e --- /dev/null +++ b/docs/MODE_RUNNER_TUNING_PLAN.md @@ -0,0 +1,114 @@ +# Mode Runner Tuning Plan + +**Date:** 2026-04-26 +**Branch:** `scrum/auto-apply-19814` (PR #11) +**Status:** Pass 5 variance test complete; conclusions locked. Implementation in progress. + +A fresh Claude session reading this + the pass5 row range in `data/_kb/mode_experiments.jsonl` should be able to continue the work without re-running anything. + +--- + +## What we set out to do + +J's directive 2026-04-26 evening: "Mode runner experiment + corpus tightening." + +Symptom in memory before the session: scrum_review's matrix corpus was kept-rate 0/2 across every call — silent failure. Question: should we tighten the corpus, build new ones, or change retrieval? + +## What we built + +Three new corpora indexed under `/vectors/index`: + +| Corpus | Builder | Docs | Chunks | Source | +|---|---|---|---|---| +| `lakehouse_arch_v1` | `scripts/build_lakehouse_corpus.ts` | 93 | 2119 | DECISIONS.md ADRs + standalone ADRs + PHASES.md + PRD.md + CONTROL_PLANE_PRD.md + SCRUM_MASTER_SPEC.md | +| `scrum_findings_v1` | `scripts/build_scrum_findings_corpus.ts` | 168 | 1260 | Past `scrum_reviews.jsonl` rows | +| `lakehouse_symbols_v1` | `scripts/build_symbols_corpus.ts` | 656 | 2470 | Regex-extracted `pub fn|struct|enum|trait` + `///` docs from `crates/**/*.rs` | + +Multi-corpus support added to the mode runner: +- `crates/gateway/src/v1/mode.rs` — `matrix_corpus` is now `Vec` (string OR array in modes.toml/JSON via `deserialize_string_or_vec`) +- Top-K retrieved from each corpus, merged by score, top 8 globally before relevance filter +- Each chunk tagged with `corpus` for telemetry +- Prompt assembly prefers `doc_id` over `source` so reviewer sees `[adr:009]` not `[lakehouse_arch]` + +Validation infra: +- `scripts/mode_pass5_variance_paid.ts` — N reps × M conditions on one file, paid model +- `scripts/mode_pass5_summarize.ts` — mean ± stddev + head-to-head wins/losses with parser handling 3 finding-table shapes (numbered, path-with-line, path-with-symbol) +- `scripts/mode_compare.ts` — extended grouping key to `mode|corpus` (sorted+joined when multiple corpora) so multi-corpus sweeps don't last-write-wins-clobber + +## What we learned + +### Single-rep bake-off (free-tier `openai/gpt-oss-120b:free`, 3 files) + +Confirmed `lakehouse_arch_v1` adds +1.7 grounded findings/file vs isolation, 100% groundedness, −20s latency. **But:** matrix slightly *hurts* on small files (273-line `delta.rs`: lakehouse 7 vs isolation 9) and unlocks +9 findings on the large file (1355-line `pathway_memory.rs`). + +`scrum_findings_v1` produced 24% out-of-bounds line citations from cross-file line-number drift — **dangerous, excluded from defaults**. Only safe with same-file gating (TBD if needed). + +### Single-rep bake-off (paid `x-ai/grok-4.1-fast`, 3 files × 4 conditions) + +Picture *flips* on a strong model. Composed corpus −1.4 grounded vs isolation. Symbols-alone slightly negative. Arch-alone negative. Suggested kitchen-sinking enrichment denigrates results when the model is good enough to handle the file directly. + +### Pass 5 variance test (paid grok-4.1-fast, 5 reps × 4 conditions on `pathway_memory.rs`) + +| Condition | n | mean grounded ± σ | range | H2H vs isolation | Δ mean | +|---|---|---|---|---|---| +| **isolation** | 5 | 6.2 ± 1.3 | [5–8] | baseline | — | +| arch_only | 5 | 5.2 ± 0.8 | [4–6] | 0W–3L–2T | −1.0 | +| symbols_only | 5 | 6.4 ± 1.5 | [4–8] | 3W–2L–0T | +0.2 | +| **composed (A+C)** | 5 | 4.4 ± 1.1 | [3–6] | **0W–5L–0T** | **−1.8** | + +**Composed loses 5/5 head-to-head against isolation on this file with this model.** Probability under random noise = 1/2⁵ = 3.1%. Statistically significant. + +Data window: rows in `data/_kb/mode_experiments.jsonl` where `ts > "2026-04-26T21:50:03Z"` and `file_path == "crates/vectord/src/pathway_memory.rs"`. Re-aggregate any time with `bun run scripts/mode_pass5_summarize.ts --since 2026-04-26T21:50:03Z`. + +## Decisions taken + +1. **Composed-corpus default is reverted.** `scrum_review.preferred_mode` switches from `codereview_lakehouse` → `codereview_isolation`. Matrix corpora stay defined in modes.toml but only fire when a caller explicitly forces `codereview_lakehouse` or one of the matrix-only experimental modes. + +2. **Model-aware enrichment downgrade (α) is wired** in `crates/gateway/src/v1/mode.rs::execute`. When a caller resolves a "strong" model AND the resolved mode is `codereview_lakehouse`, the runner downgrades to `codereview_isolation` flag-set automatically. Strong patterns: `x-ai/grok-*`, `anthropic/*`, `openai/gpt-4*`, `openai/gpt-5*`, `deepseek/deepseek-v4*`, `moonshotai/kimi-k2*`, `google/gemini-2.5*`. Override via `LH_FORCE_FULL_ENRICHMENT=1` for diagnostic runs. + +3. **`scrum_findings_v1` stays excluded from defaults** until same-file gating lands. Built and indexed; do not point any task class at it without that gate. + +## Open follow-ups (not landed in this batch) + +- **Same-file gating for `scrum_findings_v1`** — restrict retrieval to chunks where `file_path == focus_file` so cross-file line-number drift can't happen. Then it becomes a per-file "what was found before" signal. +- **Variance test on small files** — pass 5 was 1 file (the largest, where matrix-hurt was sharpest). Confirm direction holds on 273-line / 333-line files. ~15 min × 2 files = ~30 min. +- **Verify weak-model gain holds with α** — the bake-off showed matrix helps free-tier `gpt-oss-120b:free` on the large file. After α is wired, re-run on a free-tier model to confirm full enrichment still fires for it. ~5 min. +- **Higher-signal matrix (β fork)** — if we ever want matrix back as a default, it can't be whole-ADR/whole-section chunks. Better: only retrieve chunks where the focus file's defined symbols appear. Tighter signal, fewer chunks. Postponed. + +## Reference data + tools + +- **Mode-runner code:** `crates/gateway/src/v1/mode.rs` +- **Mode config:** `config/modes.toml` +- **Per-call experiment log:** `data/_kb/mode_experiments.jsonl` +- **Sweep harnesses:** + - `scripts/mode_experiment.ts` — files × modes × 1 rep (default model: `x-ai/grok-4.1-fast`) + - `scripts/mode_pass2_corpus_sweep.ts` — corpus × threshold sweep + - `scripts/mode_pass3_variance.ts` — temp × reps on one mode + - `scripts/mode_pass5_variance_paid.ts` — N reps × M conditions on one file +- **Aggregators:** + - `scripts/mode_compare.ts` — full per-mode comparison with grounding check + - `scripts/mode_pass5_summarize.ts` — variance + head-to-head, robust to 3 table shapes +- **Corpus builders (re-runnable when source docs / scrum_reviews / source code change):** + - `scripts/build_lakehouse_corpus.ts` + - `scripts/build_scrum_findings_corpus.ts` + - `scripts/build_symbols_corpus.ts` + +## Re-entry recipe (fresh session) + +```bash +cd /home/profit/lakehouse +git log --oneline scrum/auto-apply-19814 -10 # what's recent +cat docs/MODE_RUNNER_TUNING_PLAN.md # this file +bun run scripts/mode_pass5_summarize.ts --since 2026-04-26T21:50:03Z # locked result +curl -s http://localhost:3100/v1/mode/list | jq '.task_classes.scrum_review' # current config +``` + +If you want to reproduce the bake-off: + +```bash +# Strong model variance test (~17 min): +bun run scripts/mode_pass5_variance_paid.ts + +# Weak-model regression (~10 min): +LH_MODEL=openai/gpt-oss-120b:free LH_REPS=3 bun run scripts/mode_pass5_variance_paid.ts +``` diff --git a/docs/PHASES.md b/docs/PHASES.md index 69eb6c0..880c55c 100644 --- a/docs/PHASES.md +++ b/docs/PHASES.md @@ -349,6 +349,24 @@ - Per-type endpoints: `/profiles/retrieval`, `/profiles/memory`, `/profiles/observer` - `profile_type` field on ModelProfile - Guard fix: automated scrumaudit.py finds real issues +- [x] **Phase 42: Truth Layer** (2026-04-27 closure verified) + - `crates/truth/{lib,staffing,devops,loader}.rs` + - Staffing rules populated; devops scaffold by design + - `/v1/context` serves task_classes + rules; 37 tests green +- [x] **Phase 43: Validation Pipeline** (2026-04-27) + - `crates/validator/` real validators + WorkerLookup + ParquetWorkerLookup + - 500K-row workers_500k.parquet loaded at gateway boot + - `POST /v1/validate` + `POST /v1/iterate` (the 0→85% loop) + - 33 validator tests green +- [x] **Phase 44: Caller Migration** (2026-04-27) + - TS callers + aibridge::AiClient::new_with_gateway opt-in + - Vectord routed through /v1/chat for autotune + RAG + - scripts/check_phase44_callers.sh CI guard +- [x] **Phase 45: Doc-Drift Detection** (2026-04-27) + - DocRef + doc_drift module + context7 bridge + - /doc_drift/check + /scan + /resolve endpoints + - data/_kb/doc_drift_corrections.jsonl writes + - boost exclusion of unreviewed drift-flagged entries - [ ] Fine-tuned domain models (Phase 25+) - [ ] Multi-node query distribution (only if ceilings bite) diff --git a/docs/SCRUM_FIX_WAVE.md b/docs/SCRUM_FIX_WAVE.md new file mode 100644 index 0000000..2ae76a6 --- /dev/null +++ b/docs/SCRUM_FIX_WAVE.md @@ -0,0 +1,63 @@ +# Scrum Fix Wave — Phase-Sweep 2026-04-23 + +**Purpose:** Direct the scrum-master pipeline at concrete findings from the Phase 0→42 audit sweep, not at the high-level vision alone. Findings live in `data/_kb/phase_sweep_findings.jsonl` (19 items). + +## What the auditor expects you to produce per file + +For each file the scrum sees: concrete code-level suggestions that close the listed findings. Not rewrites for style. Not vision drift. Land the invariant or admit the checkbox was premature. + +## Meta-pattern to fix (read this first) + +The sweep surfaced **one root cause repeated across 5 phases**: primitives exist, cross-cutting enforcement doesn't. Auth, journal, access control, truth rules — the machinery is built, nothing calls it from the actual request path. + +One PR-cluster retires the pattern: +1. **Identity.** Auth middleware wires X-API-Key → extension `AgentIdentity { name, role, api_key_hash }`. (P5-001) +2. **Request pipeline.** `/query/sql` and `/tools/*/call` read `AgentIdentity`, pass into queryd + tools handlers. +3. **Access enforcement.** Handlers call `access.can_access()` / `masked_columns()` before returning data; log via `access.log_query()`. (P13-001) +4. **Mutation journaling.** Every ingest / delta-write / tombstone-add / catalog-register calls the corresponding `journal.record_*`. (P9-001) +5. **Truth enforcement.** `TruthStore::check()` rewritten to `evaluate(task_class, ctx) -> Vec`, actually walking `RuleCondition` against context. (P42-001, P42-002) + +After this cluster lands, Phases 5, 9, 13, 42 become "truly shipped" rather than "machinery shipped." + +## Findings by severity + +### 🔴 High + +- **P9-001** `journald/src/journal.rs`, `crates/gateway/src/main.rs`, all mutation sites. Journal has zero internal callers. Every `ingestd::service::upload_file` success, every `queryd::delta::write_delta`, every `catalogd::tombstones::add`, every `catalogd::registry::register` should emit a journal event. Plus fix: `event_counter` resets on process restart — seed from max existing `event_id` on rebuild or switch to UUID v7. +- **P13-001** `crates/gateway/src/main.rs` + `crates/queryd/src/service.rs` + `crates/gateway/src/tools/service.rs`. `AccessControl.can_access` / `masked_columns` / `log_query` have zero callers. Query path ignores role. Phase 17's `profile_scoped_search` (service.rs:1641) is the template — copy that shape. +- **P42-001** `crates/truth/src/lib.rs:56`. `TruthStore::check(task_class)` ignores `RuleCondition` entirely. Signature needs `evaluate(task_class, ctx: &serde_json::Value) -> Vec` that actually walks conditions. Update all 14 tests to exercise fail/pass semantics, not just storage. + +### 🟡 Medium + +- **P5-001** `crates/gateway/src/auth.rs` + `crates/gateway/src/main.rs:222-233`. `api_key_auth` is `#[allow(dead_code)]`. Wire with `axum::middleware::from_fn_with_state(api_key, auth::api_key_auth)` on protected routes. `/health` stays public. +- **P10-001** Legacy datasets (including `candidates`, 2.47M rows) have no PII flags. Add `POST /catalog/resync-metadata` mirroring `/catalog/resync-missing`. +- **P14-001** `crates/ingestd/src/schema_evolution.rs`. Module has 5 passing tests and zero callers. Add `POST /catalog/datasets/by-name/{name}/schema-diff`. When ADR-020 `register()` returns 409, include a `migration_rules[]` body. +- **P20-001** `config/models.json` is spec-only — never loaded by Rust. Load into `shared::model_matrix::ModelMatrix` at startup; delegate `aibridge::context::context_window_for` to matrix. +- **P21-001** `generate_continuable` has one prod caller (`rag.rs:171`). Audit every `ai_client.generate()` site. Convert the truncation-prone + thinking-empty-prone sites (auditor paths, reranker, autotune) to `generate_continuable`. +- **P39-001** `ProviderAdapter` trait + adapters ship, zero callers. `/v1/chat` in `v1/mod.rs:152` uses hardcoded `match req.provider`. Replace with adapter dispatch. +- **P40-001** `config/routing.toml` is spec-only. `RoutingEngine::new` has no callers. Add `RoutingEngine::from_toml(path)`; `V1State` carries `routing: Arc`; `/v1/chat` consults it before provider match. +- **P42-002** Truth has no enforcement site. `/v1/chat` or execution_loop should call `truth.evaluate(task_class, ctx)` post-response. + +### 🟢 Low + +- **P1-001** `crates/storaged/src/federation_service.rs:34-35`. Bucket-qualified routes wire only PUT + GET. Add DELETE + LIST on `/buckets/{bucket}/objects/{*key}`. +- **P4-001** UI deploy stale. Either rebuild (`just ui-build` + restart `lakehouse-ui.service`) or amend `PHASES.md` to note pre-Phase-9 drift. +- **P7-001** `vectord::index_registry`. Orphan index registrations (parquet deleted) still list in `/vectors/indexes`. Add a startup sweep + `POST /vectors/resync-missing`. +- **P12-001** `crates/gateway/src/tools/service.rs`. Audit row has `row_count=null`. Propagate `QueryResponse.row_count` + add `latency_ms`. +- **P20-002** `crates/gateway/src/v1/mod.rs`. No model-prefix auto-routing. Caller must set `provider` explicitly. Tie to P39-001 + P40-001 fix. +- **P21-002** `crates/aibridge/src/context.rs`. `context_window_for` hardcoded HashMap duplicates `config/models.json`. Delegate once P20-001 lands. +- **P38-001** `crates/gateway/src/execution_loop/mod.rs:1523`. Test `executor_prompt_includes_surfaced_candidates` fails on "W-1 Alice Smith" assertion. Either update prompt formatter or update test. +- **P40-002** Cost gating absent. Add `cost_ceiling_usd_per_hour` to `RoutingEngine` rule, pre-request check against `Usage.by_provider`. + +## What "done" looks like for each file the scrum touches + +- Name the specific finding(s) the file participates in. +- Show code-level diff (minimum: function signature + first 5 lines of body) for the fix. +- Call out any test that needs updating + one new test that would catch the bug on reintroduction. +- Flag if the fix is too big for one PR and should be split (most of the cross-cutting cluster wants a shared identity/middleware PR first, per-service PRs after). + +## Out of scope for this wave + +- New features beyond what the findings describe. +- UI work (Phase 4 stale is known). +- DevOps / long-horizon domain work (Terraform/Ansible — Phase 43+). diff --git a/docs/SCRUM_FORENSIC_PROMPT.md b/docs/SCRUM_FORENSIC_PROMPT.md new file mode 100644 index 0000000..e4c258f --- /dev/null +++ b/docs/SCRUM_FORENSIC_PROMPT.md @@ -0,0 +1,198 @@ +# Scrum Master PR Loop — Forensic Validation Prompt (iter 2+) + +Adopted 2026-04-23 from J. Replaces the default scrum prompt starting iter 2. Iter 1 used the softer "fix-wave" framing; iter 2 onward uses this adversarial one. + +--- + +You are acting as an adversarial **Scrum Master + Systems Auditor**. + +Your job is to **prove whether this system actually works**, not to describe it. + +You are auditing a system with the following architecture: + +- AI Gateway with per-model adapters +- Output normalization + schema validation layer +- Execution pipeline (Terraform / Ansible / shell) +- Task-scoped execution memory (S3 + Apache Arrow/Parquet) +- Relevance orchestration (context filtering, freshness validation, fact extraction) +- Local → Cloud fallback loop for failed tasks +- Iterative repair loop with stored execution evidence + +--- + +## PRIMARY OBJECTIVE + +Determine if the system is: + +1. Executable (real, not pseudocode) +2. Aligned with PRD contracts +3. Deterministic enough to trust +4. Protected from model output drift +5. Actually closing the loop (fail → repair → reuse) + +--- + +## NON-NEGOTIABLE RULES + +- Do NOT summarize +- Do NOT explain architecture unless tied to failure +- Do NOT assume code works — verify +- Every claim MUST reference files, functions, or execution evidence +- If something is unclear → mark as FAIL + +--- + +## AUDIT PASSES (RUN ALL) + +### 1. PSEUDOCODE / FAKE IMPLEMENTATION DETECTION +Find any: +- TODO / stub / placeholder +- hardcoded outputs where AI should decide +- mocked execution paths +- fake success returns + +Output exact file + line references. + +### 2. PRD CONTRACT VALIDATION +Verify implementation exists for: + +- Gateway routing logic +- Per-model adapters +- Output normalization (strip, parse, canonicalize) +- Schema validation layer +- Repair loop (retry with modification) +- Raw output storage +- Execution memory persistence +- Retrieval based on prior failures +- Relevance filtering (freshness / protocol awareness) +- Execution permission gate + +For each component: +- status: implemented | partial | missing +- include file references + +### 3. NORMALIZATION + VALIDATION PIPELINE +Prove that: + +- Raw model output is NEVER executed directly +- JSON extraction is enforced +- Unknown fields are rejected or handled +- Schema validation blocks bad output +- Repair loop triggers on failure + +If any path bypasses validation → FAIL + +### 4. FAILURE → CLOUD → REPAIR LOOP +Trace the loop: + +- Local model fails +- Failure is classified +- Context is packaged +- Cloud model returns corrective instruction +- Local model retries +- Result is validated +- Successful pattern is stored + +If any step is missing or non-deterministic → FAIL + +### 5. EXECUTION MEMORY (S3 / ARROW) +Verify: + +- Raw runs are stored (input, raw output, normalized output) +- Failures are recorded with signatures +- Successful retries are recorded +- Retrieval pulls based on: + - task similarity + - failure signature + - execution success history + +If memory is only logs and not reused → FAIL + +### 6. RELEVANCE ORCHESTRATION +Verify: + +- Context is filtered before model input +- Freshness or version awareness exists +- Fact extraction reduces noise +- Context inclusion is explainable + +If system blindly injects context → FAIL + +### 7. EXECUTION SAFETY +Verify: + +- No shell / terraform / ansible execution without validation gate +- No direct model-to-command execution +- Clear permission boundary exists + +If AI can execute commands unchecked → CRITICAL FAIL + +### 8. TESTING + EVIDENCE +Find: + +- real tests (not mocks) +- execution logs +- validation results +- success/failure traces + +If no proof of execution → FAIL + +--- + +## OUTPUT FORMAT (STRICT) + +Each finding in any array MUST include a `confidence` field (integer 0–100). The confidence represents your self-assessed probability that the finding is correct and actionable. Low confidence is valuable — do not inflate. A finding with confidence < 50 is still recorded (it signals investigation needed) but downstream consumers will weight it less. + +```json +{ + "verdict": "pass | fail | needs_patch", + "critical_failures": [ + {"id": "CF-1", "file": "path:line", "description": "...", "confidence": 95} + ], + "pseudocode_flags": [ + {"file": "path:line", "reason": "...", "confidence": 88} + ], + "prd_mismatches": [ + {"component": "...", "status": "partial|missing", "file_ref": "...", "confidence": 80} + ], + "broken_pipelines": [ + {"pipeline": "...", "break_point": "...", "confidence": 70} + ], + "missing_components": [ + {"component": "...", "required_by": "PRD section X", "confidence": 85} + ], + "risk_points": [ + {"area": "...", "risk": "...", "confidence": 60} + ], + "verified_components": [ + {"component": "...", "evidence": "file:line or test name", "confidence": 95} + ], + "evidence": { + "files_inspected": [], + "execution_paths_traced": [], + "tests_found": [], + "tests_missing": [] + }, + "required_next_actions": [ + {"action": "...", "file_hint": "...", "confidence": 75} + ] +} +``` + +**Calibration guide:** +- 90–100: pattern seen repeatedly in shipped code; mechanical; low regression risk +- 70–89: confident in direction, API shape or naming may vary +- 50–69: plausible fix but may not match conventions, could cascade +- <50: genuinely uncertain — record anyway so downstream knows to investigate + +--- + +## FINAL DIRECTIVE + +You are not reviewing code. + +You are answering: + +> "Can this system be trusted to execute real-world DevOps tasks without hallucinating, bypassing validation, or collapsing under edge cases?" + +If the answer is not provably yes, the verdict is FAIL. diff --git a/docs/SCRUM_LOOP_NOTES.md b/docs/SCRUM_LOOP_NOTES.md new file mode 100644 index 0000000..85a5765 --- /dev/null +++ b/docs/SCRUM_LOOP_NOTES.md @@ -0,0 +1,95 @@ +# Scrum Loop Notes — Observations across iterations + +Running notes from the 6x scrum loop (started 2026-04-23). One section per iteration. "Fix next loop" items accumulate here so the next scrum run picks them up — do not fix inline during a running iteration. + +## Iteration tracker + +| Iter | Status | Scrum started | Scrum finished | Fixes applied | Build green | Re-sweep findings | +|---|---|---|---|---|---|---| +| 1 | 🟡 scrum running | 2026-04-23 (brqz3jxgo) | - | - | - | - (baseline = 19) | +| 2 | 🟡 scrum running | 2026-04-23 (bzs6miehr) | - | - | - | pending | +| 3 | ⬜ queued | - | - | - | - | - | +| 4 | ⬜ queued | - | - | - | - | - | +| 5 | ⬜ queued | - | - | - | - | - | +| 6 | ⬜ queued | - | - | - | - | - | + +## Iteration 1 — in flight + +**Target files:** 21 source files extracted from the 19 Phase 0→42 findings. +**Ladder:** cloud-first per feedback_scrum_cloud_first.md (gpt-oss:120b → qwen3.5:397b → devstral-2:123b → mistral-large-3:675b → gpt-oss:20b → qwen3.5:latest). +**Proposal:** `docs/SCRUM_FIX_WAVE.md` (via LH_SCRUM_PROPOSAL env). + +### Fix next loop — observations accumulating + +*Add items here as the scrum runs. Keep each item to one line with a pointer to file + reason. Don't fix inline.* + +**[ITER 2 OBSERVATIONS]** +- **[FORENSIC vs thin-detector mismatch]** iter 2 first attempt on auth.rs triggered "thin/unstructured" rejection at 2031 chars. Cause: forensic prompt asks for strict JSON verdict output, scrum's thin-answer detector expects markdown with score + table. The detector logic needs a forensic-aware branch OR the forensic prompt should preserve markdown output shape while still applying the 8 audit passes. File: `tests/real-world/scrum_master_pipeline.ts`, function that scores accepted vs thin. Fix next loop: add `isForensicAcceptable(text)` that checks for `"verdict"` field + at least one of `critical_failures`/`pseudocode_flags`/`required_next_actions`. + +- **[OBSERVATION metric]** 11 `#[allow(dead_code)]` markers cluster in crates/gateway/{auth,access,tools/registry,execution_loop,v1/truth} + crates/aibridge/providers/openrouter + crates/vectord/service. Each one maps cleanly to an audit finding. The `execution_loop/mod.rs:85` comment even admits it: `// reserved for Phase 42 truth-gate (step 6)`. **Metric:** fewer `#[allow(dead_code)]` markers per iteration = less pseudo-real code. Baseline = 11. Target after iter 6: ≤ 2 (only ones that are genuinely optional helpers). +- **[OBSERVATION gateway-as-router]** scrum_master_pipeline currently fetches `GATEWAY/v1/chat` directly but its LADDER is still a hardcoded const. Should be driven by `config/routing.toml` via RoutingEngine (blocked by P40-001 until iter 1 lands fix). File: `tests/real-world/scrum_master_pipeline.ts:53`. +- **[OBSERVATION file-type]** iter 1 target list is `.rs` only. Iter 2 must include `tests/multi-agent/*.ts` (executor, observer, kb consumer), `auditor/checks/*.ts`, `sidecar/sidecar/*.py`, and `config/*.{json,toml}`. The scrum pipeline handles any text file. +- **[OBSERVATION triangulation]** auth.rs scrum review (first file out) independently identified P5-001 exactly: flagged `#[allow(dead_code)]`, scored alignment 4/10, prescribed an `AgentIdentity { name, role, hashed_key }` type matching SCRUM_FIX_WAVE. Audit + scrum converged without seeing each other's output — strong signal the findings are real, not artifacts of one method. +- **[RULE from J 2026-04-23]** Wiring-gap fixes happen AFTER the scrum completes, not inline. Accumulate observations, apply in one coherent pass. Matches feedback_audit_findings_log.md. +- **[OBSERVATION oversize-file]** `crates/gateway/src/execution_loop/mod.rs` is 80,901 chars → 24 shards (scrum pipeline's tree-split kicks in at 6KB threshold). A single-file-of-this-size for an execution module is itself a smell — it's the Phase 43 scaffold we kept piling into. Split candidates: executor prompts, reviewer prompts, budget accounting, truth-gate hook, fixtures. Not a fix for this iter, but queue for iter 3. +- **[OBSERVATION cost-tracking]** zero escalations across first 8 files — 0.0 dollar cloud spend above the minimum. Per-request cost on gpt-oss:120b via Ollama Cloud is effectively $0 in this environment (self-hosted or flat-rate per the llm_team_config key). If we add per-iter token totals to scrum_loop_metrics.jsonl we can show trajectory even when cost is flat. + +**[ITER 3 OBSERVATIONS]** +- **[LARGE-HANDLER thin]** kimi-k2:1t went thin on `crates/gateway/src/tools/service.rs` (~11KB, single large axum handler). deepseek-v3.1:671b rescued on attempt 2 (92.8s, 5408 chars, accepted). Pattern: very large routing files challenge even 1T models. Fix next loop: raise tree-split threshold for handler files OR shard by function boundaries not byte count. +- **[WRITE-ONLY INDICATORS STILL]** 8 KB files write-only after iter 3: `audits.jsonl` (189 rows/1.9MB — biggest waste), `phase_sweep_findings.jsonl` (35), `distilled_facts.jsonl` (17), `human_overrides.jsonl` (8), `classifications.jsonl` (5), `scrum_loop_metrics.jsonl` (2), `distilled_config_hints.jsonl` (2), `distilled_procedures.jsonl` (2). Fix next loop: extend `auditor/checks/kb_query.ts` to surface these on PR review, OR build a single "KB health dashboard" reader. +- **[ISOLATED AUTOTUNE]** `crates/vectord/src/agent.rs` has zero refs to scrum/audit/human_override KB. It tunes HNSW but doesn't know which indexes are attached to files the scrum flagged. Fix next loop: add `TriggerEvent::CodeReviewFlag { index_name, gradient_tier }` that biases trial budget toward indexes of flagged files. +- **[CONFIDENCE WELL-CALIBRATED]** kimi-k2:1t confidences span 75-98 across iter3 files, cluster 85-95. No 100% inflation; min 75 = honest edge-case uncertainty. Good signal — the model is calibrating, not performance-signaling. Do NOT "fix" this by prompt-boosting confidence. +- **[SCRUM→OBSERVER WIRED]** 2026-04-24 fix landed in iter-3 source but applies to iter 4+ (bun loaded code pre-edit). Verify next loop: `curl :3800/stats` should show `by_source.scrum > 0` after iter 4 runs. If zero, observer /event payload schema mismatch. +- **[LOW-CONFIDENCE BLOCK flag WORKING]** `crates/storaged/src/federation_service.rs` scored 3/10 with confidences **[40, 35, 50]** → avg 42, min 35. Permission Gradient correctly classifies this file as `block` tier (min <50) — exactly the signal we want. kimi-k2:1t is honestly saying "I'm not confident about these suggestions." Human must review before any auto-apply. Validates Layer #6 working end-to-end. **DO NOT fix this** — it's the system protecting us. +- **[CONFIDENCE-COLUMN DROPOUT]** `crates/gateway/src/main.rs` accepted review has 0 confidences extracted despite the prompt requiring them. Either kimi-k2:1t omitted the Confidence column in its table format (regex didn't match), or the specific content ran into token budget and confidence got trimmed. Fix next loop: strengthen the prompt instruction to say "if you omit the Confidence column you MUST provide Confidence: NN% inline after every suggestion" AND post-accept sanity-check the row (reject if findings_count=0 across 5+ suggestions). +- **[SCORE-PARSER MISS on some files]** `crates/queryd/src/service.rs` and `crates/queryd/src/delta.rs` reviews return score='?' — regex `(\d)\s*/\s*10` isn't matching. Models may have written score as "Score: 4.5/10" or "4/10 (mid)" which the parser can't see. Fix next loop: regex accepts decimals + surrounding context. Not critical — confidences still landed. +- **[SCORE DISTRIBUTION]** across 12 iter-3 files: 3/10 (7 files), 4/10 (2), 6/10 (1), ?/? (2). vectord/index_registry.rs alone scored 6/10 — meaningfully higher. That's worth a closer look: what does that file do right? If we find the pattern there and replicate to peers, scores should rise. This is learning-loop signal. + +- **[FORENSIC JSON OUTPUT IS RICHER THAN MARKDOWN]** kimi-k2:1t emitted strict JSON-schema output (matching SCRUM_FORENSIC_PROMPT.md) for `vectord/src/index_registry.rs`. Structure separates critical_failures / pseudocode_flags / prd_mismatches / broken_pipelines / missing_components / risk_points / **verified_components** / required_next_actions — each with confidence per entry. Markdown reviews never captured `verified_components` (what's confirmed working). Fix next loop: scrum pipeline detects JSON format in accepted output and extracts structured fields into KB row (`verified_components_count`, `critical_failures_count`, `missing_components_count`, `verdict`). Downstream consumers then filter PR files by `verdict: needs_patch` or prioritize by `missing_components_count`. **This is the biggest next-iter KB quality jump available** — goes from "confidence as a scalar" to "confidence per specific claim with evidence field." Verified_components in particular is the PROOF-OF-LIFE signal that tells us what's real — flipside of P9/P13/P42 gaps. + +- **[🔴 TREE-SPLIT REVIEW SHARD-LEAKAGE]** `ingestd/src/service.rs` (7 shards, 24.3KB) accepted output is titled "Forensic Audit Report – ... (shard 3)". The review covers only the Postgres-import path (shard 3). The `ingest_file` handler where my P9-001 fix lives (journal.record_ingest call) is in shard 1 or 2 — that reviewer never saw the fix. **`tree_split_fired: true` is supposed to mean the output is the reducer-merged summary of all shards**, but this review retained shard-specific scope. Either (a) the reduce step didn't integrate shard summaries, (b) the accepted attempt was one individual shard response that slipped past the reducer, or (c) the reducer prompt doesn't instruct the model to present the file holistically. **This is a real correctness bug** — it means file-level findings can be ghost-negative (fix applied, reviewer blind to it) and ghost-positive (gap exists in unreviewed shard, reviewer gives clean bill). Fix next loop: examine the reduce-step prompt in tree-split path, ensure accepted output comes from reduce step not from any individual shard. Validate by running on a file with a known fix and confirming the review notices it. + +**[ITER 4 OBSERVATIONS]** +- **[🔴 OBSERVER DROPS SCRUM RICH FIELDS]** Scrum→observer wiring works (by_source.scrum appears in /stats on iter 4 file 1). BUT observer.ts:262-283 `ObservedOp = {...}` literal only spreads known keys (endpoint, success, duration_ms, role, city, state, count, rescue_*). My scrum-specific fields (confidence_avg, confidence_min, gradient_tier, verdict, critical_failures_count, verified_components_count, missing_components_count, alignment_score, output_format, findings_count, attempts_made, thin_rejections) are silently discarded. Observer knows the scrum event happened but loses review-quality data. Fix next loop: add `metadata?: Record` passthrough on ObservedOp, or declare scrum-specific fields explicitly. Preferred: metadata passthrough so future sources (auditor, kb_extractor) land the same way. +- **[SCHEMA V4 LANDING CORRECTLY]** main.rs iter-4 KB row has alignment_score=3 (decimal parser fixed), output_format="markdown" (classifier works), verdict=null (correct — only forensic_json produces verdict), confidence_avg=91 (previous iter got 0 due to column dropout — run-to-run variance self-healed this). Structured counters (critical/verified/missing) = 0 on markdown rows, populated on forensic_json rows. +- **[RING BUFFER EVICTING LANGFUSE]** observer ring hit 2000 cap; first 2 scrum events pushed 2 langfuse entries out (1999 → 1997). Not a bug — ring works as designed — but means old-context retention is bounded. If we care about historical Langfuse traces we need a larger ring OR a separate per-source ring. +- **[UI Playwright probe found 2 real bugs]** (fixed 2026-04-24): (a) ui/server.ts tryFetch relied on content-type header to decide JSON vs text; observer Bun.serve returns JSON without `application/json` content-type, so stats were strings — UI showed "0 ops" instead of 2000. Fixed: always attempt JSON.parse, fall back to raw text. (b) ui.js renderNodeContext used Object.entries(n.health) which iterates characters on a string — gateway /health returns "lakehouse ok" and the panel showed rows like `0=l, 1=a, 2=k, ...`. Fixed: primitive-vs-object guard. **Both were invisible in functional tests — only a real browser render exposed them.** Worth adding a Playwright smoke test to CI for any future UI changes. + +### Iter 1 results + +*Populated after scrum finishes.* + +## Iteration 2 — queued + +**Prompt shape change (from J 2026-04-23):** iter 2+ uses `docs/SCRUM_FORENSIC_PROMPT.md` as the system prompt, replacing the softer iter-1 framing. Adversarial auditor tone with 8 audit passes. Strict JSON output format with `verdict: pass|fail|needs_patch`. If system can't prove itself, verdict is FAIL. + +**Scrum pipeline change:** `scrum_master_pipeline.ts` needs an env `LH_SCRUM_SYSTEM_PROMPT` (new) to inject the forensic frame alongside the proposal doc. The file-level loop still asks for suggestions per file but under the 8-pass adversarial lens. + +**Goal:** Self-host. Pipeline loads its ladder from `config/routing.toml` via the RoutingEngine that iter 1 wired. If that still isn't loaded, note gap, proceed with hardcoded ladder, flag for iter 3. +**Target expansion:** beyond `.rs` to `.ts` (tests/multi-agent, auditor/), `.py` (sidecar), `.md` (docs). + +## Iterations 3-6 — queued + +**Goal:** measure trajectory. Each iteration reduces finding count, raises unit test count, reduces grep-for-fake-markers count. If any iteration doesn't improve, that's the data point. + +## Metrics per iteration + +Capture after each re-sweep: + +- `findings_total` (baseline: 19) +- `findings_by_severity` (baseline: 3h / 8m / 8l) +- `phases_partial_count` (baseline: 9) +- `phases_real_count` (baseline: 25 of 35) +- `rust_test_count` (baseline: 194+) +- `gateway_test_fail_count` (baseline: 1 — P38-001) +- `grep_hits_unimplemented` run: `grep -rEc 'todo!\(\)|unimplemented!\(\)|FIXME' crates/` +- `grep_hits_pseudo` run: `grep -rEc '\"placeholder\"|\"stub\"|\"mock\"|\"fake\"' crates/` + +## Rules for this loop + +1. **Cloud-first for every iteration.** Per feedback_scrum_cloud_first.md, strategic review uses 120B+ tier. +2. **One cross-cutting PR per iteration when possible.** Meta-pattern from audit: identity+auth+access+journal+truth share a pipe. Fix them together. +3. **Build must be green before next iteration starts.** A broken build is evidence the last iteration regressed, not progressed. +4. **Log findings to the jsonl as new rows per iteration** with `sweep_id: phase_sweep_2026-04-23-iterN`. Never overwrite prior iteration's findings — the trajectory is the whole point. +5. **Don't fix things during an iteration.** Every observation goes into "Fix next loop" section above. Next iteration's scrum picks them up. + diff --git a/docs/SCRUM_MASTER_SPEC.md b/docs/SCRUM_MASTER_SPEC.md new file mode 100644 index 0000000..50f52c6 --- /dev/null +++ b/docs/SCRUM_MASTER_SPEC.md @@ -0,0 +1,335 @@ +# Scrum Master Pipeline — Spec + Current State + +**Status:** Active iteration on branch `scrum/auto-apply-19814` → PR #11 at git.agentview.dev/profit/lakehouse +**Branch commit head:** see `git log --oneline -1 scrum/auto-apply-19814` (auto-stale; check it) + +> **2026-04-25 — see also `docs/MATRIX_AGENT_HANDOVER.md`** for the +> standalone `matrix-agent-validated` repo split + the Ansible playbook +> that deploys it. Note: VPS at 192.168.1.145 is a TEST VENV ONLY +> (partial deploy); the real destination is the `matrix-test` Incus +> container at 10.111.129.50. + +This doc is the single handoff artifact for the scrum-master + auto-apply + pathway-memory loop. A fresh Claude Code session reading this + `docs/DECISIONS.md` (ADR-020 and ADR-021) + `docs/MATRIX_AGENT_HANDOVER.md` + `MEMORY.md` should have the same context as the session that wrote it. + +## ▶ Refactor timeline (read in order) + +The pipeline has been refactored substantially since the 2026-04-24 +baseline below. Read the changes top-down to understand current shape: + +### 2026-04-23 → 24 (foundation, captured in §1-§12 below) +- 9-rung cloud ladder + tree-split + adversarial prompt +- Pathway memory base + ADR-021 semantic-correctness layer +- Hardened auto-applier (5 gates: confidence/size/cargo/warnings/rationale) +- Hand-review wire (commit `3f166a5`) — judgment moved out of inner loop +- Anchor-grounding post-verifier (commit `9cc0ceb` / `9ecc584`) +- Single-model retry with enrichment (commit `d187bcd`) — stop cascading on quality +- Unified matrix retriever pulling from ALL KB corpora (commit `a496ced`) +- Paid OpenRouter ladder + Kimi K2.6 + Gemini 2.5 (commit `4ac5656`) +- Goal-driven autonomous loop harness (commit `e79e51e`) + +### 2026-04-25 → 26 morning (mode-runner experiment wave) +- **Observer health-probe TypeConfusion fix** (`54689d5`) — `r.json()` on text/plain `/health` was crash-looping the observer; sealed in pathway_memory as `TypeConfusion:fetch-health-json`. +- **Adjacency-pollution relevance filter** (`0115a60`) — observer `/relevance` endpoint + scrum wiring (`LH_RELEVANCE_FILTER` / `LH_RELEVANCE_THRESHOLD`). Drops chunks about symbols the focus file IMPORTS but doesn't define. +- **Audit-consensus → retire wire** (`626f18d`) — when observer rejects a hot-swap-recommended attempt, immediately call `/vectors/pathway/retire` on the trace. `HotSwapCandidate` gained `trace_uid` for single-trace precision. Confidence ≥0.7 gate avoids retiring on heuristic-fallback verdicts. +- **`/v1/mode` router phase 1** (`d277efb`) — task_class → mode/model decision endpoint with `config/modes.toml`. Decision-only; doesn't execute. +- **Native enrichment runner** (`86f63a0`) — `codereview_lakehouse` mode that COMPOSES every primitive (focus file + bug fingerprints + relevance-filtered matrix + adversarial framing) into ONE prompt for one-shot success. `POST /v1/mode/execute`. Modes-as-prompt-molders, not model-pickers — see ★ Insight from session 2026-04-26. +- **Parameterized runner + 5 experiment modes** (`7c47734`) — `codereview_lakehouse|null|isolation|matrix_only|playbook_only`. Each isolates one architectural axis. `scripts/mode_experiment.ts` sweeps files × modes; `scripts/mode_compare.ts` aggregates with grounding check (catches confabulation by comparing cited symbols to real file content). +- **Scrum mode-runner fast path** (`7c47734`) — gated by `LH_USE_MODE_RUNNER=1`, scrum tries `/v1/mode/execute` BEFORE the 9-rung ladder. Falls through to ladder if response < `LH_MODE_MIN_CHARS` or anything errors. Off by default until A/B-validated. +- **Mode-compare grounding column** (`52bb216`) — emoji-tolerant section regex + control-flag tagging. Caught `playbook_only` confabulation that hand-grading also found. + +### 2026-04-26 evening (productization wave) +- **Override knobs + staffing native runner** (`56bf30c`) — pass 2/3/4 harnesses, mode runner now serves `staffing.fill` task class natively, not just code review. +- **Multi-corpus runner + variance harness + strong-model downgrade gate** (`2dbc8db`) — three corpora (arch / findings / symbols) selectable per mode. Paid models auto-downgrade: skip matrix corpus, isolation framing only. Driven by `feedback_composed_corpora_anti_additive.md` (composed corpora LOST 5/5 vs isolation on grok-4.1-fast, p=0.031). +- **OpenAI-compat alias + smart provider routing** (`3a0b37e`) — gateway is now a drop-in middleware for any OpenAI SDK consumer. Three routing flavors verified via `/tmp/archon-test/sdk-test.ts`: `openai/gpt-4o-mini`, bare `gpt-4o-mini`, `x-ai/grok-4.1-fast`. +- **OpenAI multimodal content shape** (`540a9a2`) — accepts `content: [...]` array-of-parts. +- **`/v1/chat` fires observer event** (`d1d97a0`) — every chat call now lands both Langfuse trace AND observer `/event` (was Langfuse only). +- **Archon workflow** (`69919d9`) — `.archon/workflows/lakehouse-architect-review.yaml`. 3 Pi nodes (shape → weakness → improvement) using `openrouter/x-ai/grok-4.1-fast` through the gateway. +- **Observer KB enrichment preamble** (`d9bd4c9`) — observer prepends KB context to escalation prompts (was raw failure cluster). +- **Observer escalation → paid OpenRouter** (`340fca2`) — `deepseek-v3.1-terminus` instead of free-tier rescue. Verified: diagnoses cite architectural patterns (circuit breaker, adapter files) instead of generic timeouts. +- **Gold-standard answer corpus** (`0844206`) — `scripts/build_answers_corpus.ts` indexes `lakehouse_answers_v1` from `scrum_reviews.jsonl + observer_escalations.jsonl`. Doc ID prefixes (`review:` vs `escalation:`) let consumers same-file-gate or broaden. Auto-rebuilds from scrum epilogue (`LH_SCRUM_SKIP_ANSWERS_REBUILD=1` to disable). Observer `buildKbPreamble` now blends three sources (pathway + arch + answers); preamble grew 416 → 727 chars. + +### Verified live state (2026-04-26 ~23:30) +- Pathway memory: **88 traces, 11/11 successful replays = 100%** — hot-swap probation gate crossed; live recommendations firing. +- Strong-model auto-downgrade verified: scrum on grok-4.1-fast → matrix corpus dropped, isolation mode auto-selected, 3 files accepted on attempt 1, ~27s each. +- Auditor verdict on PR #11 head `0844206`: **block** on 8 false positives — `auditor/checks/static.ts:117` "field added but never read" check doesn't follow serde derives. Fix is in the auditor, not the code. + +### Verified architectural insights (2026-04-26 experiment) +- `codereview_lakehouse` produces 100% grounded findings, beats every challenger. +- `codereview_playbook_only` (pathway-only, no file content) confabulates ~50% of findings — keep as control, NEVER as recommendation. +- `codereview_null` (no enrichment, generic prompt) produces 0 ranked findings — adversarial framing is load-bearing. +- Matrix corpus contributes ~2 grounded findings vs isolation. Small but real. + +### Where to read what +- **Loop architecture (this doc, §1-§12):** original 2026-04-24 design. +- **Modes-as-enrichment vision:** `crates/gateway/src/v1/mode.rs` doc comment + `config/modes.toml`. +- **Mode experiment results:** `data/_kb/mode_experiments.jsonl` + `bun run scripts/mode_compare.ts`. +- **Pathway memory mechanics:** `crates/vectord/src/pathway_memory.rs` + ADR-021 in `docs/DECISIONS.md`. +- **Handover to fresh box:** `docs/MATRIX_AGENT_HANDOVER.md`. + +## 1. What the loop is + +An autonomous review-and-commit pipeline that: + +1. **Scrum master** (`tests/real-world/scrum_master_pipeline.ts`) — walks a target-file list, asks a 9-rung escalation ladder of cloud models to produce a forensic audit against PRD + a change proposal doc, retries with learning context until acceptance, emits a structured review row. +2. **Pathway memory** (`crates/vectord/src/pathway_memory.rs`) — stores the full backtrack context of each review (attempts, KB chunks, flags, bug fingerprints) indexed by a narrow fingerprint (`task_class + file_prefix + signal_class`). On every new review, it prepends historical bug patterns as a preamble so the reviewer preempts recurrences. Retired pathways auto-exclude themselves from hot-swap eligibility. +3. **Auto-applier** (`tests/real-world/scrum_applier.ts`) — filters schema_v4 review rows by gradient_tier + confidence, asks `qwen3-coder:480b` for concrete `old_string/new_string` patches, runs `cargo check --workspace`, commits on green OR reverts on red/warning-count-up/rationale-mismatch. +4. **Observer** (`mcp-server/observer.ts`) — receives per-file `/event` emissions, escalates failure clusters to LLM Team via `/v1/chat` with `qwen3-coder:480b`. +5. **Auditor** (`auditor/audit.ts`) — external N=3 consensus re-check of scrum findings; writes to `data/_kb/audit_facts.jsonl`. + +The guiding principle: **every KB write has a reader, every PR claim is diff-verifiable.** + +## 2. The 9-rung ladder (cloud-first, strongest-model-first) + +Defined in `tests/real-world/scrum_master_pipeline.ts` at `const LADDER`: + +| # | Provider | Model | Role | +|---|---|---|---| +| 1 | ollama_cloud | `kimi-k2:1t` | flagship, 1T params | +| 2 | ollama_cloud | `qwen3-coder:480b` | coding specialist, 480B | +| 3 | ollama_cloud | `deepseek-v3.1:671b` | reasoning, 671B | +| 4 | ollama_cloud | `mistral-large-3:675b` | deep analysis, 675B | +| 5 | ollama_cloud | `gpt-oss:120b` | reliable workhorse | +| 6 | ollama_cloud | `qwen3.5:397b` | dense 397B, final thinker | +| 7 | openrouter | `openai/gpt-oss-120b:free` | free-tier rescue | +| 8 | openrouter | `google/gemma-3-27b-it:free` | fastest rescue | +| 9 | ollama | `qwen3.5:latest` | last-resort local | + +**Each attempt is evaluated by `isAcceptable()`** (chars ≥ 3800 AND not a malformed JSON-only dump). On reject, the next rung sees a learning preamble with the prior rejection reason. + +## 3. Tree-split reducer + +Files larger than `FILE_TREE_SPLIT_THRESHOLD = 6000` bytes get chunked into `FILE_SHARD_SIZE = 3500`-byte shards. Each shard gets summarized via a fast rung, summaries are concatenated with internal `§N§` markers, then fed as a SCRATCHPAD to the reviewer. The `§N§` markers are stripped before the reviewer sees the merged context so it cannot claim "(shard 3)" in titles. + +Bug regime this fixed: pre-tree-split iters had reviewers claim fields were "missing" because the field was past the 6KB context cutoff, not actually absent. + +## 4. Schema v4 KB rows + +`data/_kb/scrum_reviews.jsonl` — one row per accepted review. Fields: + +```json +{ + "file": "crates/queryd/src/service.rs", + "reviewed_at": "2026-04-24T11:06:56Z", + "accepted_model": "ollama_cloud/kimi-k2:1t", + "accepted_on_attempt": 1, + "attempts_made": 1, + "tree_split_fired": true, + "suggestions_preview": "", + "confidences_per_finding": [92, 90, 88, 85, 75], + "confidence_avg": 86, + "confidence_min": 75, + "findings_count": 5, + "gradient_tier": "dry_run", // auto ≥90 / dry_run ≥70 / simulation ≥50 / block <50 + "gradient_tier_avg": "dry_run", + "alignment_score": 3, // 1-10 self-rated + "output_format": "forensic_json", + "verdict": "fail", // pass | needs_patch | fail + "critical_failures_count": 3, + "pseudocode_flags_count": 0, + "prd_mismatches_count": 4, + "missing_components_count": 6, + "verified_components_count": 2, + "risk_points_count": 3, + "schema_version": 4, + "scrum_master_reviewed": true, + // ADR-021 fields on pathway trace (NOT this row, see pathway_memory state.json) + "pathway_hot_swap_hit": false, + "pathway_id": null, + "pathway_similarity": null, + "pathway_success_rate": null, + "rungs_saved": 0 +} +``` + +## 5. Applier hardened gates (landed 5e8d87b) + +`tests/real-world/scrum_applier.ts` has **5 gates** between emitter output and commit. A patch must pass ALL: + +1. **Confidence gate** — emitter's self-reported `confidence >= MIN_CONF` (default 90; 85 with relaxed env). Rejected patches log reason `confidence NN < MM`. +2. **Size gate** — max 6 lines changed per patch. Prevents cascading cross-file refactors. +3. **Cargo-green gate** — `cargo check --workspace` must pass. Red build → `git checkout -- file`. +4. **Warning-count gate** — workspace baseline warning count measured at start; after patch, new count must be `≤ baseline`. Catches unused-import additions and dead_code-after-allow-removed patterns. **THIS GATE CAUGHT 96b46cd's HashSet noise.** +5. **Rationale-diff token alignment** — rationale text must share at least one non-stopword token with the patch's new_string. Catches "Add destructive SQL filter" claims on `use tracing;` diffs. + +Plus: +- **Deny-list**: `config/`, `ops/`, `auditor/`, `docs/`, `data/`, `mcp-server/`, `ui/`, `sidecar/`, `scripts/` can't be auto-applied (human review required). +- **Branch guard**: refuses to run on `main`. +- **Dry-run workspace revert**: in `COMMIT=0` mode, file is reverted after check regardless of outcome — no state pollution between runs. + +Every decision logs to `data/_kb/auto_apply.jsonl` (action: `committed` / `build_red_reverted` / `warnings_increased_reverted` / `rationale_mismatch_reverted` / `all_rejected` / `no_patches` / `dry_run_would_commit`). + +## 6. Pathway memory (ADR-021) + +**Full spec: `docs/DECISIONS.md` ADR-021. Code: `crates/vectord/src/pathway_memory.rs`.** + +Three-layer matrix index for compounding semantic-correctness signal: + +### Fingerprint (narrow) +`pathway_id = SHA256(task_class + "|" + file_prefix + "|" + signal_class)` — first 2 path segments (`crates/queryd`) so related files in the same crate share pathways. + +### Embedding (similarity vector) +32-bucket L2-normalized token hash. Tokens include: task_class, file_path, signal_class, per-attempt model+rung+accepted flag, KB chunk source_docs, observer class, bridge libraries, sub-pipeline calls, **semantic_flags**, and **bug_fingerprints (flag+pattern_key)**. + +**TS and Rust implementations byte-match** — verified by smoke test showing cosine=1.0 on same input tokens. This is load-bearing for the TS-written traces to be searchable against the Rust-indexed space. + +### Hot-swap gate (5-factor AND) +``` +narrow_fingerprint_matches +AND audit_consensus.pass != false (null OK during bootstrap) +AND replay_count >= 3 (probation) +AND success_rate >= 0.80 +AND NOT retired +AND similarity(query_vec, stored.pathway_vec) >= 0.90 +``` + +Replay bookkeeping: on hot-swap, `replay_count++`; if the recommended model succeeded, `replays_succeeded++`; if `replay_count >= 3 AND success_rate < 0.80` → `retired = true` (sticky — prevents oscillation on noise). + +### Semantic-correctness layer (ADR-021) +Each `PathwayTrace` carries: +- `semantic_flags: Vec` — one of 9 variants: `UnitMismatch`, `TypeConfusion`, `NullableConfusion`, `OffByOne`, `StaleReference`, `PseudoImpl`, `DeadCode`, `WarningNoise`, `BoundaryViolation` +- `bug_fingerprints: Vec` — `{flag, pattern_key, example, occurrences}` where `pattern_key = "{Flag}:{sorted-top-3-identifiers-joined-by-hyphen}"`. Stable across prose variation. +- `type_hints_used: Vec` — `{source, symbol, type_repr}`. Phase E (not yet populated). + +**Pre-review enrichment**: scrum calls `POST /vectors/pathway/bug_fingerprints` with `{task_class, file_path, signal_class, limit}` — returns aggregated fingerprints sorted by occurrences descending. If any, a `📚 PATHWAY MEMORY` preamble is prepended to the reviewer prompt with "this file area had these patterns before — check for recurrences." + +**Post-review extractor** (Phase D, `scrum_master_pipeline.ts`): walks reviewer markdown line-by-line, finds lines containing a `SemanticFlag` variant, extracts identifier-shaped backtick-quoted tokens, filters out flag names + Rust keywords (self/mut/async/etc), sorts and takes top 3, builds `pattern_key = "{Flag}:{tokens}"`. + +### HTTP surface (on gateway port 3100) +| Endpoint | Purpose | +|---|---| +| `POST /vectors/pathway/insert` | write a full PathwayTrace | +| `POST /vectors/pathway/query` | hot-swap candidate check (returns `{candidate: null}` or `{candidate: {...}}`) | +| `POST /vectors/pathway/record_replay` | update replay_count + success_rate after hot-swap | +| `GET /vectors/pathway/stats` | totals + reuse_rate + replay_success_rate | +| `POST /vectors/pathway/bug_fingerprints` | aggregated fingerprints by narrow fingerprint (for pre-review preamble) | + +### State persistence +`data/_pathway_memory/state.json` — JSON dump of all buckets. Loaded at gateway boot (`crates/gateway/src/main.rs` has `pwm.load_from_storage().await`). + +## 7. Current state (2026-04-24 end of session) + +### Commits on branch `scrum/auto-apply-19814` since iter-5 baseline + +| # | SHA | Subject | +|---|---|---| +| 1 | `25ea3de` | observer fix — route LLM Team escalation to `/v1/chat` qwen3-coder | +| 2 | `8b77d67` | OpenRouter rescue ladder + tree-split reducer + first auto-applier | +| 3 | `96b46cd` | first auto-applied commit (later found misleading) | +| 4 | `5e8d87b` | cleanup + applier hardening (warning + rationale + dry-run gates) | +| 5 | `9cc0ceb` | P42-002 — truth gate into queryd `/sql` + `/paged` paths | +| 6 | `2f8b347` | pathway_memory base (PathwayTrace, hot-swap, 18 tests) | +| 7 | `86901f8` | queryd/delta.rs 6-line unit-mismatch fix | +| 8 | `92df0e9` | ADR-021 spec | +| 9 | `0a0843b` | ADR-021 Phases A+B+C (semantic_flags, prompt tags, preamble endpoint) | +| 10 | `ee31424` | ADR-021 Phase D (fingerprint extractor) | +| 11 | `f4cff66` | Phase D fix — strip flag names + Rust keywords from pattern_keys | + +### Matrix index state +- **12 pathway traces** in `data/_pathway_memory/state.json` +- **11 distinct bug fingerprints** across 4 Flag categories on `crates/queryd` narrow fingerprint (1 manually seeded + 10 extracted) +- **0 hot-swaps fired** (probation requires ≥3 replays per pathway; none reached yet) + +### Active in-flight +- Iter 9 complete; next iter 10+ will use cleaner fingerprint extractor (`f4cff66`) +- 4 "noisy" pattern_keys from iter-9-file-1 pre-fix run (e.g., `DeadCode:DeadCode`) — dormant, won't match future output, acceptable dead entries + +### Queued (not yet implemented) +- **Phase E** — `type_hints_used` population from `catalogd` column types, Arrow `RecordBatch.schema()`, Rust struct field types. Feeds typed context to reviewer prompt. +- **Auditor → pathway audit_consensus wire** — activates the strict-audit gate (currently lenient: null bootstraps, only explicit `false` blocks). +- **VCP UI cards** for "top bug fingerprints in last N iters" + "new patterns learned this iter" + +## 8. How to run a new iteration + +```bash +# Default 3 files (playbook_memory.rs, doc_drift.rs, auditor/audit.ts) +LH_SCRUM_FORENSIC=/home/profit/lakehouse/docs/SCRUM_FORENSIC_PROMPT.md \ +LH_SCRUM_PROPOSAL=/home/profit/lakehouse/docs/SCRUM_FIX_WAVE.md \ +bun run tests/real-world/scrum_master_pipeline.ts + +# Targeted files: +LH_SCRUM_FILES="/home/profit/lakehouse/crates/queryd/src/delta.rs,/home/profit/lakehouse/crates/queryd/src/service.rs" \ +LH_SCRUM_FORENSIC=... LH_SCRUM_PROPOSAL=... \ +bun run tests/real-world/scrum_master_pipeline.ts + +# Dry-run auto-applier against the latest scrum output: +LH_APPLIER_MIN_CONF=85 LH_APPLIER_MAX_FILES=10 \ +LH_APPLIER_MODEL=qwen3-coder:480b \ +LH_APPLIER_BRANCH=scrum/auto-apply-19814 \ +bun run tests/real-world/scrum_applier.ts + +# Actually commit (ONLY after dry-run looks clean): +LH_APPLIER_COMMIT=1 LH_APPLIER_MIN_CONF=85 LH_APPLIER_MAX_FILES=10 \ +LH_APPLIER_MODEL=qwen3-coder:480b \ +LH_APPLIER_BRANCH=scrum/auto-apply-19814 \ +bun run tests/real-world/scrum_applier.ts +``` + +## 9. Verify services before running + +```bash +# Gateway (port 3100) — must be up; pathway endpoints are here +curl -s http://localhost:3100/health # "lakehouse ok" +curl -s http://localhost:3100/vectors/pathway/stats # pathway memory totals + +# UI (port 3950) — VCP dashboard + /data/pathway_stats aggregation +curl -s http://localhost:3950/data/pathway_stats + +# Observer (port 3800) — event receiver + LLM Team escalation +curl -s http://localhost:3800/health 2>/dev/null || true + +# Sidecar (port 3200) — Python embed +curl -s http://localhost:3200/health 2>/dev/null || true + +# LLM Team (port 5000) — /api/run?mode=extract ONLY registered mode +# (others like code_review/patch/refactor return "Unknown mode") +curl -s http://localhost:5000/health 2>/dev/null || true +``` + +If gateway missing new routes after code change: `cargo build --release -p gateway && sudo systemctl restart lakehouse.service`. + +If UI missing new routes: kill old `bun run ui/server.ts` and restart (not a systemd service right now). + +## 10. Where things live (code pointers) + +| Concern | File | +|---|---| +| Scrum orchestrator | `tests/real-world/scrum_master_pipeline.ts` | +| Scrum ladder constant | same file, `const LADDER` line ~92 | +| Tree-split reducer | same file, `async function treeSplitFile` | +| Forensic prompt preamble (loaded via env) | `docs/SCRUM_FORENSIC_PROMPT.md` | +| Fix-wave proposal preamble | `docs/SCRUM_FIX_WAVE.md` | +| Scrum iter notes | `docs/SCRUM_LOOP_NOTES.md` | +| Auto-applier | `tests/real-world/scrum_applier.ts` | +| Applier audit trail | `data/_kb/auto_apply.jsonl` | +| Scrum reviews KB | `data/_kb/scrum_reviews.jsonl` | +| Model trust journal | `data/_kb/model_trust.jsonl` | +| Pathway memory module | `crates/vectord/src/pathway_memory.rs` | +| Pathway HTTP handlers | `crates/vectord/src/service.rs` (bottom) | +| Pathway state on disk | `data/_pathway_memory/state.json` | +| VCP UI server | `ui/server.ts` | +| VCP UI client | `ui/ui.js` + `ui/ui.css` + `ui/index.html` | +| Observer | `mcp-server/observer.ts` | +| Auditor | `auditor/audit.ts` | +| LLM Team extract client | `auditor/fact_extractor.ts` | +| ADR-021 spec | `docs/DECISIONS.md` ADR-021 | + +## 11. Key memory files a fresh session should read + +From `/root/.claude/projects/-home-profit/memory/`: + +- `project_scrum_pipeline.md` — updated state of the scrum iterations +- `project_first_auto_apply.md` — 96b46cd story + cleanup + hardening evidence from iter 7 +- `feedback_semantic_correctness_via_matrix.md` — J's insight on compounding, the ADR-021 rule +- `feedback_endpoint_probe_discipline.md` — GET 405 is not endpoint validation +- `reference_llm_team_modes.md` — only `extract` is registered on port 5000 +- `feedback_scrum_cloud_first.md` — scrum/audit/enrich pipelines use cloud first +- `feedback_cloud_determinism.md` — cloud N=3 consensus + qwen3-coder tie-breaker + +## 12. Known gotchas + +- **Gateway restart needed after Rust route additions.** `sudo systemctl restart lakehouse.service` — the service is systemd-managed. +- **UI server needs manual restart** after `ui/server.ts` changes (no systemd unit). Kill old `bun` pid, restart with `bun run ui/server.ts &`. +- **LLM Team mode `code_review` doesn't exist** — only `extract` is registered in `/root/llm_team_ui.py`. Don't wire new features to "Unknown mode" endpoints. See `reference_llm_team_modes.md`. +- **OpenRouter free-tier 429s during consensus probes** are normal (rate-limited upstream). In the production ladder they hit as last-resort rescue with seconds-to-minutes gap; different traffic pattern than rapid-fire consensus runs. +- **Openrouter minimax-m2.5:free has a 45s timeout** — not in ladder, only for one-off probes. +- **Probation period is 3 replays** before hot-swap can fire. On a fresh install, no hot-swap fires until a pathway has been re-visited ≥3 times. diff --git a/docs/SYSTEM_EVOLUTION_LAYERS.md b/docs/SYSTEM_EVOLUTION_LAYERS.md new file mode 100644 index 0000000..7fdca57 --- /dev/null +++ b/docs/SYSTEM_EVOLUTION_LAYERS.md @@ -0,0 +1,83 @@ +# Future Expansion — Advanced System Evolution Layers + +Adopted 2026-04-24 from J. The system stops optimizing for task completion. It optimizes for **provable execution, repeatable outcomes, resilience under drift, failure, and adversarial conditions.** + +## Layer roster + iteration mapping + +| # | Layer | Short form | Target iter | +|---|---|---|---:| +| 1 | Counterfactual Execution | Generate synthetic failure variants from each success | iter 5 | +| 2 | Model Trust Profiling | Per-(model, task_type) success rate → routing weight | **iter 3** | +| 3 | Execution DNA | Compress successful runs into reusable patterns | iter 4 | +| 4 | Drift Sentinel | Re-validate historical tasks on a schedule | iter 5 | +| 5 | Adversarial Injection | Inject poisoned context / malformed outputs / conflicts | iter 6 | +| 6 | Permission Gradient | Confidence → execution tier (≥0.9 full, ≥0.7 dry-run, ≥0.5 sim, <0.5 block) | **iter 3** | +| 7 | Multi-Agent Disagreement | Planner/Critic/Validator — disagreement = signal | iter 4 | +| 8 | Temporal Context | Time-aware memory with decay_score + last_validated_at | iter 4 | +| 9 | Execution Cost Intelligence | Tokens, iterations, cloud_calls, latency per task | **iter 3** | +| 10 | Human Override as Data | Capture manual fixes as jsonl rows | **iter 3** | + +## Detail (J's original framing preserved) + +### 1. Counterfactual Execution Layer +Simulate alternate failure paths for every successful task. Real Execution → Success → Generate Variations (env, version, inputs) → Simulate Failure Cases → Store Synthetic Failure Signatures. **Purpose:** pre-train against unseen failures before real exposure. + +### 2. Model Trust Profiling ← iter 3 +Per-(model, task_type) performance tracking. +``` +{ "model": "...", "task_type": "...", "success_rate": 0.0, "failure_modes": [], "trust_score": 0.0 } +``` +**Usage:** route by trust score, adjust validation strictness dynamically, per-model risk budgets. + +### 3. Execution DNA (Trace Compression) +Successful executions → reusable fragments. +``` +{ "dna_id": "hash", "task_signature": "...", "critical_steps": [], "failure_avoidance": [] } +``` +Replaces doc retrieval with pattern retrieval; faster convergence on similar tasks. + +### 4. Drift Sentinel +Select Historical Task → Re-run Current Env → Compare → If Failure → Mark Drifted → Trigger Re-learning. Detect silent decay; maintain long-term reliability. + +### 5. Adversarial Injection Engine +Inject malformed outputs / outdated docs / conflicting instructions / poisoned memory. Verify validation catches, execution blocks unsafe actions, memory rejects corrupted data. Build system immunity. + +### 6. Permission Gradient Execution ← iter 3 +Confidence-based control replacing binary: +- confidence ≥ 0.9 → full execution +- confidence ≥ 0.7 → dry-run + diff +- confidence ≥ 0.5 → simulation only +- confidence < 0.5 → block +Inputs: validation score, model trust score, memory match confidence. Risk-aware control; reduced catastrophic-failure surface. + +### 7. Multi-Agent Disagreement Engine +Planner / Critic / Validator; disagreement triggers more context, bigger model, stricter validation. Disagreement is signal, not noise. + +### 8. Temporal Context Layer +``` +{ "created_at": "ts", "last_validated_at": "ts", "decay_score": 0.0 } +``` +Retrieval priority: recent + validated + high success rate. Avoid stale knowledge. + +### 9. Execution Cost Intelligence ← iter 3 +``` +{ "task": "...", "tokens_used": 0, "iterations": 0, "cloud_calls": 0, "latency_ms": 0 } +``` +Optimize local vs cloud; reduce unnecessary iterations. + +### 10. Human Override as Data ← iter 3 +``` +{ "human_fix": "...", "reason": "...", "task_signature": "...", "validated": true } +``` +Manual fixes become reusable knowledge. + +## Final Principle + +Memory is not passive recall. It is operational substrate: +- failures become structured knowledge +- successes become reusable execution patterns +- all outputs are validated before reuse + +## System Directive + +Not speed. Not convenience. **Correctness. Verifiability. Resilience under change.** diff --git a/docs/distillation/operator-handoff.md b/docs/distillation/operator-handoff.md new file mode 100644 index 0000000..c63fcb6 --- /dev/null +++ b/docs/distillation/operator-handoff.md @@ -0,0 +1,191 @@ +# Distillation System — Operator Handoff + +**Version:** v1.0.0 +**Branch:** `scrum/auto-apply-19814` +**Tag:** `distillation-v1.0.0` +**Audit baseline:** `data/_kb/audit_baselines.jsonl` (auto-grown per audit-full run) + +This is the operator-level handoff for the distillation system. If you are picking this up cold, **read this doc first**, then `docs/recon/local-distillation-recon.md`. Skim the per-phase reports under `reports/distillation/` only when you need detail. + +## What this system does + +Turns real Lakehouse execution traces (1052 records sampled at v1.0.0 freeze) into clean, gated training datasets: + +- **RAG corpus** — 446 grounded examples for retrieval-augmentation +- **SFT corpus** — 351 instruction→response pairs (strict accepted-only) +- **Preference corpus** — 83 chosen/rejected pairs (zero self-pairs, zero identical-text) + +It is **NOT** a model trainer. It is a **knowledge refinery** that produces training-safe substrate. The local-model "replay" runtime (Phase 7) demonstrates that retrieval against this substrate makes a 7B-class model behave like the system instead of fabricating audit verdicts. + +## Phase map + +| Phase | What it does | Commit | Report | +|---|---|---|---| +| 0 | Recon doc — inventory of source streams + integration plan | 27b1d27 | `docs/recon/local-distillation-recon.md` | +| 1 | 9 schemas + 51 schema tests + foundation types | 27b1d27 | (in commit body) | +| 2 | Materializer: 12 source jsonls → unified EvidenceRecord at `data/evidence/YYYY/MM/DD/` | 1ea8029 | (in commit body) | +| 3 | Deterministic Success Scorer: EvidenceRecord → ScoredRun (4 categories, no LLM) | c989253 | (in commit body) | +| 4 | RAG/SFT/Preference exports + quarantine system | 68b6697 | `reports/distillation/phase4-export-report.md` | +| 5 | Receipts harness — per-stage StageReceipt + RunSummary + DriftReport | 2cf359a | `reports/distillation/phase5-receipts-report.md` | +| 6 | Acceptance gate — fixture-driven 22-invariant E2E test | 1b433a9 | `reports/distillation/phase6-acceptance-report.md` | +| 7 | Replay layer — retrieval-driven local-model bootstrap | 681f39d | `reports/distillation/phase7-replay-report.md` | +| 8 | Full system audit + drift baseline | 5bdd159 | `reports/distillation/phase8-full-audit-report.md` | + +The auditor rebuild (commit 20a039c) is wired to use the Phase 5 substrate: it now calls `lakehouse_answers_v1` matrix retrieval instead of tree-split shard summaries. Per-audit cost: 50× fewer cloud calls, 17× faster wall-clock. + +## Known-good commands + +All commands run from `/home/profit/lakehouse`. Use `bun run scripts/distillation/distill.ts ` or `./scripts/distill ` if symlinked. + +```bash +# Build everything end-to-end with structured receipts +./scripts/distill run-all + +# Read a specific run's summary + drift +./scripts/distill receipts --run-id + +# Verify the system end-to-end on a deterministic fixture +./scripts/distill acceptance + +# Audit Phases 0-7 + drift detection vs prior baseline +./scripts/distill audit-full + +# Test a task through the replay layer (local model with retrieval) +./scripts/distill replay --task "" +./scripts/distill replay --task "" --no-retrieval # baseline / A/B +./scripts/distill replay --task "" --allow-escalation # try deepseek if local fails + +# Per-stage one-shot (rare — prefer run-all for receipts) +./scripts/distill build-evidence +./scripts/distill score +./scripts/distill export-rag +./scripts/distill export-sft # strict accepted-only +./scripts/distill export-sft --include-partial # opens to partially_accepted +./scripts/distill export-preference +./scripts/distill export-all +``` + +## How to rerun the full audit + +```bash +./scripts/distill audit-full +``` + +Reads: +- on-disk `data/evidence/`, `data/scored-runs/`, `exports/{rag,sft,preference}/*` +- the most recent run_id under `reports/distillation/` +- the prior audit baseline at `data/_kb/audit_baselines.jsonl` + +Writes: +- `reports/distillation/phase8-full-audit-report.md` +- a new row to `data/_kb/audit_baselines.jsonl` (auto-grown — never overwrite) + +Exit code 0 = pass (every required check held). Non-zero = at least one required check failed. + +## How to inspect drift + +Two levels: + +1. **Per-run drift** — every `run-all` writes `reports/distillation//drift.json`. Compares to the most recent prior run. Severity `ok | warn | alert`. + +2. **Cross-run baseline drift** — `audit-full` reads the latest baseline row from `data/_kb/audit_baselines.jsonl` and compares 10 tracked metrics (record counts, category distribution, export sizes, quarantine totals). Drift table appears in `reports/distillation/phase8-full-audit-report.md` with `>20%` flagged as `warn`. + +The baseline file is **append-only**. Don't truncate it — its value grows with the longitudinal record. If a metric flips `warn` after a code change, the row before that change is the diagnostic anchor. + +## How to restore from last good state + +```bash +git fetch --tags +git checkout distillation-v1.0.0 +./scripts/distill audit-full # confirm 16/16 required pass at v1.0.0 +``` + +If you've made changes that broke the system, hard reset to v1.0.0: + +```bash +git reset --hard distillation-v1.0.0 # destructive — loses uncommitted work +./scripts/distill acceptance # confirm 22/22 fixture invariants +./scripts/distill audit-full # confirm baseline match +``` + +## How to add future phases without contaminating the corpus + +The corpus = `exports/rag/playbooks.jsonl` + `exports/sft/instruction_response.jsonl` + `exports/preference/chosen_rejected.jsonl`. These are training-safe **only if** every gate held. To add Phase 10+: + +1. Add code under `scripts/distillation/.ts`. Do NOT modify Phases 0-8. +2. If your phase produces evidence, append to `data/_kb/.jsonl` and add a transform in `scripts/distillation/transforms.ts`. The materializer picks it up automatically. +3. If your phase needs a new schema, create `auditor/schemas/distillation/.ts` with `_SCHEMA_VERSION = 1` constant + validator + tests in `auditor/schemas/distillation/schemas.test.ts` (positive + negative fixtures). +4. Run `./scripts/distill audit-full` BEFORE merging. Confirm 16/16 still passes. +5. Run `./scripts/distill acceptance`. Confirm 22/22 still passes. +6. Re-run `./scripts/distill run-all`. Inspect drift in the new run's `drift.json`. Anything `>20%` in record counts means your phase moved the corpus — explain it in the commit. + +## What NOT to modify casually + +These have explicit firewalls. Touching them = potentially weakening contamination prevention: + +| File | Why fragile | +|---|---| +| `auditor/schemas/distillation/sft_sample.ts` | The `quality_score` enum literally enforces "no rejected/needs_human_review in SFT". Loosening it = silent leak | +| `scripts/distillation/export_sft.ts` `SFT_NEVER` constant | Second-layer defense. If schema fails, this catches it | +| `scripts/distillation/export_sft.ts` re-read validation | Third layer — re-reads on-disk SFT and fails LOUD if forbidden quality_score appears | +| `scripts/distillation/scorer.ts` category mapping | Changing rules → silent corpus shift. Run `audit-full` after any change to see drift | +| `tests/fixtures/distillation/acceptance/` | The fixture is the gate. Changing it = changing the bar | +| `data/_kb/audit_baselines.jsonl` | Append-only. Truncating loses longitudinal drift signal | + +If you must change one of these, run `audit-full` BEFORE and AFTER. The drift table will tell you exactly what your change moved. + +## Receipt-vs-drift quick reference + +If `audit-full` flags a metric: +- `>20%` swing in `p3_accepted` → scorer rules changed OR source data shifted +- `>20%` swing in `p4_sft_rows` → SFT eligibility changed (check exporter filter) +- `>20%` swing in `p4_total_quarantined` → either source data is dirtier OR a gate got tighter +- Hash mismatch on identical input → determinism violation; revert immediately + +If `acceptance` fails: +- 22 invariants are pinned in `scripts/distillation/acceptance.ts`. The failing one names what broke. +- Spec invariants (1-22) are documented in `reports/distillation/phase6-acceptance-report.md`. + +## Pointers to non-distillation systems + +The auditor (`auditor/`) and the gateway (`crates/gateway/`) are the consumers of the distillation substrate. They use it but are not part of it: + +- Auditor's `pr_audit` mode (`crates/gateway/src/v1/mode.rs`) retrieves from `lakehouse_answers_v1`. If you regenerate the RAG export, the auditor's context auto-improves on next call. +- The gateway's `/v1/chat` is the entry point all model calls flow through. Receipts capture provider, model, latency, prompt+completion tokens. + +## Provenance + +Every export row → traces to `data/scored-runs/.../.jsonl` line N → traces to `data/evidence/.../.jsonl` line N → traces to `data/_kb/.jsonl` line N. The `provenance.sig_hash` field (canonical sha256 of the source row, sorted keys) is the join key. + +If a downstream consumer asks "where did this SFT row come from", run: + +```bash +jq 'select(.id == "") | .provenance' exports/sft/instruction_response.jsonl +# returns {source_file, line_offset, sig_hash, recorded_at} +# Then: +sed -n "$(( + 1))p" data/scored-runs/ +# And so on back to data/_kb/.jsonl +``` + +## Test discipline + +```bash +bun test tests/distillation/ auditor/schemas/distillation/ +``` + +At v1.0.0: **145 tests, 0 fail, 372 expect() calls, ~600ms.** Any new phase must keep this at 0 fail. + +## Cumulative commits at v1.0.0 + +``` +27b1d27 distillation: Phase 0 recon + Phase 1 schemas + Phase 2 transforms scaffold +1ea8029 distillation: Phase 2 — Evidence View materializer + health audit +c989253 distillation: Phase 3 — deterministic Success Scorer +68b6697 distillation: Phase 4 — dataset export layer +2cf359a distillation: Phase 5 — receipts harness (system-level observability) +1b433a9 distillation: Phase 6 — acceptance gate suite +20a039c auditor: rebuild on mode runner + drop tree-split (use distillation substrate) +681f39d distillation: Phase 7 — replay-driven local model bootstrapping +5bdd159 distillation: Phase 8 — full system audit + distillation: Phase 9 — release freeze and operator handoff +``` diff --git a/docs/distillation/recovery-runbook.md b/docs/distillation/recovery-runbook.md new file mode 100644 index 0000000..065d94a --- /dev/null +++ b/docs/distillation/recovery-runbook.md @@ -0,0 +1,208 @@ +# Distillation System — Recovery Runbook + +**Version:** v1.0.0 +**Audience:** Future operator (or future Claude session) inheriting this system in a broken state. + +This is the failure-mode runbook. Read top-down, stop at the first symptom that matches. + +## Symptom 1: `audit-full` exits non-zero + +A required check failed. The report at `reports/distillation/phase8-full-audit-report.md` will name the failing check verbatim. Map by phase: + +### P0 — recon doc missing +**Cause:** repo state corrupted; the recon doc has never existed at this commit. +**Fix:** +```bash +git checkout distillation-v1.0.0 -- docs/recon/local-distillation-recon.md +``` + +### P0 — tier-1 source stream missing +**Cause:** fresh-clone or post-rotation environment without source data. +**Severity:** informational only (audit-full reports as required=false). Pipeline will produce 0 rows but won't fail. +**Fix:** populate the source stream OR accept reduced output and note in the next report. + +### P1 — schema validators fail +**Cause:** somebody modified a Phase 1 schema and broke a validator. +**Diagnostic:** +```bash +bun test auditor/schemas/distillation/ 2>&1 | grep -A2 "fail" +``` +**Fix:** revert the schema change. Phase 1 schemas are versioned (`_SCHEMA_VERSION = 1`); they bump deliberately, never silently. +```bash +git diff distillation-v1.0.0 -- auditor/schemas/distillation/ # see what changed +git checkout distillation-v1.0.0 -- auditor/schemas/distillation/ +``` + +### P2 — materializer dry-run fails / writes 0 +**Cause:** every source jsonl is empty OR every transform is broken. +**Diagnostic:** +```bash +ls -la data/_kb/*.jsonl # confirm sources have content +bun run scripts/distillation/build_evidence_index.ts --dry-run +# inspect skip reasons in data/_kb/distillation_skips.jsonl +``` +**Fix:** identify the broken transform via per-source row counts. If a real-data shape changed (e.g. a new field name in a source jsonl), update the matching transform in `scripts/distillation/transforms.ts`. Add a fixture row to `auditor/schemas/distillation/realdata.test.ts` covering the new shape. + +### P3 — scored-runs distribution empty +**Cause:** `data/scored-runs/` is missing OR the score categories are not landing. +**Fix:** +```bash +./scripts/distill score # re-runs scorer if data/evidence/ is populated +``` +If still empty, the scorer rules in `scripts/distillation/scorer.ts` may have changed. Re-run `bun test tests/distillation/scorer.test.ts` — if those fail, revert. + +### P4 — SFT contamination firewall caught a leak (CRITICAL) +**Severity:** alert. A `rejected` or `needs_human_review` row landed in SFT. This is a non-negotiable spec violation. +**Stop immediately:** +```bash +mv exports/sft/instruction_response.jsonl exports/sft/instruction_response.jsonl.QUARANTINED-$(date +%s) +``` +**Diagnostic:** the audit report's "P4 SFT contamination firewall" check shows the count. The forbidden row is in the file you just renamed: +```bash +jq 'select(.quality_score != "accepted" and .quality_score != "partially_accepted")' exports/sft/instruction_response.jsonl.QUARANTINED-* +``` +**Root cause is one of:** +1. SftSample schema validator was loosened — check `auditor/schemas/distillation/sft_sample.ts` against v1.0.0 +2. Exporter `SFT_NEVER` constant was loosened — check `scripts/distillation/export_sft.ts` +3. Schema validation was bypassed (someone called `appendFileSync` directly) — find the offending caller via `git log --oneline -p exports/sft/` + +**Recovery:** revert the offending change. Re-run `./scripts/distill export-sft`. The fresh output should pass the audit's leak check. + +### P4 — Preference self-pair leaked +**Cause:** export_preference's pairing logic produced `chosen_run_id == rejected_run_id`. Schema validator should catch this. +**Diagnostic:** +```bash +jq 'select(.chosen_run_id == .rejected_run_id) | .id' exports/preference/chosen_rejected.jsonl +``` +**Fix:** check `scripts/distillation/export_preference.ts::buildPair` — the equality guard at the top must remain. Revert if missing. + +### P5 — RunSummary fails to validate +**Cause:** receipts harness emitted a malformed summary. +**Diagnostic:** +```bash +LATEST=$(ls -1t reports/distillation/*/summary.json | head -1) +bun -e "import {validateRunSummary} from './auditor/schemas/distillation/run_summary'; const s = JSON.parse(await Bun.file('$LATEST').text()); console.log(validateRunSummary(s))" +``` +**Fix:** the field that failed validation is named in the validator output. Either fix the harness in `scripts/distillation/receipts.ts` or revert. + +### P6 — acceptance gate fails an invariant +**Cause:** something in Phases 1-5 changed in a way the fixture catches. +**Diagnostic:** run acceptance directly to see all 22 checks: +```bash +bun run scripts/distillation/acceptance.ts +# scan output; the failing check names what broke +cat reports/distillation/phase6-acceptance-report.md +``` +**Fix:** the report's "Failures" section names the invariant. The 22 invariants are documented at the top of `scripts/distillation/acceptance.ts`. Locate the affected phase code, revert. + +### P7 — replay validation regressed +**Cause:** local model output failed the structural validator OR retrieval found 0 playbooks. +**Diagnostic:** +```bash +./scripts/distill replay --task "" --local-only +# inspect the validation_result.reasons +``` +**Fix:** +- If validation reasons mention "filler/hedge phrase": the local model regressed (model swap?) — revert `LH_REPLAY_LOCAL_MODEL` to default +- If retrieval is empty: `exports/rag/playbooks.jsonl` is empty — re-run export-rag + +## Symptom 2: drift table flags `warn` + +A metric moved >20% from baseline. This is a SOFT alert — not a failure, but worth investigating before treating outputs as stable. + +**Diagnostic:** +```bash +jq -r '.metrics' data/_kb/audit_baselines.jsonl | tail -5 +# see the recent baseline trajectory +cat reports/distillation/phase8-full-audit-report.md +# read the drift table +``` + +**Common causes:** +- New source data → record counts grow → expected, not a regression +- Scorer rules changed → category distribution shifted → confirm intentional +- Exporter filter loosened → SFT/RAG counts grow → CHECK contamination firewall first + +**If the drift is intentional**, write a row to `data/_kb/audit_baselines.jsonl` documenting why (no schema for this — just append a JSON line with a `notes` field). Future audits will treat the new value as the new baseline. + +## Symptom 3: `acceptance` exits non-zero but `audit-full` doesn't + +This is rare — acceptance is stricter (22 invariants on a fixture vs audit-full's 16 required checks on real data). The failing acceptance check usually points to a broken assumption that real data hides. + +**Diagnostic:** +```bash +bun run scripts/distillation/acceptance.ts 2>&1 | head -50 +ls /tmp/distillation_phase6_acceptance/data/evidence/ # the failed run leaves its temp root +``` + +**Fix:** the acceptance script keeps the temp root on fail (cleans only on pass). Inspect `/tmp/distillation_phase6_acceptance/` to see what the pipeline produced vs expected. The fixture rows themselves are the contract — change the fixture deliberately, never to make a test pass. + +## Symptom 4: `run-all` produces empty exports + +**Cause:** Phase 2 or Phase 3 ran on empty input. + +**Diagnostic order:** +1. `ls data/_kb/*.jsonl` — sources present? +2. `find data/evidence -name "*.jsonl" | xargs wc -l` — any rows materialized? +3. `find data/scored-runs -name "*.jsonl" | xargs wc -l` — any rows scored? +4. `wc -l data/_kb/distillation_skips.jsonl data/_kb/scoring_skips.jsonl` — anything skipped? + +The first counter that's 0 names the broken phase. + +## Symptom 5: hash mismatch on identical input + +**Cause:** determinism violation. Same input → different output. This is a CRITICAL bug. + +**Diagnostic:** +```bash +# Wipe outputs but keep sources, run twice with same recorded_at, compare run_hash +rm -rf data/evidence data/scored-runs exports +RA="2026-04-27T00:00:00.000Z" +./scripts/distill run-all # captures run_id_1 +LATEST_1=$(ls -1t reports/distillation/ | grep -v phase | head -1) + +rm -rf data/evidence data/scored-runs exports +./scripts/distill run-all +LATEST_2=$(ls -1t reports/distillation/ | grep -v phase | head -1) + +jq .run_hash reports/distillation/$LATEST_1/summary.json +jq .run_hash reports/distillation/$LATEST_2/summary.json +# These MUST match if recorded_at is fixed. +``` + +**If they don't match:** something in the pipeline introduced non-determinism. Common causes: +- A `Date.now()` baked into output (other than the explicit `recorded_at`) +- `Math.random()` or `randomUUID()` in a path that should be deterministic +- A `Map` iteration order issue (rare in V8) +- Concurrent writes to the same file + +Bisect against `distillation-v1.0.0` — find the commit that introduced the non-determinism, revert. + +## Symptom 6: replay logs growing unbounded + +Phase 7 replay appends to `data/_kb/replay_runs.jsonl` with no rotation. Acceptable until file >100MB, then: + +```bash +# Move and start fresh +mv data/_kb/replay_runs.jsonl data/_kb/replay_runs.archive.$(date +%s).jsonl +gzip data/_kb/replay_runs.archive.*.jsonl +``` + +This is documented as a Phase 7 carry-over. A future Phase 10+ could add rotation. + +## Last resort: nuclear restore + +If nothing works: + +```bash +git fetch --tags +git stash # save uncommitted work +git checkout distillation-v1.0.0 +./scripts/distill audit-full # confirm 16/16 pass at v1.0.0 +./scripts/distill acceptance # confirm 22/22 pass + +# Now diff against the broken state to see what changed +git diff distillation-v1.0.0..scrum/auto-apply-19814 -- scripts/distillation/ auditor/schemas/distillation/ +``` + +The diff is your bug. diff --git a/docs/recon/local-distillation-recon.md b/docs/recon/local-distillation-recon.md new file mode 100644 index 0000000..25e01e7 --- /dev/null +++ b/docs/recon/local-distillation-recon.md @@ -0,0 +1,309 @@ +# Local Distillation Pipeline — Repo Recon + +**Date:** 2026-04-26 +**Status:** Phase 0 (read-only inventory — no implementation yet) +**Spec:** `/home/profit/now.md` +**Branch:** `scrum/auto-apply-19814` head `f753e11` (uncommitted: auditor rebuild) + +This document inventories what already exists in the Lakehouse repo before we build the distillation substrate. It is the gating artifact: per the spec, no implementation lands until this document is settled. + +The headline finding: **~70% of the spec's modules already have working substrate** in the form of JSONL streams, vector corpora, scoring gates, and a partial extraction pipeline (`distilled_facts.jsonl` / `distilled_procedures.jsonl`). The work is integration + formalization, not greenfield. The biggest risk is shipping a parallel system that drifts from what the existing scrum/auditor/observer loops actually produce. + +--- + +## 1. Repo structure + +``` +/home/profit/lakehouse +├── crates/ # 15 Rust crates (see PRD.md) +│ ├── shared/ # types.rs, profiles/, model_matrix.rs, secrets.rs +│ ├── gateway/ # /v1/* HTTP surface, mode router, observer event fanout +│ ├── vectord/ # HNSW + pathway_memory.rs (88 traces) + Mem0 versioning +│ ├── catalogd/ # column types, manifests +│ ├── truth/ # Phase 42 — TOML rule engine for SQL/request gates +│ ├── validator/ # Phase 43 — staffing/devops validators +│ └── ... +├── auditor/ # TypeScript PR auditor (Bun runtime) +│ ├── audit.ts # orchestrator +│ ├── audit_one.ts # one-shot harness +│ ├── claim_parser.ts # extracts ship-claims from PR body +│ ├── fact_extractor.ts # LLM Team /api/run?mode=extract integration +│ ├── kb_index.ts # **already a queryable index over data/_kb/*.jsonl** +│ ├── kb_stats.ts +│ ├── checks/ # static.ts, dynamic.ts, inference.ts, kb_query.ts +│ ├── policy.ts # severity → block/warn/info gates +│ └── gitea.ts # PR poller +├── tests/ +│ ├── real-world/ # scrum_master_pipeline.ts, scrum_applier.ts, runs/ +│ ├── multi-agent/ # scenarios/, playbooks/ +│ ├── architecture_smoke.ts +│ ├── battery/ +│ └── agent_test/ +├── scripts/ +│ ├── build_answers_corpus.ts # NEW 2026-04-26: lakehouse_answers_v1 +│ ├── build_lakehouse_corpus.ts # arch corpus +│ ├── build_symbols_corpus.ts # symbols corpus +│ ├── build_scrum_findings_corpus.ts # findings corpus +│ ├── vectorize_raw_corpus.ts +│ ├── mode_experiment.ts / mode_compare.ts / mode_pass{2,3,4,5}_*.ts +│ └── ... +├── sidecar/ # Python (Ollama embed adapter) +├── mcp-server/ # observer.ts, relevance.ts, ai_models.ts (port 3700/3800) +├── ui/ # public Bun UI (devop.live/lakehouse, port 3700) +├── data/ # **the substrate this document audits** (see §3) +└── docs/ + ├── PRD.md + ├── PHASES.md + ├── DECISIONS.md (ADRs 001-021) + ├── SCRUM_MASTER_SPEC.md + ├── MATRIX_AGENT_HANDOVER.md + ├── MODE_RUNNER_TUNING_PLAN.md + └── recon/ + └── local-distillation-recon.md (this file) +``` + +--- + +## 2. Existing components by spec module + +### 2.1 Gateway / orchestrator + +`crates/gateway/src/v1/mode.rs` is the **prompt-molder substrate** — task_class → mode → enrichment composer + LLM call. Five native modes (codereview_lakehouse, codereview_isolation, codereview_null, codereview_matrix_only, codereview_playbook_only) + staffing_inference_lakehouse + (uncommitted) pr_audit. Strong-model auto-downgrade gate based on Pass 5 variance test. + +**Distillation relevance:** The mode runner already encodes "compose pathway memory + matrix retrieval + framing into a one-shot prompt." The distillation pipeline can call mode runner endpoints rather than reimplementing retrieval. + +### 2.2 Observer / scratchpad + +- `mcp-server/observer.ts` — Bun service on `:3800`. `/event`, `/relevance`, `/review` endpoints. Receives scrum + scenario + langfuse-bridge sources. KB preamble blends pathway + arch + answers (3 sources). +- `mcp-server/relevance.ts` — adjacency-pollution heuristic filter (added 2026-04-25). +- Scrum scratchpad: `tests/real-world/scrum_master_pipeline.ts::treeSplitFile` — text-only multi-shard scratchpad. Auditor curates the same way (`auditor/checks/inference.ts::treeSplitDiff`). + +**Distillation relevance:** Scratchpads are unstructured text. Spec wants structured extraction (objective/completed/failed/pending). The `distilled_*.jsonl` streams (§3) already do half of this for the LLM Team runs — extending to the scrum scratchpad is the gap. + +### 2.3 Knowledge base / index + +Two layers: + +**Layer 1: append-only JSONL streams in `data/_kb/`** (see §3 for full inventory). +**Layer 2: vector corpora in `data/vectors/*.parquet`** + HNSW indexes. + +Auditor's `kb_index.ts` already wraps the JSONLs as a queryable index. `kb_query.ts` check uses it to surface recurring patterns across PRs. + +**Distillation relevance:** Layer 1 is the EvidenceCollector substrate. Layer 2 is the HybridIndexer substrate. Neither has a unified record schema across streams — that's the formalization work. + +### 2.4 MCP / context integrations + +- `.mcp.json` — MCP server configuration (gitea, etc.) +- `mcp-server/` — observer + relevance + ai_models surfaces +- LLM Team UI (port 5000) — `/api/run?mode=extract` is the only registered mode (per `feedback_endpoint_probe_discipline.md`); `code_review/patch/refactor` return "Unknown mode" +- `aibridge` crate — Rust ↔ Python sidecar; OpenAI-compat proxy as of `3a0b37e` + +**Distillation relevance:** Existing call surfaces are already the right shape. Distillation pipeline runs ON the gateway via `/v1/*`, not on a parallel runtime. + +### 2.5 PRD / requirements docs + +- `docs/PRD.md` — phases 0-37 (shipped) + 38-44 productization +- `docs/CONTROL_PLANE_PRD.md` — long-horizon control plane (2026-04-22 pivot) +- `docs/PHASES.md` — phase tracker +- `docs/DECISIONS.md` — ADRs 001-021 (021 is semantic-correctness matrix layer) +- `docs/SCRUM_MASTER_SPEC.md` — scrum loop architecture + refactor timeline +- `docs/MODE_RUNNER_TUNING_PLAN.md` — open knobs + +**Distillation relevance:** PRD is the ground truth for the PRD-drift comparator. PHASES.md + auditor's `phase_sweep_findings.jsonl` already encode partial drift reports. + +### 2.6 Model routing logic + +- `config/modes.toml` — task_class → mode/model registry (6 task classes including new pr_audit) +- `crates/gateway/src/v1/mode.rs::is_weak_model` — strong/weak heuristic for matrix corpus downgrade +- `data/_kb/model_trust.jsonl` (45K) — per-run model performance ledger (run_id, accepted_model, attempts_made, etc.) +- `data/_kb/mode_experiments.jsonl` (1.3M) — per-call mode runner telemetry (mode, model, latency_ms, sources, response, response_chars) + +**Distillation relevance:** `mode_experiments.jsonl` is the cleanest per-call record we have — it's already an EvidenceRecord with everything except observer_notes and human_override fields. The Model Routing Ledger spec module is mostly an aggregation script over this jsonl + model_trust.jsonl. + +### 2.7 Logs / traces + +- Langfuse (port 3001, docker `langfuse`) — every `/v1/chat` and `/v1/respond` call (`crates/gateway/src/v1/langfuse_trace.rs`). Fire-and-forget. +- Observer `/event` — every `/v1/chat` call also fires here (`d1d97a0`) +- `data/_observer/ops.jsonl` — observer event log (mcp-server side) +- `data/_auditor/verdicts/*.json` — per-PR auditor verdict +- Systemd journals: lakehouse, lakehouse-sidecar, lakehouse-observer, lakehouse-auditor + +**Distillation relevance:** Langfuse + observer events are the trace substrate, but they're not yet linked to the JSONL streams via shared run_id. Linkage is part of EvidenceRecord work. + +### 2.8 Test framework + +- Bun-native tests in `crates/*/src/**/*test*` (Rust) and `tests/*` (TypeScript) +- `tests/real-world/` — scrum master + applier integration +- `tests/architecture_smoke.ts` — PRD-invariant probe against 500k workers +- `tests/multi-agent/scenarios/` — 20+ scenario fixtures (Heritage_Foods, Riverfront_Steel, etc.) +- `auditor/fixtures/hybrid_38_40_45.ts` — auditor's own dynamic fixture + +**Distillation relevance:** Test framework supports both Rust and TS. The acceptance-gate suite (Phase 6 of distillation plan) lands in `tests/distillation/`. + +### 2.9 Data schemas (existing, implicit) + +The shapes that matter, by JSONL: + +| File | Key fields | Provenance fields | +|------|-----------|-------------------| +| `audits.jsonl` (2.6M) | full per-PR verdict | `pr_number`, `head_sha`, `audited_at` | +| `audit_facts.jsonl` (506K) | extracted facts/entities/relationships from auditor inference | `pr_number`, `head_sha`, `extracted_at`, `extractor`, `verifier`, `llm_team_run_id` | +| `audit_lessons.jsonl` (539K) | derived lessons from past audits | (similar to facts) | +| `audit_discrepancies.jsonl` | N=3 consensus splits — chosen/rejected pairs | `pr_number`, `head_sha`, `claim_idx`, `votes`, `resolution` | +| `scrum_reviews.jsonl` (448K) | per-file scrum review (forensic JSON or markdown) | `file`, `reviewed_at`, `accepted_model`, `accepted_on_attempt` | +| `auto_apply.jsonl` (14K) | applier action per file | `file`, `ts`, `action`, `patches_applied` | +| `mode_experiments.jsonl` (1.3M) | per-call mode runner telemetry | `ts`, `task_class`, `mode`, `model`, `file_path`, `sources`, `latency_ms` | +| `observer_escalations.jsonl` (1.9K) | observer-diagnosed failure clusters | `ts`, `sig_hash`, `cluster_size`, `analysis`, `mode`, `kb_preamble_chars` | +| `observer_reviews.jsonl` (97K) | observer hand-reviews of scrum attempts | (TBD) | +| `model_trust.jsonl` (45K) | per-run model trust ledger | `run_id`, `task_type`, `accepted_model`, `attempts_made`, `confidence_avg`, `errors`, `thin_rejections` | +| `outcomes.jsonl` (98K) | per-run scenario outcomes | `run_id`, `sig_hash`, `created_at`, `models`, `total_events`, `ok_events`, `total_citations`, `total_gap_signals` | +| `human_overrides.jsonl` (2.4K) | human-in-loop overrides | (TBD) | +| `overseer_corrections.jsonl` (21K) | overseer model corrections | (TBD) | +| `phase_sweep_findings.jsonl` (45K) | phase-audit drift findings | `phase`, `phase_name`, `status`, `claims_verified`, `claims_fake`, `claims_partial`, `findings`, `evidence`, `discovered_at` | +| `doc_drift_corrections.jsonl` (603B) | doc drift signals | (TBD) | +| `pathway_recommendations.jsonl` (57K) | pathway memory hot-swap recommendations | `run_id` | +| `signatures.jsonl` (270K) | run signatures for dedup/grouping | (TBD) | +| `classifications.jsonl` (52K) | task-type classifications | (TBD — likely the task_type taxonomy) | +| `contract_analyses.jsonl` (4.3K) | contract analysis runs (closest to canonical EvidenceRecord) | `ts`, `ok`, `permit_id`, `analysis`, `matrix_corpora`, `matrix_hits`, `matrix_ms`, `observer_verdict`, `observer_conf`, `observer_notes`, `observer_src`, `cost`, `duration_ms` | +| `distilled_facts.jsonl` (179K) | **already-distilled fact stream** | `run_id`, `sig_hash`, `created_at`, `extractor`, `verifier`, `categorizer`, `category`, `text`, `embedding`, `embed_dim`, `schema_version`, `source_label`, `source_service` | +| `distilled_procedures.jsonl` (21K) | **already-distilled procedure stream** | (same shape as facts) | +| `distilled_config_hints.jsonl` (22K) | **already-distilled config-hint stream** | (same shape) | + +--- + +## 3. The data substrate (what's already produced) + +### Schema observation + +`distilled_facts.jsonl` and `distilled_procedures.jsonl` already match what now.md calls a normalized evidence record — almost. They have: + +✅ run_id, sig_hash (provenance + dedup) +✅ extractor, verifier, categorizer (deterministic role labels) +✅ schema_version (forward-compat) +✅ embedding pre-computed (already in HybridIndexer Layer 2!) +✅ category, source_label, source_service (taxonomy + origin) +✅ text (the distilled content) + +❌ no observer_notes +❌ no commands_run / tool_calls +❌ no validation_results / failure_markers +❌ no human_override + +So: **the `distilled_*` streams are an EvidenceRecord prototype, narrowed to LLM-extracted text.** Extending the schema to cover the missing fields (or sourcing them via JOIN to other streams) is the Phase 1 work. + +`contract_analyses.jsonl` is the **other** prototype — it carries observer integration fields (verdict, confidence, notes, src) plus retrieval telemetry (matrix_corpora, matrix_hits, matrix_ms) plus per-call cost/duration. Different shape, but more complete in some axes. + +The right move is to **reconcile both shapes** into a single schema rather than picking one. + +### Vector corpora (HybridIndexer Layer 2) + +20 corpora live in `data/vectors/*.parquet`: + +- `lakehouse_arch_v1` — architecture corpus +- `lakehouse_symbols_v1` — symbol corpus (via tree-sitter or grep) +- `lakehouse_answers_v1` — gold-standard prior reviews + escalations (commit `0844206`) +- `scrum_findings_v1` — old, superseded by answers_v1 +- `distilled_factual_v202604*`, `distilled_procedural_v202604*`, `distilled_config_hint_v202604*` — vectorized distilled streams +- `kb_team_runs_v1`, `kb_team_runs_agent`, `llm_team_runs_v1` — LLM Team artifact corpora +- `chicago_permits_v1`, `entity_brief_v1`, `ethereal_workers_v1`, `workers_500k_v8` — domain corpora +- `threat_intel_v1`, `sec_tickers_v1` — external + +The hybrid retrieval pattern is established: `mode.rs` queries top_k from each named corpus, merges by score, takes top 8, drops via `/relevance`. **Keyword/BM25 is missing** (the spec asks for hybrid keyword + semantic) — but DataFusion in queryd can run substring/regex queries on the underlying Parquet, so the substrate is there. + +--- + +## 4. Gap analysis (spec module → real gap) + +| Spec module | What we have | Gap | +|------|------|-----| +| Evidence Collector | 23 source JSONLs, 2 prototype schemas (`distilled_*`, `contract_analyses`) | Unified `EvidenceRecord` schema spanning all sources + JOIN view by run_id/file/timestamp | +| Success Scorer | 5 scrum_applier gates, auditor verdicts, mode_compare grounding %, pathway replay rate, scrum verdict, observer accept/reject | Single deterministic function combining these into 4 categories with explicit reasons[] | +| Playbook Extractor | bug_fingerprints (semantic-correctness layer), `_playbook_memory/`, `_playbook_lessons/` (50+ JSON), distilled_procedures.jsonl | Full task-flow playbooks (model routing path + commands_run + recovery + escalation triggers); current playbooks are bug-pattern + staffing-fill, not procedural | +| Hybrid Indexer | 20 vector corpora + pathway_memory + auditor `kb_index.ts` | Keyword/BM25 layer; task-tag filters (the embedding side is solid) | +| Dataset Builder | nothing exporting in spec format | NET NEW — `build_rag_dataset.ts`, `build_sft_dataset.ts`, `build_preference_dataset.ts` | +| Scratchpad Normalizer | tree-split scratchpads (text), `distilled_*.jsonl` (LLM-extracted) | Structured normalization of scrum/auditor scratchpads into objective/completed/failed/pending JSON | +| PRD Drift Comparator | auditor inference + static + `phase_sweep_findings.jsonl` + `doc_drift_corrections.jsonl` | Per-repo-state snapshot (the existing pieces are per-PR or per-phase) | +| Model Routing Ledger | `model_trust.jsonl` + `mode_experiments.jsonl` + strong-model downgrade gate | Aggregated, queryable view by task_type × model_name | +| Receipts | per-call jsonl rows + auditor verdicts | Per-pipeline-stage `receipt.json` with git_sha + input/output hashes + record_counts | + +--- + +## 5. Risks + +1. **Drift from existing loops.** The scrum, auditor, and observer pipelines all write into the substrate. A distillation pipeline that defines its own EvidenceRecord without conforming to those producers' shapes will drift. Mitigation: derive `EvidenceRecord` schema from existing JSONL keys, formalize what's there before adding new fields. + +2. **Over-distillation as theater.** It's tempting to "extract" content from raw runs without checking the existing distilled_facts/procedures already cover the run. Mitigation: dedup by `sig_hash` against existing distilled streams before extracting; emit pure pass-through rows when source already has a distilled twin. + +3. **Stale extraction.** `distilled_facts.jsonl` was last touched 2026-04-23 — 3 days old. `distilled_config_hints.jsonl` similar. If the extraction pipeline that produces them has rotted, building on top of them propagates rot. Mitigation: run the distillation extractor once on a fresh run before treating these as canonical; verify schema_version still matches. + +4. **No-leak invariant on SFT.** The spec is non-negotiable: rejected runs must NEVER appear in `exports/sft/instruction_response.jsonl`. Easy to violate via JOIN bugs. Mitigation: SFT export reads only `category=accepted` rows from `scored-runs/*.jsonl`; tests enforce this with a fixture containing rejected/partial mix. + +5. **Provenance integrity.** Every export row must trace to a source jsonl row. Mitigation: `provenance` field is `{source_file, line_offset, sig_hash}`; export-side validator checks each row's source_file exists and contains a row with matching sig_hash. + +6. **Receipts as security theater.** A receipt that just says "ran successfully" is worse than nothing. Mitigation: receipts include git_sha, sha256 of input/output files, record_counts (in vs out), and an explicit `validation_pass` boolean tied to schema validators. + +7. **Hybrid index keyword side.** Adding BM25 over Parquet via DataFusion is doable but requires a custom UDF. If we punt this to "later," the hybrid in HybridIndexer is dishonest naming. Mitigation: ship Phase 1-5 with semantic-only and rename the module `SemanticIndexer`; add BM25 in a follow-up phase rather than claiming hybrid prematurely. + +8. **Upstream model outage.** Just observed: `kimi-k2:1t` is currently 500-ing on Ollama Cloud. If distillation pipeline depends on a single model for verification, an outage breaks the whole pipeline. Mitigation: deterministic validators must NOT call any LLM; only the LLM-driven steps (initial extraction) should depend on cloud. Failures degrade gracefully — extracted text gets routed to `needs_human_review` not silently dropped. + +--- + +## 6. Recommended integration points + +1. **Reuse `auditor/kb_index.ts` as the EvidenceCollector substrate.** It already reads JSONL streams. Extend it to emit the unified EvidenceRecord by JOINing across streams by `run_id`/`file`/`sig_hash`. + +2. **Reuse `crates/shared/src/profiles/` as the schema home for model ledger entries.** `MemoryProfile` and `RetrievalProfile` are already typed. Add `ModelRoutingLedger` alongside. + +3. **Reuse `mode_experiments.jsonl` as the per-call truth source.** It's the most complete record per call (mode, model, sources, response, latency_ms, ts). Treat it as the canonical "execution trace" for any /v1/mode/execute call. + +4. **Reuse `data/vectors/*` as the HybridIndexer storage.** Don't add a parallel index — the Parquet + HNSW pattern is already proven. The new RAG export emits TO an existing-shaped corpus. + +5. **Reuse `scripts/build_*_corpus.ts` as the dataset-building convention.** They're already idempotent, take env knobs (LH_GATEWAY, LH_CHUNK_SIZE, LH_OVERLAP), and POST to `/vectors/index`. The new export scripts follow the same shape. + +6. **Reuse `mcp-server/observer.ts` as the validation event sink.** Distillation pipeline stages emit `/event` calls so a future UI can show pipeline progress alongside scrum + scenario events. + +7. **Reuse `auditor/policy.ts` as the gate-pattern reference.** The 5-gate scrum_applier and the `policy.ts` severity dispatch both encode the discipline of "deterministic check first, model opinion never." Success Scorer follows the same pattern. + +8. **Reuse `contract_analyses.jsonl` as the EvidenceRecord prototype.** It's the closest existing schema to what now.md asks for. Migrate its fields into the unified EvidenceRecord; backfill its rows into `data/evidence/`. + +--- + +## 7. Schemas to formalize in Phase 1 + +Based on the inventory above, the schemas Phase 1 needs to define are: + +1. **EvidenceRecord** — derived from `contract_analyses` + `mode_experiments` + observer fields + the spec's required fields (run_id, task_id, timestamp, model_name, model_role, input_hash, output_hash, source_files, commands_run, retrieved_context, observer_notes, scratchpad_summary, success_markers, failure_markers, validation_results, human_override, provenance) +2. **ScoredRun** — `{evidence_run_id, category in {accepted, partially_accepted, rejected, needs_human_review}, reasons: string[], scored_at, scorer_version}` +3. **Playbook** — `{playbook_id, task_type, problem_pattern, useful_context, model_routing_path, commands_worked, commands_failed, validation_steps, repo_files_touched, recovery_strategy, known_failure_modes, escalation_threshold, acceptance_criteria, source_run_ids, created_at}` +4. **ScratchpadSummary** — `{run_id, current_objective, completed_steps, failed_steps, pending_steps, important_paths, decisions, unresolved_questions, validation_status, next_command, source_scratchpad_hash}` +5. **ModelLedgerEntry** — `{model_name, model_provider, task_type, success_rate, failure_modes, best_partner_model, escalation_role, cost, latency_p50, latency_p95, context_window, sample_count, last_updated}` +6. **RagSample** — spec shape exactly +7. **SftSample** — spec shape exactly + strict `score=accepted` invariant +8. **PreferenceSample** — spec shape exactly + `chosen != rejected` invariant +9. **Receipt** — `{command, git_sha, input_files: [{path, sha256}], output_files: [{path, sha256}], record_counts: {in, out}, validation_pass, errors, warnings, duration_ms, started_at, ended_at}` + +Each schema lands in `crates/shared/src/schemas/distillation/` (Rust source-of-truth) + `auditor/schemas/distillation/` (TS validators). Phase 1 acceptance: every schema has 2+ positive fixtures (drawn from existing JSONL rows) and 2+ negative fixtures (missing required, wrong type, no provenance). + +--- + +## 8. Phase 1 readiness checklist + +Before Phase 1 starts, the following must be true: + +- [x] Recon doc exists (this file) +- [x] Sample shapes captured for the 8+ source JSONLs the schemas derive from +- [x] Existing distilled_* streams audited — confirmed they're prototypes, not blockers +- [x] Existing vector corpora inventoried — confirmed HybridIndexer Layer 2 substrate is real +- [x] Risks listed with mitigations +- [x] Integration points named — derive, don't reinvent + +Phase 1 is unblocked after this document is reviewed by the user. Implementation begins with `crates/shared/src/schemas/distillation/evidence_record.rs` + matching `auditor/schemas/distillation/evidence_record.ts` Zod validator + 2/2 fixtures from `distilled_facts.jsonl` and `contract_analyses.jsonl`. + +--- + +## 9. What this document is NOT + +- Not a green-light to start implementation. The spec is explicit: schemas first, then everything else. +- Not a commitment to build all 9 schemas in parallel. Phase 1 ships the EvidenceRecord schema alone if necessary, with the others queued behind it. +- Not a replacement for the spec at `/home/profit/now.md`. Spec is canonical; this document maps spec onto current state. +- Not a survey of the staffing pipeline (`crates/validator/staffing/*`, scenarios/, etc.). Distillation is orthogonal — the staffing pipeline is one of the many sources distillation reads from, not its target. diff --git a/docs/recon/staffing-lakehouse-distillation-recon.md b/docs/recon/staffing-lakehouse-distillation-recon.md new file mode 100644 index 0000000..7207bf7 --- /dev/null +++ b/docs/recon/staffing-lakehouse-distillation-recon.md @@ -0,0 +1,266 @@ +# Staffing Lakehouse × Distillation Substrate — Recon + +**Date:** 2026-04-27 +**Status:** Phase 0 (read-only inventory — no implementation yet) +**Spec:** J's "Lakehouse Staffing Integration" prompt +**Distillation tag (consumer of):** `distillation-v1.0.0` (commit `e7636f2`) + +This document inventories the staffing surface in the Lakehouse repo and identifies where the distillation substrate (Phases 0-8) should attach as a *consumer*. **No distillation core mutation — staffing builds on top.** + +The headline finding: **staffing has substantial existing infrastructure but is undocumented as a system.** Validators are scaffolds, scenarios are test fixtures, synthetic data spans 6+ shapes with overlapping intent, and there's no unified staffing audit. The integration work is orchestration over what already exists, not greenfield. + +--- + +## 1. Existing staffing schemas + +### Rust validators (`crates/validator/src/staffing/`) + +| File | Shape | Status | +|---|---|---| +| `mod.rs` | trait + module wiring | scaffold complete | +| `fill.rs::FillValidator` | validates `{fills: [{candidate_id, name}]}` against Artifact::FillProposal | schema check live; worker-existence + status + geo checks are TODO (commented in source) | +| `playbook.rs::PlaybookValidator` | validates Artifact::Playbook (operation format, endorsed_names cap, fingerprint) | schema-shape only; no semantic content check | +| `email.rs` | email-domain validation | scaffold | + +### Profiles (`crates/shared/src/profiles/`) + +| File | Purpose | +|---|---| +| `execution.rs` | execution profile (model routing per task class) | +| `memory.rs` | MemoryProfile (Phase 19 playbook boost ceiling, history cap, doc stale window, auto-retire) | +| `observer.rs` | Observer profile (failure cluster size, alert cooldown, ring size, langfuse forward) | +| `retrieval.rs` | RetrievalProfile (top_k, rerank_top_k, freshness cutoff, boost_playbook_memory, enforce_sensitivity_gates) | + +These are **typed** but auditing whether they're enforced at runtime is part of Phase 1 work. + +### PII (`crates/shared/src/pii.rs`) + +`detect_sensitivity(column_name)` → maps column names to sensitivity classes (`Pii`, `Financial`, `Public`). Verified by tests: +- `email`, `contact_email`, `ssn` → Pii +- `salary`, `bill_rate` → Financial + +`catalogd::service.rs:264` carries `column_redactions: HashMap` per dataset. Catalog enforces, but the audit needs to confirm masking is actually applied at query time. + +--- + +## 2. Synthetic data inventory + +| File | Rows | Shape | Status assessment | +|---|---|---|---| +| `data/datasets/candidates.parquet` | 1,000 | candidate_id, first_name, last_name, email, phone, city, state, skills, years_experience, hourly_rate_usd, status | **Has PII (raw email + phone)**. CAND-* IDs. status field: `placed`, `unknown others`. Compact + realistic. | +| `data/datasets/job_orders.parquet` | 15,000 | job_order_id, client_id, title, vertical, bill_rate, pay_rate, status, city, state, zip, description | JO-* IDs, CLI-* clients. Verticals: Admin, Manufacturing(?), etc. Realistic shape. **No candidate-fill linkage table observed.** | +| `data/datasets/workers_500k.parquet` | 500,000 | worker_id (int), name, role, email, phone, city, state, zip, skills (CSV string), certifications, archetype, reliability/responsiveness/engagement/compliance/availability (0-1 floats), communications (multi-msg string), resume_text | **Largest + richest source.** Has PII. archetype enum (flexible/?). 4-axis personality scores. Resume text + comm log = good RAG/SFT material. | +| `data/datasets/workers_100k.parquet` | 100,000 | (presumed same as 500k) | scaled-down sibling | +| `data/datasets/ethereal_workers.parquet` | 10,000 | same as workers_500k schema | scenario-friendly subset | +| `data/datasets/client_workersi.parquet` | 160 | worker_id, name, role, city, state, email, phone, skills, certifications, availability, reliability, archetype | **Different shape** (no scores beyond reliability+availability, no resume_text). Probably client-side "approved roster" — the worker pool a client has historically used. | +| `data/datasets/client_workerskjkk.parquet` | (similar) | (same as above) | typo-named sibling — gap to clean up | +| `data/datasets/sparse_workers.parquet` | 200 | name, phone, role, city, state, notes | **Different shape** — no IDs, no scores, just contact + notes. Looks like edge-case test data (sparse field coverage). | +| `data/datasets/new_candidates.parquet` | 3 | name, phone, email, city, state, skills, years | Demo / smoke-test data. Tiny. | + +**Total worker-shape rows on disk: ~625k** across 5 files. Schema fragmentation (3 distinct shapes) is a real issue — see gap report. + +### Scenarios (`tests/multi-agent/scenarios/`) + +44 JSON files covering specific staffing days. Sample shape (Heritage Foods Indianapolis 2026-04-23): +```json +{ "client": "Heritage Foods", "date": "2026-04-23", "events": [ + { "kind": "baseline_fill", "at": "10:30", "role": "Machine Operator", "count": 2, + "city": "Indianapolis", "state": "IN", "shift_start": "10:30 AM" }, + { "kind": "recurring", "at": "10:30", "role": "Receiving Clerk", "count": 1, ... } +]} +``` + +Event kinds observed: `baseline_fill`, `recurring`. Cities span Indianapolis, Cincinnati, Madison, Toledo, Detroit, Columbus, etc. — Midwestern + Eastern US. + +### Playbook lessons (`data/_playbook_lessons/`) + +64 JSON files. Sample shape (Heritage Foods 2026-04-21): +```json +{ "date": "...", "client": "...", "cities": "...", "states": "...", + "events_total": 5, "events_ok": 3, "checkpoint_count": 2, + "model": "gpt-oss:20b", "cloud": false, + "lesson": "", + "checkpoints": [{ "after": "09:30", "risk": "...", "hint": "..." }, ...] } +``` + +These are **post-run retrospectives** — the staffing ops loop wrote them after each scenario completed. Goldmine for RAG. + +--- + +## 3. Ingestion paths + storage layout + +### Object storage / Parquet +- `data/datasets/*.parquet` is the disk-resident store. Treated as input by `ingestd` (CSV/JSON/PDF/Postgres/MySQL ingest in `crates/ingestd`). +- **No catalog manifests observed for the staffing parquets** (none under `data/_catalog/manifests/` matching candidate/worker/job names). The datasets exist on disk but may not be registered with `catalogd` — gap. + +### MariaDB +- `crates/queryd/src/context.rs` has a "candidates_safe" view referenced by recent code (failed at boot when schema mismatched, see prior memory `feedback_endpoint_probe_discipline.md`). +- Schema for the views isn't visible from grep — needs DB inspection. + +### Vector indexes (`data/vectors/`) +- `workers_500k_v8.parquet` — vector corpus matched by `staffing_inference_lakehouse` mode in `config/modes.toml` +- `ethereal_workers_v1.parquet` — alt corpus +- `entity_brief_v1.parquet` — Chicago-permit-style entity briefs (different domain but same indexer) +- `chicago_permits_v1.parquet` — separate but uses same machinery + +### KB streams that touch staffing +- `data/_kb/contract_analyses.jsonl` — contractor + permit analyses (related but not staffing per se) +- `data/_kb/staffers.jsonl` — 1.5K, small, not yet inspected +- `data/_kb/outcomes.jsonl` — scenario outcomes log (used by Phase 2 transforms in distillation) +- `data/_playbook_memory/state.json` — Phase 19 playbook memory state + +--- + +## 4. Search / indexing logic + +### Staffing-aware mode runner +`config/modes.toml` defines `staffing_inference` task class: +```toml +preferred_mode = "staffing_inference_lakehouse" +default_model = "openai/gpt-oss-120b:free" +matrix_corpus = "workers_500k_v8" +``` + +The mode runner (Phase 5+ work in this session) composes: +- `EnrichmentFlags { include_file_content, include_bug_fingerprints, include_matrix_chunks, use_relevance_filter, framing: Staffing }` +- Pulls top-K from `workers_500k_v8` corpus +- `FRAMING_STAFFING` system prompt instructs: "only recommend candidates whose names appear in the matrix data; do NOT fabricate workers" + +### Pass 4 staffing harness +`scripts/mode_pass4_staffing.ts` ships synthetic FillRequest payloads through the runner. Each request is a JSON `{city, state, role, count, deadline, notes?}` posted as `file_content` (the runner's input shape). Validation: did the model surface real worker_ids from the corpus, or fabricate. + +### What's missing +- **No "candidate matching" deterministic scorer** beyond mode-runner LLM. Staffing audit should add: given a job_order, can we score worker fit deterministically (skills overlap, geo distance, status filter) BEFORE asking the LLM? Currently the LLM does both retrieval and scoring. +- **No indexed link table between candidates.parquet and workers_500k.parquet.** They look like the SAME population in different shapes — the workers_500k has the scores + resume + comms, candidates has the basic contact + status + hourly rate. If they're meant to be different populations, the join key is unclear; if they're the same, there's redundancy. + +--- + +## 5. Audit / event tables + +**No staffing-specific audit/event log observed.** Searched for `audit_event`, `outcome_event`, `fill_event` patterns in `crates/` — zero hits. The closest existing infrastructure: +- `data/_kb/outcomes.jsonl` — per-run scenario outcomes (used by distillation transforms) +- `data/_observer/ops.jsonl` — observer ring buffer (general-purpose, not staffing) +- `data/_playbook_lessons/*.json` — post-run lessons (retrospective, not audit) + +**Gap:** staffing fills happen, scenarios complete, but **no schema-backed event log** captures: which worker_ids were proposed, accepted, filled, rejected, with what timing, against which job_order. The closest record is in scenarios + playbook_lessons but those are unstructured + per-scenario, not a queryable log. + +--- + +## 6. PII / tokenization boundaries + +### Detection +`crates/shared/src/pii.rs::detect_sensitivity` recognizes: `email`, `contact_email`, `ssn`, `phone` → Pii. `salary`, `bill_rate`, `pay_rate` → Financial. + +### Enforcement +`catalogd::service.rs` carries per-dataset `column_redactions: HashMap` — but enforcement at query time wasn't visible from initial grep. Auditing whether masking actually happens when `staffing_inference_lakehouse` retrieves from `workers_500k_v8` is in scope. + +### Risk +Raw email + phone live in `workers_500k.parquet` and `candidates.parquet`. If the LLM mode runner retrieves chunks and the catalog hasn't masked them, **the LLM sees PII**. Spec says "do not expose raw PII to AI" — auditing this is non-negotiable for the staffing integration. + +--- + +## 7. PRD docs + +- `docs/PRD.md` — main PRD. §32 names staffing as the reference implementation. §158 explicitly notes Phase 19 playbook learning was originally write-only, claims it's now closed — **verify**. +- `docs/CONTROL_PLANE_PRD.md` — long-horizon vision (2026-04-22 pivot) + +PRD references staffing throughout but doesn't itemize a "staffing PRD checklist" the way the auditor's pr_audit mode expects per-PR claims. Drift detection between PRD claims and code reality is exactly the auditor's job — running it on the PRD as input rather than a PR diff is a configuration shift, not new code. + +--- + +## 8. Where distillation outputs should attach + +The Phase 0-8 distillation substrate is **already feeding the staffing surface in two places**: + +1. **`staffing_inference_lakehouse` mode → `workers_500k_v8` matrix corpus.** This is read-only consumption; no change needed. +2. **`pr_audit` mode → `lakehouse_answers_v1` corpus.** Generic; not staffing-specific. + +**What's missing for staffing:** + +a. **Staffing-specific RAG corpus** — `staffing_answers_v1` built from playbook_lessons + scored scenarios. Same builder pattern as `lakehouse_answers_v1` (commit `0844206`'s `scripts/build_answers_corpus.ts`); just point at staffing inputs. + +b. **Staffing audit task class** — `staffing_audit` mode in `config/modes.toml`, paralleling the auditor's `pr_audit` work. Reads PRD claims + scenario outcomes, asks "do we ship what the PRD claims for staffing?" + +c. **Staffing acceptance fixture** — same shape as `tests/fixtures/distillation/acceptance/` but with synthetic candidate + job_order + scenario + lesson rows. Pins staffing invariants: PII masked, candidates valid, scenarios reproducible. + +d. **Staffing replay tasks** — drop sample fill requests through `./scripts/distill replay` to see if the local model proposes real worker_ids vs fabricates. + +**Implementation approach (deferred until gap report + J approval):** + +``` +scripts/staffing/ + audit.ts # ./scripts/staffing audit — single entry + build_answers.ts # build_staffing_answers_v1 from lessons + scenarios + build_corpus_v9.ts # rebuild workers_500k_v9 with PII masking applied + acceptance.ts # staffing-specific 22-invariant gate + +tests/fixtures/staffing/ + candidates_sample.parquet + job_orders_sample.parquet + scenario_sample.json + lesson_sample.json + +reports/staffing/ + staffing-audit-report.md + staffing-prd-drift-report.md + staffing-search-quality-report.md + staffing-synthetic-data-report.md +``` + +**ALL of the above is consumer-side.** The distillation pipeline's `scripts/distillation/`, `auditor/schemas/distillation/`, and Phase 0-8 commits are NOT touched. + +--- + +## 9. Risks identified during recon + +1. **Synthetic data shape fragmentation** — 3 distinct worker schemas across 5 files. If staffing audit assumes one shape and the system uses another, audits will silently miss. +2. **PII enforcement unverified.** Catalog has a redaction primitive; whether it's wired to mode-runner retrieval is the audit's first deterministic check. +3. **No structured staffing audit log.** Lessons + outcomes are retrospective summaries, not per-event records. Without per-event records, deterministic checks like "every worker proposed by the LLM exists in workers_500k" can't run on historical scenarios. +4. **Validator scaffolds.** `FillValidator::validate` does schema-shape only — the worker-existence/status/geo TODOs in the source are exactly the deterministic gates the staffing audit needs to run. Wiring them is consumer work, not distillation work. +5. **Fragile PRD ↔ code linkage.** PRD §158 claims Phase 19 closed the playbook write-only gap; no audit verifies. The staffing-prd-drift-report should run an inference-style claim verification against PRD claims, not unlike the auditor's pr_audit but with PRD as the source. +6. **`workers_500k_v8` is the embedded corpus the LLM sees.** If it carries PII without masking, the LLM has been seeing PII. Auditing the corpus content (not just the SQL views) is required. +7. **64 playbook_lessons + 44 scenarios = ~108 RAG candidates.** Plenty for a staffing_answers corpus, but PII filtering must apply before vectorization. Currently lessons may contain worker names ("Susan X. Ruiz double-booked"). + +--- + +## 10. Recommended integration points (where consumer code attaches) + +1. **Staffing audit script** at `scripts/staffing/audit.ts` reads from existing distillation outputs: + - `data/scored-runs/` (filter to task_id starting `permit:` or `scenario:`) + - `exports/quarantine/*.jsonl` (any staffing-specific quarantines) + - `reports/distillation//summary.json` (cross-reference) + +2. **Reuse Phase 5 receipts harness** — staffing audit writes a `StageReceipt` matching the existing schema, with a new `stage` value (extend the enum to `"staffing-audit"` only after schema-version bump if needed; otherwise use the existing reserved `"index"` slot or just write a parallel manifest under `reports/staffing/`). + +3. **Reuse Phase 1 schemas** — RagSample, SftSample, PreferenceSample work for staffing data without modification. The `tags` array can carry `task:staffing.fill` to keep the corpus self-tagged. + +4. **Reuse Phase 7 replay** — `./scripts/distill replay --task "fill 2 welders in Toledo OH"` already works; just feed it from synthetic FillRequest payloads. + +5. **Reuse Phase 8 audit-full** — its drift baseline tracks distillation metrics; staffing audit gets its OWN baseline file at `data/_kb/staffing_audit_baselines.jsonl`. + +6. **Schema invariants for staffing**: + - every candidate_id in candidates.parquet appears in workers_500k.parquet OR is documented as "candidate-distinct-from-worker" + - every status value in candidates.parquet is in a known enum + - every email in workers/candidates is masked when it reaches the LLM (audit by inspecting prompt traces in Langfuse) + +--- + +## 11. What this document is NOT + +- Not a green-light to start staffing audit implementation. The spec is explicit: synthetic-data gap report next, THEN J reviews, THEN code. +- Not an audit itself. This is the inventory — the audit's first run will surface findings. +- Not a redesign of staffing data shapes. The fragmentation is documented for the gap report; reshape decisions are J's call, not this recon's. +- Not a modification of the distillation v1.0.0 substrate. Per spec: "DO NOT modify the completed distillation pipeline unless a blocking integration bug is found." + +--- + +## 12. Phase 1 readiness checklist + +Before staffing implementation starts, the following must be true: + +- [x] Recon doc exists (this file) +- [ ] Synthetic-data gap report exists (next) +- [ ] J reviews both before any code change +- [ ] J approves audit scope + first invariants + +Phase 1 is unblocked only after the gap report is reviewed. diff --git a/mcp-server/index.ts b/mcp-server/index.ts index df5b5f9..de804fa 100644 --- a/mcp-server/index.ts +++ b/mcp-server/index.ts @@ -18,6 +18,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js" import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js"; import { z } from "zod"; import { startTrace, logSpan, logGeneration, scoreTrace, flush as flushTraces } from "./tracing.js"; +import { buildPermitBrief } from "./entity.js"; const BASE = process.env.LAKEHOUSE_URL || "http://localhost:3100"; const PORT = parseInt(process.env.MCP_PORT || "3700"); @@ -39,6 +40,29 @@ async function api(method: string, path: string, body?: any, retries = 2) { const ms = Date.now() - t0; let parsed: any; try { parsed = JSON.parse(text); } catch { parsed = { raw: text, status: resp.status }; } + + // Trace the call if we have an active trace. Pre-existing edit had + // this block at module scope, dangling after the closing brace of + // api() — parsed broken until fixed 2026-04-24. + if (activeTrace) { + const isGen = path.includes("/generate"); + if (isGen) { + logGeneration(activeTrace, `lakehouse${path}`, { + model: body?.model || "unknown", + prompt: typeof body?.prompt === "string" ? body.prompt.slice(0, 500) : JSON.stringify(body).slice(0, 300), + completion: typeof parsed?.text === "string" ? parsed.text.slice(0, 500) : JSON.stringify(parsed).slice(0, 300), + duration_ms: ms, + tokens_in: parsed?.prompt_eval_count, + tokens_out: parsed?.eval_count, + }); + } else { + logSpan(activeTrace, `lakehouse${path}`, body, { + rows: parsed?.row_count, sources: parsed?.sources?.length, + sql_matches: parsed?.sql_matches, method: parsed?.method, + }, ms); + } + } + return parsed; } catch (e: any) { if (attempt === retries) throw e; @@ -52,29 +76,6 @@ async function api(method: string, path: string, body?: any, retries = 2) { throw new Error("unreachable"); } - // Trace the call if we have an active trace - if (activeTrace) { - const isGen = path.includes("/generate"); - if (isGen) { - logGeneration(activeTrace, `lakehouse${path}`, { - model: body?.model || "unknown", - prompt: typeof body?.prompt === "string" ? body.prompt.slice(0, 500) : JSON.stringify(body).slice(0, 300), - completion: typeof parsed?.text === "string" ? parsed.text.slice(0, 500) : JSON.stringify(parsed).slice(0, 300), - duration_ms: ms, - tokens_in: parsed?.prompt_eval_count, - tokens_out: parsed?.eval_count, - }); - } else { - logSpan(activeTrace, `lakehouse${path}`, body, { - rows: parsed?.row_count, sources: parsed?.sources?.length, - sql_matches: parsed?.sql_matches, method: parsed?.method, - }, ms); - } - } - - return parsed; -} - const server = new McpServer({ name: "lakehouse", version: "1.0.0" }); server.tool( @@ -960,6 +961,61 @@ async function main() { return new Response(Bun.file(import.meta.dir + "/console.html")); } + // ─── Contractor / entity drill-down page ─── + // Single-contractor portfolio view across every wired source: + // OSHA national, Chicago history, ticker chart, parent link, + // federal contracts, debarment, unions, training. Click any + // contractor name in a permit Entity Brief to land here. + if (url.pathname === "/contractor") { + return new Response(Bun.file(import.meta.dir + "/contractor.html"), { + headers: { ...cors, "Content-Type": "text/html" }, + }); + } + if (url.pathname === "/intelligence/contractor_profile" && req.method === "POST") { + const start = Date.now(); + try { + const b = (await req.json().catch(() => ({}))) as { name?: string }; + if (!b.name) return err("missing name", 400); + // Use the entity-brief library directly — single entity, all sources. + const { fetchOshaBrief, fetchTickerBrief, fetchContractorHistory, fetchParentLink, fetchFederalContracts, fetchDebarmentBrief, fetchNlrbBriefReal, fetchIlsosBrief, fetchNewsMentions, fetchDiversityCerts, scoreNewsSentiment, fetchBlsConstructionTrend, normalizeEntityName, entityTicker } = await import("./entity.js"); + const [osha, stock, history, parent_link, federal, debarment, nlrb, ilsos, news, diversity, macro] = await Promise.all([ + fetchOshaBrief(b.name), + fetchTickerBrief(b.name), + fetchContractorHistory(b.name), + fetchParentLink(b.name), + fetchFederalContracts(b.name), + fetchDebarmentBrief(b.name), + fetchNlrbBriefReal(b.name), + fetchIlsosBrief(b.name), + fetchNewsMentions(b.name), + fetchDiversityCerts(b.name), + fetchBlsConstructionTrend(), + ]); + const news_sentiment = news ? scoreNewsSentiment(news) : null; + return ok({ + key: normalizeEntityName(b.name), + display_name: b.name, + ticker: entityTicker(b.name), + osha, + stock, + history, + parent_link, + federal, + debarment, + nlrb, + ilsos, + news, + news_sentiment, + diversity, + macro, + generated_at: new Date().toISOString(), + duration_ms: Date.now() - start, + }); + } catch (e: any) { + return err(`contractor_profile: ${e.message}`, 500); + } + } + // Intelligence: Market data — public building permits → staffing demand forecast if (url.pathname === "/intelligence/market" && req.method === "POST") { const start = Date.now(); @@ -1158,14 +1214,86 @@ async function main() { // a PROPOSED fill drawn from our 500K worker bench. Surfaces the // meta-index dimension directly: "what past similar fills had in // common" for this role + geo. + // Architecture signals — the "our substrate is better than the + // alternatives" proof surface. Pulls live health numbers so the + // dashboard can show, per-card or in a top bar, that the claims + // we make in the PRD (instant searches, self-regulation, + // hot-swap, indexed-at-ingest) are verifiable right now. + if (url.pathname === "/intelligence/arch_signals" && (req.method === "GET" || req.method === "POST")) { + try { + const t0 = Date.now(); + // Index freshness + shape (hot-swap + clever-index claims) + const idxRaw = await fetch("http://localhost:3100/vectors/indexes/workers_500k_v1", { + signal: AbortSignal.timeout(3000), + }).then(r => r.ok ? r.json() : null).catch(() => null); + + // Playbook memory — "self-regulates via learned playbooks" + const pbmRaw = await fetch("http://localhost:3100/vectors/playbook_memory/stats", { + signal: AbortSignal.timeout(3000), + }).then(r => r.ok ? r.json() : null).catch(() => null); + + // Pathway memory — ADR-021 compounding-bug-grammar surface + const pwmRaw = await fetch("http://localhost:3100/vectors/pathway/stats", { + signal: AbortSignal.timeout(3000), + }).then(r => r.ok ? r.json() : null).catch(() => null); + + // Live instant-search probe — one trivial hybrid call so the + // latency number on screen is fresh, not cached. + const probeT0 = Date.now(); + await api("POST", "/vectors/hybrid", { + index_name: "workers_500k_v1", + filter_dataset: "workers_500k", + id_column: "worker_id", + sql_filter: "state = 'OH'", + question: "production worker", + top_k: 3, generate: false, + }).catch(() => ({})); + const probeMs = Date.now() - probeT0; + + return ok({ + generated_at: new Date().toISOString(), + duration_ms: Date.now() - t0, + index: idxRaw ? { + name: idxRaw.index_name, + source: idxRaw.source, + model: idxRaw.model_name, + dimensions: idxRaw.dimensions, + chunk_count: idxRaw.chunk_count, + doc_count: idxRaw.doc_count, + created_at: idxRaw.created_at, + backend: idxRaw.vector_backend, + last_used: idxRaw.last_used ?? null, + build_signature: idxRaw.build_signature ?? null, + } : null, + playbook_memory: pbmRaw ? { + entries: pbmRaw.entries_count ?? pbmRaw.count ?? 0, + rebuilt_at: pbmRaw.last_rebuilt_at ?? null, + } : null, + pathway_memory: pwmRaw ? { + total_pathways: pwmRaw.total_pathways ?? 0, + retired: pwmRaw.retired ?? 0, + with_audit_pass: pwmRaw.with_audit_pass ?? 0, + total_replays: pwmRaw.total_replays ?? 0, + } : null, + instant_search_probe_ms: probeMs, + }); + } catch (e: any) { + return err(`arch_signals: ${e.message}`, 500); + } + } + if (url.pathname === "/intelligence/permit_contracts" && req.method === "POST") { const start = Date.now(); try { const permitUrl = "https://data.cityofchicago.org/resource/ydr8-5enu.json"; // Recent + substantial permits only — skip tiny ones that // don't imply real staffing demand. + // Include contact_1 + contact_2 fields so the Entity Brief + // panel on each card can populate without a second fetch. + // Contacts identify the applicant / contractor by name — + // those are the keys we pass to OSHA/ILSOS enrichment. const permits: any[] = await fetch( - `${permitUrl}?$select=permit_type,work_type,work_description,reported_cost,street_number,street_direction,street_name,community_area,issue_date&` + `${permitUrl}?$select=id,permit_type,work_type,work_description,reported_cost,street_number,street_direction,street_name,community_area,issue_date,contact_1_name,contact_1_type,contact_2_name,contact_2_type&` + `$where=reported_cost>250000 AND issue_date>'2025-06-01'` + `&$order=issue_date DESC&$limit=6` ).then(r => r.json()).catch(() => []); @@ -1193,6 +1321,11 @@ async function main() { // query path exactly. k=200 to ensure boost fires across // the full memory surface (the embedding-discrimination // narrowness means under-k silently misses endorsements). + // + // Timed so the UI can surface "instant search from clever + // indexing at ingest" — the architecture claim J wants + // visible. Each contract card shows its hybrid latency. + const hybridT0 = Date.now(); const searchRes = await api("POST", "/vectors/hybrid", { index_name: "workers_500k_v1", filter_dataset: "workers_500k", @@ -1202,6 +1335,7 @@ async function main() { top_k: 5, generate: false, use_playbook_memory: true, playbook_memory_k: 200, }).catch(() => ({ sources: [] as any[] })); + const hybridMs = Date.now() - hybridT0; // Path 2 — discovered patterns for this role in this city. const patternRes = await api("POST", "/vectors/playbook_memory/patterns", { @@ -1240,14 +1374,72 @@ async function main() { else if (daysToDeadline <= 21) urgency = "soon"; else urgency = "scheduled"; + // Fill-probability ramp — staffing-industry heuristic. + // Base probability by pool_size (how many available workers + // match the role+geo), decayed by days-remaining. Produces + // a curve the UI can sparkline. + const poolSize = (searchRes.sql_matches ?? 0) as number; + const basePFill = poolSize >= count * 20 ? 0.95 + : poolSize >= count * 10 ? 0.85 + : poolSize >= count * 5 ? 0.70 + : poolSize >= count * 2 ? 0.55 + : poolSize >= count ? 0.35 + : 0.15; + const fillByDay = [0, 3, 7, 14, 21, 30].map((d) => { + // Front-loaded: most fills land in first 7 days; tail + // falls off quickly. This is a Weibull-ish shape that + // matches real staffing data we've seen. + const ramp = d === 0 ? 0.0 + : d <= 3 ? 0.35 + : d <= 7 ? 0.65 + : d <= 14 ? 0.85 + : d <= 21 ? 0.95 + : 1.0; + return { day: d, cumulative_pct: Math.round(basePFill * ramp * 100) }; + }); + + // Economics — "as though the contracts were accepted and + // filled." 40 hrs/week, default 12-week contract. Margin + // = (bill - avg_pay) × count × hours. Payout window is + // fill_date + 30d billing cycle. + const weeksAssumed = 12; + const hoursPerWeek = 40; + const avgPayRate = sources.length + ? sources.reduce((s, c) => s + (c.implied_pay_rate || 0), 0) / sources.length + : contractBillRate / BILL_MARKUP; + const grossRevenue = contractBillRate * count * hoursPerWeek * weeksAssumed; + const grossMargin = (contractBillRate - avgPayRate) * count * hoursPerWeek * weeksAssumed; + const overBillCount = sources.filter((c) => c.over_bill_rate).length; + const overBillPoolMargin = sources + .filter((c) => c.over_bill_rate) + .reduce((s, c) => s + (c.implied_pay_rate - contractBillRate) * hoursPerWeek * weeksAssumed, 0); + + // Shift inference from permit work_type + description. + // Construction defaults to 1st-shift (day). Heavy civil or + // facility work sometimes runs 2nd or split-shift. 3rd + // (overnight) is rare in commercial construction but real + // for maintenance / emergency calls. + const descLower = ((p.work_description || "") + " " + (p.work_type || "")).toLowerCase(); + const shifts: string[] = ["1st"]; // default day + if (/night|overnight|24\s*hr|emergency/.test(descLower)) shifts.push("3rd"); + if (/multi.?shift|round.?the.?clock|double.?shift/.test(descLower)) shifts.push("2nd"); + if (/weekend|saturday|sunday/.test(descLower)) shifts.push("4th"); + contracts.push({ permit: { + id: p.id, cost, work_type: p.work_type || "General construction", description: (p.work_description || "").substring(0, 140), address: `${p.street_number || ""} ${p.street_direction || ""} ${p.street_name || ""}`.trim(), community_area: p.community_area, issue_date: (p.issue_date || "").substring(0, 10), + // Contacts — used by /intelligence/permit_entities to + // enrich each card with OSHA + ILSOS on expand. + contact_1_name: p.contact_1_name || "", + contact_1_type: p.contact_1_type || "", + contact_2_name: p.contact_2_name || "", + contact_2_type: p.contact_2_type || "", }, implied_bill_rate: contractBillRate, timeline: { @@ -1260,12 +1452,32 @@ async function main() { role, count, city, state, - pool_size: searchRes.sql_matches, + pool_size: poolSize, candidates: sources, }, discovered_pattern: patternRes.discovered_pattern, pattern_matched: patternRes.matched_playbooks ?? 0, pattern_workers_examined: patternRes.total_workers_examined ?? 0, + // ADR-021 / PRD architecture claims surface — these fields + // let the UI show "instant search from clever indexing" + // and the fill economics beyond bill rate alone. + search_latency_ms: hybridMs, + fill_probability: { + base_pct: Math.round(basePFill * 100), + curve: fillByDay, + }, + economics: { + avg_pay_rate: Math.round(avgPayRate * 100) / 100, + hours_per_week: hoursPerWeek, + weeks_assumed: weeksAssumed, + gross_revenue: Math.round(grossRevenue), + gross_margin: Math.round(grossMargin), + margin_pct: grossRevenue > 0 ? Math.round((grossMargin / grossRevenue) * 100) : 0, + payout_window_days: [30, 45], + over_bill_count: overBillCount, + over_bill_pool_margin_at_risk: Math.round(overBillPoolMargin), + }, + shifts_needed: shifts, }); } @@ -1281,6 +1493,58 @@ async function main() { } } + // Intelligence: per-permit entity brief — OSHA + ILSOS + property + // Takes a permit identifier (we look it up from Chicago Socrata) or + // raw contact fields directly from the client. Returns an "ETF + // basket" shape: property + entities + per-entity risk factors. + // OSHA is live-scraped (cached 30d). ILSOS returns a structured + // placeholder because apps.ilsos.gov blocks our ASN. + if (url.pathname === "/intelligence/permit_entities" && req.method === "POST") { + const start = Date.now(); + try { + const b = await req.json().catch(() => ({})) as { + permit_id?: string; + address?: string; + work_type?: string; + contact_1_name?: string; + contact_1_type?: string; + contact_2_name?: string; + contact_2_type?: string; + fetch_osha?: boolean; + fetch_ilsos?: boolean; + }; + // If the caller didn't pass contact fields but did pass a + // permit_id, go pull the record from Chicago Socrata. + let permit = b; + if (b.permit_id && !b.contact_1_name) { + const u = `https://data.cityofchicago.org/resource/ydr8-5enu.json?$where=id='${encodeURIComponent(b.permit_id)}'`; + const rows = (await fetch(u).then((r) => r.json())) as any[]; + const p = rows?.[0]; + if (p) { + const addr = [p.street_number, p.street_direction, p.street_name] + .filter(Boolean) + .join(" "); + permit = { + permit_id: b.permit_id, + address: addr, + work_type: p.work_type, + contact_1_name: p.contact_1_name, + contact_1_type: p.contact_1_type, + contact_2_name: p.contact_2_name, + contact_2_type: p.contact_2_type, + }; + } + } + const brief = await buildPermitBrief(permit, { + fetchOsha: b.fetch_osha !== false, + fetchIlsos: b.fetch_ilsos !== false, + }); + return ok({ ...brief, duration_ms: Date.now() - start }); + } catch (e: any) { + return err(`permit_entities: ${e.message}`, 500); + } + } + // Removed 2026-04-20: /intelligence/learn was a legacy CSV writer // that destructively re-wrote successful_playbooks. /log and // /log_failure replace it cleanly via /vectors/playbook_memory/seed diff --git a/mcp-server/langfuse_bridge.ts b/mcp-server/langfuse_bridge.ts new file mode 100644 index 0000000..e66eea5 --- /dev/null +++ b/mcp-server/langfuse_bridge.ts @@ -0,0 +1,174 @@ +// langfuse_bridge — the missing piece called out in project_lost_stack.md +// and Phase 40 PRD. Polls Langfuse `/api/public/traces` at interval, +// forwards every completed trace to observer `:3800/event` with +// `source: "langfuse"`. Observer's existing ring buffer + analyzer +// pick it up, so the KB learns from cost/latency/provider deltas per +// model — not just from scenario outcomes. +// +// Loopback: observer persistOp() appends to data/_observer/ops.jsonl +// and its aggregator produces pathway_recommendations.jsonl. This +// bridge closes the feedback loop between LLM call metadata and the +// playbook/KB learning surface. +// +// State persistence: last-seen trace timestamp written to a JSON file +// so restarts don't double-emit. Bounded forward window (50/tick) so +// first-run catch-up doesn't hammer the observer. + +const LANGFUSE_URL = process.env.LANGFUSE_URL ?? "http://localhost:3000"; +const LANGFUSE_PUBLIC = process.env.LANGFUSE_PUBLIC_KEY; +const LANGFUSE_SECRET = process.env.LANGFUSE_SECRET_KEY; +const OBSERVER_URL = process.env.OBSERVER_URL ?? "http://localhost:3800"; +const POLL_INTERVAL_MS = Number(process.env.LANGFUSE_POLL_MS ?? 30000); +const BATCH_LIMIT = Number(process.env.LANGFUSE_BATCH_LIMIT ?? 50); +const STATE_FILE = process.env.LANGFUSE_STATE_FILE + ?? "/var/lib/lakehouse-guard/langfuse_last_seen.json"; + +interface LangfuseTrace { + id: string; + name?: string; + timestamp: string; + input?: any; + output?: any; + latency?: number; // seconds, per Langfuse API + totalCost?: number; + usage?: { input?: number; output?: number; total?: number }; + metadata?: any; +} + +interface State { last_seen_ts?: string } + +function basicAuth(): string { + return "Basic " + btoa(`${LANGFUSE_PUBLIC}:${LANGFUSE_SECRET}`); +} + +async function loadState(): Promise { + try { + const f = Bun.file(STATE_FILE); + if (!(await f.exists())) return {}; + return JSON.parse(await f.text()) as State; + } catch (e) { + console.warn(`[langfuse-bridge] state load failed: ${e}`); + return {}; + } +} + +async function saveState(s: State): Promise { + try { + await Bun.write(STATE_FILE, JSON.stringify(s)); + } catch (e) { + console.warn(`[langfuse-bridge] state save failed: ${e}`); + } +} + +async function fetchTracesSince(cursor?: string): Promise { + const url = new URL("/api/public/traces", LANGFUSE_URL); + url.searchParams.set("limit", String(BATCH_LIMIT)); + url.searchParams.set("orderBy", "timestamp.asc"); + if (cursor) url.searchParams.set("fromTimestamp", cursor); + const resp = await fetch(url, { + headers: { authorization: basicAuth() }, + signal: AbortSignal.timeout(10_000), + }); + if (!resp.ok) { + throw new Error(`langfuse ${resp.status}: ${(await resp.text()).slice(0, 200)}`); + } + const body: any = await resp.json(); + return (body.data ?? []) as LangfuseTrace[]; +} + +// Shape one Langfuse trace into the ObservedOp the observer expects +// (see mcp-server/observer.ts:29). `source: "langfuse"` is the +// provenance flag so the analyzer can weight traces differently from +// scenario-sourced events. +function toObservedOp(t: LangfuseTrace): Record { + const endpoint = t.metadata?.provider + ?? t.metadata?.model + ?? t.name + ?? "langfuse.trace"; + const inputSummary = typeof t.input === "string" + ? t.input.slice(0, 200) + : JSON.stringify(t.input ?? {}).slice(0, 200); + const outputSummary = typeof t.output === "string" + ? t.output.slice(0, 200) + : JSON.stringify(t.output ?? {}).slice(0, 200); + return { + timestamp: t.timestamp, + endpoint: `langfuse:${endpoint}`, + input_summary: inputSummary, + success: !t.metadata?.error, + duration_ms: Math.round((t.latency ?? 0) * 1000), + output_summary: outputSummary, + source: "langfuse", + sig_hash: t.metadata?.sig_hash, + event_kind: t.metadata?.task_class, + // Extra fields the observer doesn't schema but the KB aggregator + // can still pick up via JSON passthrough. + model: t.metadata?.model, + provider: t.metadata?.provider, + prompt_tokens: t.usage?.input, + completion_tokens: t.usage?.output, + total_tokens: t.usage?.total, + total_cost: t.totalCost, + }; +} + +async function forwardToObserver(op: Record): Promise { + const resp = await fetch(`${OBSERVER_URL}/event`, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify(op), + signal: AbortSignal.timeout(5_000), + }); + if (!resp.ok) { + throw new Error(`observer ${resp.status}: ${(await resp.text()).slice(0, 200)}`); + } +} + +async function tick(): Promise { + const state = await loadState(); + let traces: LangfuseTrace[]; + try { + traces = await fetchTracesSince(state.last_seen_ts); + } catch (e) { + console.warn(`[langfuse-bridge] fetch failed: ${e}`); + return; + } + if (traces.length === 0) { + console.log(`[langfuse-bridge] no new traces since ${state.last_seen_ts ?? "start"}`); + return; + } + let last = state.last_seen_ts ?? ""; + let forwarded = 0; + for (const t of traces) { + try { + await forwardToObserver(toObservedOp(t)); + forwarded++; + if (t.timestamp > last) last = t.timestamp; + } catch (e) { + console.warn(`[langfuse-bridge] forward ${t.id} failed: ${e}`); + // Don't advance cursor on forward failure — retry next tick. + break; + } + } + if (last) await saveState({ last_seen_ts: last }); + console.log( + `[langfuse-bridge] forwarded ${forwarded}/${traces.length}, last_seen=${last}`, + ); +} + +async function main(): Promise { + if (!LANGFUSE_PUBLIC || !LANGFUSE_SECRET) { + console.error("LANGFUSE_PUBLIC_KEY + LANGFUSE_SECRET_KEY required"); + process.exit(1); + } + console.log( + `[langfuse-bridge] polling ${LANGFUSE_URL} every ${POLL_INTERVAL_MS}ms → ${OBSERVER_URL}/event`, + ); + await tick(); + setInterval(tick, POLL_INTERVAL_MS); +} + +main().catch(e => { + console.error(`[langfuse-bridge] fatal: ${e}`); + process.exit(1); +}); diff --git a/mcp-server/observer.ts b/mcp-server/observer.ts index 13a2be2..edb6e45 100644 --- a/mcp-server/observer.ts +++ b/mcp-server/observer.ts @@ -17,6 +17,8 @@ * agents do and helps them not repeat mistakes. */ +import { filterChunks } from "./relevance"; + const GATEWAY = process.env.GATEWAY_URL || "http://localhost:3700"; const LAKEHOUSE = process.env.LAKEHOUSE_URL || "http://localhost:3100"; const CYCLE_SECS = parseInt(process.env.OBSERVER_CYCLE || "30"); @@ -37,7 +39,7 @@ interface ObservedOp { // Phase 24 — optional provenance so error analyzer and playbook // builder can differentiate MCP-layer ops from scenario-sourced // events. Scenarios set source="scenario" + staffer_id + sig_hash. - source?: "mcp" | "scenario"; + source?: "mcp" | "scenario" | "langfuse" | "overseer_correction"; staffer_id?: string; sig_hash?: string; event_kind?: string; @@ -47,6 +49,12 @@ interface ObservedOp { count?: number; rescue_attempted?: boolean; rescue_succeeded?: boolean; + // Overseer-correction-specific (2026-04-23): lets the analyzer + // correlate corrections with the drift that prompted them and with + // subsequent outcomes that either validated or invalidated the advice. + task_class?: string; + correction?: string; + applied_at_turn?: number; } const recentOps: ObservedOp[] = []; @@ -135,6 +143,397 @@ async function persistOp(op: ObservedOp) { } +// ─── LLM Team escalation (code_review mode) ─── +// +// When recent failures on a single sig_hash cross a threshold the +// local qwen2.5 analysis is probably insufficient. J's 2026-04-24 +// direction: "the observer would trigger to give more context" — +// route failure clusters to LLM Team's specialized code_review mode +// (via /api/run) so richer structured signal lands in the KB for +// scrum + auditor + playbook memory to consume next pass. +// +// Non-destructive: runs in parallel to the existing qwen2.5 analysis, +// never replaces it. Writes to data/_kb/observer_escalations.jsonl +// as a dedicated audit surface. + +const LLM_TEAM = process.env.LH_LLM_TEAM_URL ?? "http://localhost:5000"; +const LLM_TEAM_ESCALATIONS = "/home/profit/lakehouse/data/_kb/observer_escalations.jsonl"; +const ESCALATION_THRESHOLD = 3; // N+ failures on same sig_hash triggers + +// ─── KB enrichment helper (2026-04-26) ──────────────────────────── +// Mirrors what scrum_master_pipeline already does on every per-file +// review: queries pathway_memory bug fingerprints + the lakehouse_arch +// matrix corpus, then asks qwen3.5:latest to synthesize a tight +// briefing. We reuse the same primitives so observer escalations carry +// the same compounding context the scrum loop builds — no new index +// surfaces, no new corpora. +// +// `task_class` is derived from the cluster (most ops use the same one); +// pathway/bug_fingerprints is permissive about a null file_path, so +// non-code clusters (scenario fills, v1.chat events) just see broader +// matches via task_class alone. +// +// Returns "" when there's no useful signal — caller treats empty as +// "no preamble" and skips the prepend. +async function buildKbPreamble(sigHash: string, cluster: ObservedOp[]): Promise { + const sample = cluster[0]; + const taskClass = sample?.event_kind + ?? (sample?.source === "scenario" ? "scenario_fill" : "observer_escalation"); + + // Step 1: pathway bug fingerprints. Best-effort; null filePath just + // widens the query at the matrix-index level. + let fingerprints: { flag: { kind: string }; pattern_key: string; example: string; occurrences: number }[] = []; + try { + const r = await fetch(`${LAKEHOUSE}/vectors/pathway/bug_fingerprints`, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify({ task_class: taskClass, file_path: null, signal_class: null, limit: 5 }), + signal: AbortSignal.timeout(5000), + }); + if (r.ok) fingerprints = (await r.json() as any).fingerprints ?? []; + } catch {} + + // Step 2: architectural matrix (lakehouse_arch_v1) — ADRs/PRD/plan + // intent. Cluster summary is the search query. + const clusterSummary = cluster.slice(-5).map(o => + `${o.endpoint ?? "?"} ${o.input_summary ?? ""} ${o.error ?? ""}` + ).join(" | "); + let matrixChunks: { doc_id?: string; chunk_text?: string; score?: number }[] = []; + try { + const r = await fetch(`${LAKEHOUSE}/vectors/search`, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify({ index_name: "lakehouse_arch_v1", query: `${taskClass} ${clusterSummary}`, top_k: 4 }), + signal: AbortSignal.timeout(5000), + }); + if (r.ok) matrixChunks = (await r.json() as any).results ?? []; + } catch {} + + // Step 3: gold-standard prior answers (lakehouse_answers_v1) — past + // scrum reviews + observer escalations. This is where the BIG-model + // results we save live; future small-model handlers retrieve them + // here as scaffolding so the cheap rung gets near-paid quality. + let answerChunks: { doc_id?: string; chunk_text?: string; score?: number }[] = []; + try { + const r = await fetch(`${LAKEHOUSE}/vectors/search`, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify({ index_name: "lakehouse_answers_v1", query: `${taskClass} ${clusterSummary}`, top_k: 3 }), + signal: AbortSignal.timeout(5000), + }); + if (r.ok) answerChunks = (await r.json() as any).results ?? []; + } catch {} + + if (fingerprints.length === 0 && matrixChunks.length === 0 && answerChunks.length === 0) return ""; + + // Step 3: synthesis via local model (qwen3.5:latest, provider=ollama). + // Compresses the raw bundle to a 1-2 sentence briefing the cloud + // reviewer can actually use. If local model is down/slow, fall back + // to the raw dump rather than blocking the escalation path. + const rawBundle = [ + fingerprints.length > 0 + ? "PRIOR BUG PATTERNS (pathway memory):\n" + fingerprints.map((fp, i) => + `${i + 1}. [${fp.flag.kind}] ${fp.pattern_key} (×${fp.occurrences}) e.g. ${fp.example.slice(0, 120)}` + ).join("\n") + : "", + matrixChunks.length > 0 + ? "RELATED ARCHITECTURE CONTEXT:\n" + matrixChunks.map((c, i) => + `${i + 1}. [${c.doc_id ?? "?"}] ${(c.chunk_text ?? "").slice(0, 200)}` + ).join("\n") + : "", + answerChunks.length > 0 + ? "PRIOR GOLD-STANDARD ANSWERS (similar past reviews + escalations):\n" + answerChunks.map((c, i) => + `${i + 1}. [${c.doc_id ?? "?"}] ${(c.chunk_text ?? "").slice(0, 240)}` + ).join("\n") + : "", + ].filter(Boolean).join("\n\n"); + + const synthPrompt = `A failure cluster (sig_hash=${sigHash.slice(0, 8)}, ${cluster.length} occurrences, task_class=${taskClass}) is about to be escalated for diagnosis. Here are prior signals from our knowledge base: + +${rawBundle} + +Output a single paragraph (≤300 chars) briefing the cloud reviewer on which prior signals are most likely relevant to this cluster. If nothing matches, say so plainly. No preamble, no markdown.`; + + let synthesized = ""; + try { + const r = await fetch(`${LAKEHOUSE}/v1/chat`, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify({ + provider: "ollama", + model: "qwen3.5:latest", + messages: [{ role: "user", content: synthPrompt }], + max_tokens: 200, + temperature: 0.1, + think: false, + }), + signal: AbortSignal.timeout(15000), + }); + if (r.ok) { + const j = await r.json() as any; + synthesized = (j?.choices?.[0]?.message?.content ?? "").trim(); + } + } catch {} + + const body = synthesized.length > 0 ? synthesized : rawBundle; + return `═══ KB CONTEXT — prior signals on this task class (synthesized by qwen3.5:latest) ═══\n${body}\n═══\n\n`; +} + +async function escalateFailureClusterToLLMTeam(sigHash: string, cluster: ObservedOp[]) { + // Package the failure cluster as a single context blob. Originally + // I routed this to LLM Team's `code_review` mode at /api/run, but + // that mode isn't registered in llm_team_ui.py — it returned + // "Unknown mode" on every call. Revised 2026-04-24: route directly + // to the gateway's /v1/chat with provider=ollama_cloud + qwen3-coder:480b + // (the coding specialist that's rung 2 of the scrum ladder, proven + // to produce substantive structured reviews). Fire-and-forget so + // downstream failures don't block observer's normal loop. + const context = cluster.slice(-8).map((o, i) => + `[${i + 1}] endpoint=${o.endpoint} input=${o.input_summary} error=${o.error ?? "?"}` + ).join("\n"); + const kbPreamble = await buildKbPreamble(sigHash, cluster); + const prompt = `${kbPreamble}sig_hash=${sigHash} · ${cluster.length} failures on the same signature:\n\n${context}\n\nReview this failure cluster. Identify:\n1. Likely root cause (single sentence).\n2. Files most likely responsible (path hints).\n3. Concrete fix direction (under 3 sentences).\n4. Confidence: NN%\n\nBe specific, not generic.`; + + try { + // 2026-04-26: switched from ollama_cloud/qwen3-coder:480b (weekly + // 429 quota was blocking escalations) to paid OpenRouter + // deepseek-v3.1-terminus — 671B reasoning specialist, $0.21 in / + // $0.79 out per M tokens (under the $0.85/M ceiling J set), 164K + // ctx. Per-escalation cost: ~$0.0006 (typical 500-token prompt + + // 300-token completion). + const resp = await fetch(`${LAKEHOUSE}/v1/chat`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + provider: "openrouter", + model: "deepseek/deepseek-v3.1-terminus", + messages: [{ role: "user", content: prompt }], + max_tokens: 800, + temperature: 0.2, + }), + signal: AbortSignal.timeout(60000), + }); + if (!resp.ok) { + console.error(`[observer] escalation /v1/chat ${resp.status}: ${(await resp.text()).slice(0, 200)}`); + return; + } + const j: any = await resp.json(); + const analysis = j?.choices?.[0]?.message?.content ?? ""; + + // Audit row stays schema-compatible with the prior implementation — + // downstream consumers see structured fields regardless of the + // review-source change. Facts/entities stay empty (this call is + // direct-model, not extract-mode); the raw analysis carries the + // signal. + const row = { + ts: new Date().toISOString(), + source: "observer_escalation", + mode: "direct_chat_deepseek_v3_1_terminus", + sig_hash: sigHash, + cluster_size: cluster.length, + cluster_staffer: cluster[0]?.staffer_id, + cluster_endpoint: cluster[0]?.endpoint, + prompt_tokens: j?.usage?.prompt_tokens ?? 0, + completion_tokens: j?.usage?.completion_tokens ?? 0, + kb_preamble_chars: kbPreamble.length, + analysis: analysis.slice(0, 4000), + }; + const { appendFile } = await import("node:fs/promises"); + await appendFile(LLM_TEAM_ESCALATIONS, JSON.stringify(row) + "\n"); + console.error( + `[observer] escalated sig_hash=${sigHash.slice(0, 8)} · cluster=${cluster.length} · ${analysis.length} chars` + ); + } catch (e) { + console.error(`[observer] escalation failed: ${(e as Error).message}`); + } +} + +// Track which sig_hashes we've already escalated this session so we +// don't hammer LLM Team on every analyzeErrors tick when a cluster +// persists across cycles. +const escalatedSigHashes = new Set(); + +// ─── Hand-review for scrum/agent candidate responses (2026-04-25) ─── +// +// Observer is OUTSIDE the scrum loop's epistemic scope, so its verdict +// can be treated as truth about whether a candidate review is grounded. +// Two-tier evaluator: +// 1. Try cloud LLM (qwen3-coder:480b) — semantic judgment with +// response + source excerpt + grounding stats as context. +// 2. On cloud failure (throttle/timeout) → deterministic heuristic +// over grounding_pct + total_quotes. Marked source: "heuristic" +// so consumers can tell which rung produced the verdict. +// Every verdict is persisted to data/_kb/observer_reviews.jsonl. + +const OBSERVER_REVIEWS = "/home/profit/lakehouse/data/_kb/observer_reviews.jsonl"; + +interface HandReviewInput { + file_path: string; + model: string; + response: string; + source_content: string; + grounding_stats: { total: number; grounded: number; groundedPct: number | null }; + attempt: number; +} + +interface HandReviewVerdict { + verdict: "accept" | "reject" | "cycle"; + confidence: number; + notes: string; + source: "cloud" | "heuristic"; +} + +async function handReview(input: HandReviewInput): Promise { + const t0 = Date.now(); + let verdict: HandReviewVerdict; + + try { + verdict = await cloudHandReview(input); + } catch (e) { + console.error(`[observer/review] cloud failed (${(e as Error).message}); using heuristic`); + verdict = heuristicHandReview(input); + } + + // Persist regardless of source so we can later compare cloud vs + // heuristic verdicts on the same input and tune the heuristic. + const row = { + ts: new Date().toISOString(), + file_path: input.file_path, + model: input.model, + attempt: input.attempt, + response_chars: input.response.length, + grounding_stats: input.grounding_stats, + verdict: verdict.verdict, + confidence: verdict.confidence, + notes: verdict.notes, + source: verdict.source, + duration_ms: Date.now() - t0, + }; + try { + const { appendFile } = await import("node:fs/promises"); + await appendFile(OBSERVER_REVIEWS, JSON.stringify(row) + "\n"); + } catch { /* best-effort persistence */ } + + return verdict; +} + +async function cloudHandReview(input: HandReviewInput): Promise { + const grounded = input.grounding_stats.grounded; + const total = input.grounding_stats.total; + const pct = input.grounding_stats.groundedPct; + // Truncate to keep the prompt under typical context windows. + // 2000 + 4000 = ~6000 chars ≈ 1500 tokens, plus response context. + const responseExcerpt = input.response.slice(0, 2000); + const sourceExcerpt = input.source_content.slice(0, 4000); + + const prompt = `You are a code-review quality observer. Decide whether the following automated review is grounded in the actual source — not invented, not hallucinated. + +FILE: ${input.file_path} +MODEL: ${input.model} +ATTEMPT: ${input.attempt} +ANCHOR GROUNDING: ${grounded}/${total} backtick-quoted snippets matched the source verbatim${pct !== null ? ` (${pct}%)` : ""} + +REVIEW (first 2000 chars): +\`\`\` +${responseExcerpt} +\`\`\` + +SOURCE EXCERPT (first 4000 chars): +\`\`\` +${sourceExcerpt} +\`\`\` + +Respond ONLY with a JSON object: +{ + "verdict": "accept" | "reject" | "cycle", + "confidence": 0-100, + "notes": "<1-2 sentences on what makes this grounded or hallucinated>" +} + +- accept: review references real symbols/lines in source; findings could be acted on. +- reject: review invents APIs, fabricates calls, contradicts source. Do NOT record. +- cycle: review is mediocre — partially grounded but wrong shape, try a stronger model.`; + + // Hand-review uses paid OpenRouter so it sidesteps the Ollama Cloud + // throttle that drove every prior iter into the heuristic fallback. + // Grok 4.1 fast: $0.20 in / $0.50 out per M tokens, 2M ctx. A typical + // hand-review (~6K input + 300 output) costs ~$0.0014. Selected via + // J directive 2026-04-25 ("best model under $0.72/M"). + const resp = await fetch(`${LAKEHOUSE}/v1/chat`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + provider: "openrouter", + model: "x-ai/grok-4.1-fast", + messages: [{ role: "user", content: prompt }], + max_tokens: 300, + temperature: 0.0, + }), + signal: AbortSignal.timeout(45000), + }); + if (!resp.ok) { + throw new Error(`/v1/chat ${resp.status}: ${(await resp.text()).slice(0, 200)}`); + } + const j: any = await resp.json(); + const content = (j?.choices?.[0]?.message?.content ?? "").trim(); + // Pull JSON object from the response — model may wrap it in prose. + const m = content.match(/\{[\s\S]*\}/); + if (!m) throw new Error(`no JSON object in response: ${content.slice(0, 100)}`); + const parsed = JSON.parse(m[0]); + const v = String(parsed.verdict ?? "accept").toLowerCase(); + return { + verdict: (v === "reject" || v === "cycle") ? v as "reject" | "cycle" : "accept", + confidence: Number(parsed.confidence ?? 50), + notes: String(parsed.notes ?? "").slice(0, 500), + source: "cloud", + }; +} + +function heuristicHandReview(input: HandReviewInput): HandReviewVerdict { + // Deterministic fallback when cloud is throttled. Conservative: + // only flip to reject when the evidence is overwhelming, otherwise + // accept (fall-open principle — observer is policy, not blocker). + const total = input.grounding_stats.total; + const pct = input.grounding_stats.groundedPct; + const respLen = input.response.length; + + // Too short to be a real review + if (respLen < 1500) { + return { verdict: "reject", confidence: 80, notes: `response too short (${respLen} chars)`, source: "heuristic" }; + } + // Below 5 quotes — not enough signal to judge grounding; accept + if (total < 5 || pct === null) { + return { verdict: "accept", confidence: 50, notes: `insufficient quote signal (${total} quotes); accepting`, source: "heuristic" }; + } + // Very heavy hallucination + if (pct < 20) { + return { verdict: "reject", confidence: 85, notes: `low grounding (${pct}% of ${total} quotes)`, source: "heuristic" }; + } + // Mediocre — cycle to a stronger model + if (pct < 50) { + return { verdict: "cycle", confidence: 65, notes: `mediocre grounding (${pct}% of ${total} quotes); try stronger`, source: "heuristic" }; + } + // Good enough + return { verdict: "accept", confidence: 75, notes: `grounding ${pct}% of ${total} quotes`, source: "heuristic" }; +} + +async function maybeEscalate(failures: ObservedOp[]) { + // Group failures by sig_hash + const bySig = new Map(); + for (const f of failures) { + const k = f.sig_hash ?? "__no_sig__"; + (bySig.get(k) ?? bySig.set(k, []).get(k)!).push(f); + } + for (const [sigHash, cluster] of bySig) { + if (sigHash === "__no_sig__") continue; + if (cluster.length < ESCALATION_THRESHOLD) continue; + if (escalatedSigHashes.has(sigHash)) continue; + escalatedSigHashes.add(sigHash); + // Fire-and-forget — don't block the existing analyzer loop. + escalateFailureClusterToLLMTeam(sigHash, cluster).catch(() => {}); + } +} + // ─── Error analyzer loop ─── async function analyzeErrors() { @@ -142,17 +541,28 @@ async function analyzeErrors() { const failures = recentOps.filter(op => !op.success); if (failures.length === 0) return; + // NEW 2026-04-24: escalate recurring sig_hash clusters to LLM Team + // code_review mode. Runs in parallel to the local qwen2.5 analysis + // below — non-blocking, richer downstream signal for scrum/auditor. + maybeEscalate(failures).catch(() => {}); + const errorSummary = failures.slice(-10).map(f => `[${f.endpoint}] ${f.input_summary}: ${f.error}` ).join("\n"); - // Ask local model to diagnose + // Ask local model to diagnose. Phase 44 migration (2026-04-27): + // /v1/chat instead of legacy /ai/generate so /v1/usage tracks the + // call + Langfuse traces it. Same upstream model (qwen2.5 local). try { - const resp = await fetch(`${LAKEHOUSE}/ai/generate`, { + const resp = await fetch(`${LAKEHOUSE}/v1/chat`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ - prompt: `You are a system reliability observer. Analyze these recent failures and suggest fixes: + model: "qwen2.5", + provider: "ollama", + messages: [{ + role: "user", + content: `You are a system reliability observer. Analyze these recent failures and suggest fixes: ${errorSummary} @@ -162,14 +572,15 @@ For each error: 3. Should this be added to the playbook as a "don't do this"? Be specific and actionable. Under 200 words.`, - model: "qwen2.5", + }], max_tokens: 400, temperature: 0.2, }), }); - const analysis = await resp.json(); - if (analysis.text) { - console.error(`[observer] Error analysis:\n${analysis.text}`); + const analysis = await resp.json() as any; + const analysisText = analysis?.choices?.[0]?.message?.content ?? ""; + if (analysisText) { + console.error(`[observer] Error analysis:\n${analysisText}`); // Log the analysis as a playbook entry await fetch(`${GATEWAY}/log`, { method: "POST", @@ -177,7 +588,7 @@ Be specific and actionable. Under 200 words.`, body: JSON.stringify({ operation: `error_analysis: ${failures.length} failures`, approach: "LLM-analyzed error patterns", - result: analysis.text.slice(0, 500), + result: analysisText.slice(0, 500), context: errorSummary.slice(0, 500), }), }); @@ -251,6 +662,28 @@ function startHttpListener() { .map(o => ({ ts: o.timestamp, ok: o.success, staffer: o.staffer_id, kind: o.event_kind, role: o.role })), })); } + // ─── Hand-review endpoint (2026-04-25) ─── + // scrum/agent posts a candidate response + source content + grounding + // stats. Observer evaluates via cloud LLM (qwen3-coder:480b) with + // semantic context and returns {verdict, confidence, notes}. On + // cloud throttle, falls back to a deterministic heuristic over the + // grounding stats so the loop keeps moving with honest signal. + // + // This is the policy layer scrum was missing — pre-2026-04-25 the + // scrum_master applied a hardcoded grounding-rate threshold inline, + // which baked judgment into the wrong layer. Now scrum reports data + // (response + source + stats) and observer decides accept/reject/cycle. + if (req.method === "POST" && url.pathname === "/review") { + return req.json().then((body: any) => handReview(body)) + .then((verdict) => new Response(JSON.stringify(verdict), { + headers: { "content-type": "application/json" }, + })) + .catch((e: Error) => + new Response(JSON.stringify({ verdict: "accept", notes: `observer error: ${e.message}`, source: "heuristic" }), { + status: 200, // fall-open shape — scrum keeps moving on observer failure + headers: { "content-type": "application/json" }, + })); + } if (req.method === "POST" && url.pathname === "/event") { return req.json().then((body: any) => { const op: ObservedOp = { @@ -261,7 +694,10 @@ function startHttpListener() { duration_ms: Number(body.duration_ms ?? 0), output_summary: body.output_summary ?? (body.success ? "filled" : (body.error ?? "failed")), error: body.error, - source: "scenario", + // Respect the client's provenance if set (langfuse bridge + // sends source:"langfuse", etc.). Default to "scenario" + // to keep legacy Phase 24 callers working. + source: body.source ?? "scenario", staffer_id: body.staffer_id, sig_hash: body.sig_hash, event_kind: body.event_kind, @@ -278,19 +714,89 @@ function startHttpListener() { }).catch((e: Error) => new Response(JSON.stringify({ error: e.message }), { status: 400 })); } + // ─── Relevance filter (2026-04-25) ─── + // Drops "adjacency pollution" from matrix-retrieved chunks before + // they reach the reviewer LLM. Caller (scrum/agent) posts the + // focus file + candidate chunks; observer scores via heuristic + // (path/symbol/token signals) and returns kept + dropped lists. + // Pure function — no I/O, safe to call hot. + if (req.method === "POST" && url.pathname === "/relevance") { + return req.json().then((body: any) => { + const focus = body.focus_file ?? body.focus ?? {}; + const chunks = body.chunks ?? []; + const threshold = typeof body.threshold === "number" ? body.threshold : 0.3; + const result = filterChunks(focus, chunks, threshold); + return new Response(JSON.stringify(result), { + headers: { "content-type": "application/json" }, + }); + }).catch((e: Error) => + new Response(JSON.stringify({ error: e.message }), { status: 400 })); + } return new Response("not found", { status: 404 }); }, }); console.error(`[observer] HTTP listener bound to 0.0.0.0:${OBSERVER_PORT}`); } +// ─── Overseer corrections tailer (2026-04-23) ─── + +// The gateway's /v1/respond loop writes T3 overseer corrections to +// data/_kb/overseer_corrections.jsonl. Tail it once per cycle and +// inject each new row into the same recentOps ring that analyzeErrors +// + consolidatePlaybooks read — so a correction that just fired shows +// up alongside the outcomes it was meant to repair, and the analyzer +// can flag patterns like "three corrections on staffing.fill with the +// same advice — underlying problem isn't a drift, it's a data gap". +const CORRECTIONS_PATH = process.env.OVERSEER_CORRECTIONS_PATH + ?? "/home/profit/lakehouse/data/_kb/overseer_corrections.jsonl"; +let correctionsCursor = 0; // byte offset + +async function tailOverseerCorrections(): Promise { + const f = Bun.file(CORRECTIONS_PATH); + if (!(await f.exists())) return 0; + const size = f.size; + if (size <= correctionsCursor) return 0; + + // Read only the suffix since the last cursor; keeps tail work + // bounded even as the file grows. + const text = await f.slice(correctionsCursor, size).text(); + correctionsCursor = size; + + let forwarded = 0; + for (const line of text.split("\n")) { + if (!line.trim()) continue; + let row: any; + try { row = JSON.parse(line); } catch { continue; } + const op: ObservedOp = { + timestamp: row.created_at ?? new Date().toISOString(), + endpoint: `overseer:${row.model ?? "gpt-oss:120b"}`, + input_summary: `${row.task_class ?? "?"}: ${row.reason ?? "escalation"}`, + // Correction itself is neither success nor failure — it's a + // mitigation attempt. We mark success=true so analyzeErrors + // doesn't count it as a failure, but the preview lets the + // analyzer see what was tried. + success: true, + duration_ms: Number(row.usage?.latency_ms ?? 0), + output_summary: String(row.correction ?? "").slice(0, 200), + source: "overseer_correction", + sig_hash: row.sig_hash, + task_class: row.task_class, + correction: String(row.correction ?? ""), + applied_at_turn: Number(row.applied_at_turn ?? 0), + }; + recordExternalOp(op); + forwarded++; + } + return forwarded; +} + // ─── Main loop ─── async function main() { console.error(`[observer] started — cycle=${CYCLE_SECS}s, gateway=${GATEWAY}, port=${OBSERVER_PORT}`); // Run a health check first - const health = await fetch(`${GATEWAY}/health`).then(r => r.json()).catch(() => null); + const health = await fetch(`${GATEWAY}/health`).then(r => r.ok ? r.text() : null).catch(() => null); if (!health) { console.error("[observer] gateway unreachable — exiting"); process.exit(1); @@ -306,7 +812,14 @@ async function main() { await Bun.sleep(CYCLE_SECS * 1000); cycle++; - // Every cycle: analyze errors if any + // Every cycle: tail the overseer corrections KB stream, then + // analyze errors. Order matters — if an overseer correction just + // landed for a sig_hash that previously failed, the analyzer + // should see both. + const newCorrections = await tailOverseerCorrections(); + if (newCorrections > 0) { + console.error(`[observer] pulled ${newCorrections} new overseer correction(s) into ring`); + } await analyzeErrors(); // Every 5 cycles: consolidate playbooks @@ -315,12 +828,16 @@ async function main() { } const scenarioOps = recentOps.filter(o => o.source === "scenario").length; + const langfuseOps = recentOps.filter(o => o.source === "langfuse").length; + const correctionOps = recentOps.filter(o => o.source === "overseer_correction").length; const stats = { cycle, total_ops: recentOps.length, successes: recentOps.filter(o => o.success).length, failures: recentOps.filter(o => !o.success).length, scenario_ops: scenarioOps, + langfuse_ops: langfuseOps, + overseer_corrections: correctionOps, }; console.error(`[observer] cycle ${cycle}: ${JSON.stringify(stats)}`); } diff --git a/mcp-server/relevance.test.ts b/mcp-server/relevance.test.ts new file mode 100644 index 0000000..93b91fa --- /dev/null +++ b/mcp-server/relevance.test.ts @@ -0,0 +1,129 @@ +import { test, expect } from "bun:test"; +import { + scoreRelevance, + filterChunks, + extractDefinedSymbols, + extractImportedSymbols, + jaccard, + tokenize, +} from "./relevance"; + +const RUST_FOCUS = ` +use queryd::context::build_context; +use catalogd::Registry; +use shared::types::{Tombstone, ModelProfile}; + +pub struct GatewayState { + catalog: Registry, +} + +pub async fn handle_query(state: &GatewayState, sql: &str) -> Result { + let ctx = build_context(&state.catalog).await?; + ctx.sql(sql).await.map(QueryResponse::from) +} + +pub fn shutdown(state: GatewayState) { + drop(state); +} +`; + +test("extractDefinedSymbols pulls pub fn / struct names", () => { + const syms = extractDefinedSymbols(RUST_FOCUS); + expect(syms).toContain("handle_query"); + expect(syms).toContain("shutdown"); + expect(syms).toContain("GatewayState"); +}); + +test("extractImportedSymbols pulls names from use statements", () => { + const syms = extractImportedSymbols(RUST_FOCUS); + expect(syms).toContain("build_context"); + expect(syms).toContain("Registry"); + expect(syms).toContain("Tombstone"); + expect(syms).toContain("ModelProfile"); + // Should not include keywords + expect(syms).not.toContain("use"); + expect(syms).not.toContain("crate"); +}); + +test("path_match dominates when chunk encodes focus path", () => { + const focus = { path: "crates/gateway/src/main.rs", content: RUST_FOCUS }; + const chunk = { + source: "distilled_factual_v20260423095819", + doc_id: "crates/gateway/src/main.rs:42", + text: "Some chunk content unrelated to anything", + score: 0.5, + }; + const { score, reasons } = scoreRelevance(focus, chunk); + expect(score).toBeGreaterThanOrEqual(1.0); + expect(reasons).toContain("path_match"); +}); + +test("import_only adjacency pollution gets penalized", () => { + // Chunk talks about queryd::context::build_context (imported by focus) + // but never mentions any focus-defined symbol — classic pollution. + const focus = { path: "crates/gateway/src/main.rs", content: RUST_FOCUS }; + const chunk = { + source: "distilled_procedural_v20260423102847", + doc_id: "proc_8421", + text: "When build_context fails the Registry must be invalidated. The Tombstone fields drive the merge-on-read filter — caller should not retry on stale fingerprints.", + score: 0.65, + }; + const { score, reasons } = scoreRelevance(focus, chunk); + expect(reasons.some(r => r.startsWith("import_only("))).toBe(true); + expect(score).toBeLessThan(0.3); // below default threshold → dropped +}); + +test("defined_match keeps a chunk that's actually about the focus", () => { + const focus = { path: "crates/gateway/src/main.rs", content: RUST_FOCUS }; + const chunk = { + source: "distilled_factual_v20260423095819", + doc_id: "fact_12", + text: "handle_query in GatewayState must return QueryResponse, not anyhow::Error. The shutdown path drops state synchronously.", + score: 0.4, + }; + const { score, reasons } = scoreRelevance(focus, chunk); + expect(reasons.some(r => r.startsWith("defined_match"))).toBe(true); + expect(score).toBeGreaterThan(0.3); // above threshold → kept +}); + +test("filterChunks bucket-sorts kept vs dropped", () => { + const focus = { path: "crates/gateway/src/main.rs", content: RUST_FOCUS }; + const chunks = [ + { source: "x", doc_id: "crates/gateway/src/main.rs:1", text: "anything", score: 0.5 }, // path_match — kept + { source: "x", doc_id: "y", text: "build_context Tombstone Registry adjacent only", score: 0.7 }, // import_only — dropped + { source: "x", doc_id: "z", text: "handle_query and GatewayState are at fault here", score: 0.4 }, // defined_match — kept + { source: "x", doc_id: "w", text: "completely unrelated content about chicago permits", score: 0.6 }, // nothing — dropped + ]; + const result = filterChunks(focus, chunks); + expect(result.kept.length).toBe(2); + expect(result.dropped.length).toBe(2); + expect(result.kept.map(c => c.doc_id)).toContain("crates/gateway/src/main.rs:1"); + expect(result.kept.map(c => c.doc_id)).toContain("z"); +}); + +test("threshold override changes filter behavior", () => { + const focus = { path: "crates/queryd/src/x.rs", content: "pub fn foo() {}" }; + const weak = { source: "x", doc_id: "y", text: "foo is referenced here briefly", score: 0.2 }; + const result_strict = filterChunks(focus, [weak], 0.95); + const result_loose = filterChunks(focus, [weak], 0.1); + expect(result_strict.kept.length).toBe(0); + expect(result_loose.kept.length).toBe(1); +}); + +test("empty defined/imported gracefully scores by tokens only", () => { + const focus = { path: "doc.md", content: "This is plain prose about welders in Chicago." }; + const chunk = { source: "x", doc_id: "y", text: "Welders working in Chicago need OSHA certs.", score: 0.5 }; + const { score, reasons } = scoreRelevance(focus, chunk); + expect(score).toBeGreaterThan(0); + expect(reasons.some(r => r.startsWith("token_overlap"))).toBe(true); +}); + +test("jaccard / tokenize basic sanity", () => { + const a = tokenize("the quick brown fox jumps over the lazy dog"); + const b = tokenize("a fast brown wolf runs over a tired dog"); + expect(a.has("the")).toBe(false); // stopword + expect(a.has("brown")).toBe(true); + const j = jaccard(a, b); + expect(j).toBeGreaterThan(0); + expect(j).toBeLessThan(1); +}); diff --git a/mcp-server/relevance.ts b/mcp-server/relevance.ts new file mode 100644 index 0000000..f99d985 --- /dev/null +++ b/mcp-server/relevance.ts @@ -0,0 +1,246 @@ +/** + * Heuristic relevance filter for matrix-retrieved chunks. + * + * Drops "adjacency pollution" — chunks that scored well on cosine but + * are actually about code the focus file IMPORTS, not the focus file + * itself. Without this, the reviewer LLM hallucinates imported-crate + * internals as belonging to the focus file ("I see main.rs does X" + * when X is in queryd::context that main.rs only calls through). + * + * Pure functions here; HTTP wiring lives in observer.ts. + * + * Scoring signals (all 0..1, additive then clamped): + * path_match +1.0 chunk.source/doc_id encodes focus.path + * defined_match +0.6 chunk text mentions focus.defined_symbols + * token_overlap +0.4 jaccard of non-stopword tokens + * prefix_match +0.3 chunk source shares first-2-segment prefix + * import_penalty -0.5 mentions ONLY imported symbols, no defined ones + * + * Threshold default 0.3 — empirically tuned to keep direct hits and drop + * the obvious adjacency cases. Caller can override per-request. + */ + +const STOPWORDS = new Set([ + "the","a","an","and","or","but","if","then","else","is","are","was","were", + "be","been","being","of","in","on","at","to","for","with","by","from","as", + "that","this","these","those","it","its","they","them","their","we","our", + "you","your","i","me","my","not","no","so","do","does","did","done", + "will","would","could","should","can","may","might","must","shall", + "fn","let","mut","pub","use","mod","struct","enum","trait","impl","self", + "type","const","static","async","await","return","match","ok","err","some", + "none","into","from","ref","box","arc","rc","vec","string","str", +]); + +export interface FocusFile { + path: string; + content?: string; + defined_symbols?: string[]; + imported_symbols?: string[]; +} + +export interface CandidateChunk { + source: string; // corpus name or producer file + doc_id: string; // chunk identifier + text: string; + score: number; // upstream cosine score +} + +export interface ScoredChunk extends CandidateChunk { + relevance: number; + reasons: string[]; +} + +export interface FilterResult { + kept: ScoredChunk[]; + dropped: ScoredChunk[]; + threshold: number; + focus_path: string; + total_in: number; +} + +export function tokenize(text: string): Set { + const out = new Set(); + if (!text) return out; + const words = text.toLowerCase().match(/[a-z_][a-z0-9_]{2,}/g) ?? []; + for (const w of words) { + if (!STOPWORDS.has(w)) out.add(w); + } + return out; +} + +export function jaccard(a: Set, b: Set): number { + if (a.size === 0 || b.size === 0) return 0; + let inter = 0; + for (const x of a) if (b.has(x)) inter++; + const union = a.size + b.size - inter; + return union === 0 ? 0 : inter / union; +} + +function collectMatches(content: string, re: RegExp, group: number): string[] { + const out: string[] = []; + for (const m of content.matchAll(re)) { + if (m[group]) out.push(m[group]); + } + return out; +} + +/** + * Extract pub-symbol names from Rust/TS source. Conservative — we'd + * rather miss a symbol than over-match on something unrelated. + */ +export function extractDefinedSymbols(content: string): string[] { + if (!content) return []; + const out = new Set(); + const patterns: Array<[RegExp, number]> = [ + [/\bpub\s+(?:async\s+)?fn\s+([a-z_][a-z0-9_]*)/gi, 1], + [/\bpub\s+struct\s+([A-Z][A-Za-z0-9_]*)/g, 1], + [/\bpub\s+enum\s+([A-Z][A-Za-z0-9_]*)/g, 1], + [/\bpub\s+trait\s+([A-Z][A-Za-z0-9_]*)/g, 1], + [/\bpub\s+const\s+([A-Z_][A-Z0-9_]*)/g, 1], + [/\bpub\s+type\s+([A-Z][A-Za-z0-9_]*)/g, 1], + [/\bexport\s+(?:async\s+)?function\s+([a-z_][a-zA-Z0-9_]*)/g, 1], + [/\bexport\s+class\s+([A-Z][A-Za-z0-9_]*)/g, 1], + [/\bexport\s+interface\s+([A-Z][A-Za-z0-9_]*)/g, 1], + [/\bexport\s+(?:const|let|var)\s+([a-zA-Z_][a-zA-Z0-9_]*)/g, 1], + ]; + for (const [re, g] of patterns) { + for (const sym of collectMatches(content, re, g)) out.add(sym); + } + return [...out]; +} + +/** + * Extract imported symbol names from Rust/TS source. Used as the + * negative signal — chunks about THESE belong to other files. + */ +export function extractImportedSymbols(content: string): string[] { + if (!content) return []; + const out = new Set(); + const ignore = new Set(["use","as","crate","super","self","mod"]); + // Rust: use foo::bar::Baz, use foo::{Bar, Baz}, use foo::bar as alias. + // Character class must include uppercase or paths like + // `use catalogd::Registry;` get skipped because the regex backs off + // when it can't extend the captured block past the uppercase letter. + const useRe = /\buse\s+([A-Za-z_][A-Za-z0-9_:{}, \n]*?);/g; + for (const block of collectMatches(content, useRe, 1)) { + for (const ident of block.matchAll(/[A-Za-z_][A-Za-z0-9_]*/g)) { + const tok = ident[0]; + if (tok.length > 2 && !ignore.has(tok)) out.add(tok); + } + } + // TS: import { X, Y } from "foo"; import X from "foo"; + const tsRe = /\bimport\s+(?:\{([^}]+)\}|([A-Za-z_][A-Za-z0-9_]*))\s+from/g; + for (const m of content.matchAll(tsRe)) { + const block = m[1] || m[2] || ""; + for (const ident of block.matchAll(/[A-Za-z_][A-Za-z0-9_]*/g)) { + const tok = ident[0]; + if (tok.length > 2 && tok !== "as") out.add(tok); + } + } + return [...out]; +} + +/** + * First-2-segment prefix used to compare paths cheaply. Mirrors the + * pathway_memory file_prefix() so the same "same crate" notion applies. + */ +export function filePrefix(path: string): string { + return path.split("/").slice(0, 2).join("/"); +} + +export function scoreRelevance( + focus: FocusFile, + chunk: CandidateChunk, +): { score: number; reasons: string[] } { + const reasons: string[] = []; + let score = 0; + + const focusPath = focus.path ?? ""; + const focusBase = focusPath.split("/").pop() ?? ""; + const chunkText = chunk.text ?? ""; + const chunkSource = chunk.source ?? ""; + const chunkDocId = chunk.doc_id ?? ""; + + // path_match: chunk's provenance encodes the focus path or filename. + if (focusPath && (chunkSource.includes(focusPath) || chunkDocId.includes(focusPath) || chunkText.includes(focusPath))) { + score += 1.0; + reasons.push("path_match"); + } else if (focusBase && focusBase.length > 4 && (chunkText.includes(focusBase) || chunkDocId.includes(focusBase))) { + score += 0.6; + reasons.push("filename_match"); + } + + // defined_match: chunk text mentions symbols this file actually defines + const defined = focus.defined_symbols ?? (focus.content ? extractDefinedSymbols(focus.content) : []); + if (defined.length > 0) { + let hits = 0; + for (const s of defined) { + if (s.length > 2 && chunkText.includes(s)) hits++; + } + if (hits > 0) { + const ratio = Math.min(1, hits / Math.max(1, defined.length)); + const contrib = 0.6 * ratio; + score += contrib; + reasons.push(`defined_match(${hits}/${defined.length})`); + } + } + + // token_overlap: jaccard of non-stopword tokens + if (focus.content) { + const overlap = jaccard(tokenize(focus.content), tokenize(chunkText)); + if (overlap > 0.05) { + const contrib = 0.4 * overlap; + score += contrib; + reasons.push(`token_overlap(${overlap.toFixed(2)})`); + } + } + + // prefix_match: same first-2-segments (e.g. crates/queryd) + if (focusPath) { + const fp = filePrefix(focusPath); + if (fp && (chunkSource.includes(fp) || chunkDocId.includes(fp) || chunkText.includes(fp))) { + score += 0.3; + reasons.push("prefix_match"); + } + } + + // import_penalty: chunk mentions only symbols this file imports, never + // any it defines. Strong signal of adjacency pollution. + const imported = focus.imported_symbols ?? (focus.content ? extractImportedSymbols(focus.content) : []); + if (imported.length > 0 && defined.length > 0) { + let importHits = 0; + let definedHits = 0; + for (const s of imported) { + if (s.length > 2 && chunkText.includes(s)) importHits++; + } + for (const s of defined) { + if (s.length > 2 && chunkText.includes(s)) definedHits++; + } + if (importHits > 0 && definedHits === 0) { + score -= 0.5; + reasons.push(`import_only(${importHits})`); + } + } + + return { score, reasons }; +} + +export function filterChunks( + focus: FocusFile, + chunks: CandidateChunk[], + threshold = 0.3, +): FilterResult { + const scored: ScoredChunk[] = chunks.map((c) => { + const { score, reasons } = scoreRelevance(focus, c); + return { ...c, relevance: score, reasons }; + }); + const kept = scored.filter((c) => c.relevance >= threshold); + const dropped = scored.filter((c) => c.relevance < threshold); + return { + kept, + dropped, + threshold, + focus_path: focus.path, + total_in: chunks.length, + }; +} diff --git a/mcp-server/search.html b/mcp-server/search.html index aeff7dd..7a15c1c 100644 --- a/mcp-server/search.html +++ b/mcp-server/search.html @@ -6,6 +6,7 @@
@@ -114,8 +212,49 @@ body{font-family:'Inter',-apple-system,system-ui,'Segoe UI',sans-serif;backgroun
+ + + + + + + + + +
+ + ⓪ Not a CRM — an index that learns from you + loading growth numbers… + ▾ click to collapse + +

+ If you've worked on a legacy staffing CRM, your mental model is field inventory — + every concept must be a visible column, dropdown, or checkbox, or it doesn't exist. This + system works the opposite way: concepts don't need to be pre-declared because the + hybrid index + playbook memory learns them when you work a contract. + The rows below translate the familiar legacy surface into what actually happens here, + with real numbers for every claim. +

+
+
+
Analyzing contracts and workers...
+ +
+
+ ① Live Market — Chicago right now + Public permit data pulled live · clock aligned to current shift · refreshed every page load +
+

+ The clock shows where we sit in the 24-hour cycle. Colored arcs mark the 4 standard + staffing shifts; the red needle is now. The panel beside it summarizes what Chicago's + public permit system is asking for right now — staffing demand before anyone's acted + on it. This is the real world the rest of the page is reacting to. +

+
Loading live market…
+
+
Staffing Forecast — Next 30 Days @@ -124,11 +263,20 @@ body{font-family:'Inter',-apple-system,system-ui,'Segoe UI',sans-serif;backgroun
Loading forecast...
+
- Live Contracts — Chicago Permits → Proposed Fills + ② Staffer's Console — what's on your plate Real public permit data + worker bench + past playbook patterns
+

+ This is what a recruiter or coordinator sees when they open the console. Each card is + one open permit ranked against our 500K worker bench. The fill-probability bar + shows cumulative chance of filling by day; the economics panel projects + gross revenue, margin, and payout window; the over-bill pool flags workers + whose pay exceeds the contract's bill rate — they go into a margin-watch bucket instead + of being rejected outright. +

Loading live contracts...
@@ -140,34 +288,228 @@ body{font-family:'Inter',-apple-system,system-ui,'Segoe UI',sans-serif;backgroun
+ +
+
+ ③ Worker Search — find someone specific + Natural language search +
+

+ Type a plain-English description — role, location, trait, certification. + The query hits the hybrid SQL + vector index over all 500K worker profiles + and ranks by semantic match, reliability, and availability. Try one of the + sample searches below or write your own. +

+
+ +
+ + + +
+
+
+ +
- System Activity - Learning from every interaction + ④ System Activity — how the substrate learns + Playbook memory, pathway traces, self-tuning indices
+

+ Every completed fill, every accepted playbook, every rejected candidate feeds + back into the substrate. This strip shows what the system has learned since + the last run — which patterns are compounding, which memories are fresh, + which indices are being exercised. If it's empty, the system hasn't seen + enough traffic yet to form a memory worth showing. +

-
+ +
- Worker Search - Natural language search + ⑤ Substrate Signals — architecture health + Live probes of the index, memory, and pathway layers +
+

+ These tiles measure the architecture itself, not the staffing workload. + Instant-search latency, index shape, playbook-memory depth, pathway-matrix + compounding — four probes that answer "is the substrate healthy right now?" +

+
+
Probing substrate…
-
Search all workers
- -
-
-
+ + + + + + + + + + diff --git a/ui/server.ts b/ui/server.ts new file mode 100644 index 0000000..9eb6f88 --- /dev/null +++ b/ui/server.ts @@ -0,0 +1,455 @@ +// Visual Control Plane server — v1 +// Single Bun.serve process on :3950. Serves static index.html and +// /data/* endpoints that fan out to the live services + tail jsonl KB +// files. No build step, no node_modules. Restart via systemd or +// `bun run ui/server.ts`. + +const PORT = Number(process.env.LH_UI_PORT ?? 3950); +const KB = "/home/profit/lakehouse/data/_kb"; +const REPO = "/home/profit/lakehouse"; + +const GATEWAY = "http://localhost:3100"; +const SIDECAR = "http://localhost:3200"; +const OBSERVER = "http://localhost:3800"; +const MCP = "http://localhost:3700"; +const CONTEXT7 = "http://localhost:3900"; + +// Tail helper — read last N lines of a jsonl file without loading +// the whole thing. For files up to a few MB this is fine to read fully. +async function tailJsonl(path: string, n = 50): Promise { + try { + const text = await Bun.file(path).text(); + const lines = text.trim().split("\n").filter(Boolean); + const tail = lines.slice(-n); + return tail.map(l => { + try { return JSON.parse(l); } catch { return { _raw: l, _error: "parse" }; } + }); + } catch (e) { + return []; + } +} + +async function tryFetch(url: string, timeout = 1500): Promise { + try { + const r = await fetch(url, { signal: AbortSignal.timeout(timeout) }); + if (!r.ok) return null; + // Fix 2026-04-24: some upstream services (observer Bun.serve) return + // JSON without an application/json content-type. Don't rely on header + // — try parsing the body as JSON; fall back to raw text on failure. + const body = await r.text(); + try { return JSON.parse(body); } catch { return body; } + } catch { + return null; + } +} + +// Compact the massive /vectors/indexes response into just the shape the +// UI needs: [{name, source, model, dims, chunks, bucket, backend}] +async function indexesSummary(): Promise { + const j = await tryFetch(`${GATEWAY}/vectors/indexes`); + if (!Array.isArray(j)) return { count: 0, items: [] }; + const items = j.slice(0, 12).map((i: any) => ({ + name: i.index_name, + source: i.source, + dims: i.dimensions, + chunks: i.chunk_count, + backend: i.vector_backend, + bucket: i.bucket, + })); + return { count: j.length, items }; +} + +async function servicesSnapshot() { + const [gw, sc, obs, mcp, c7, jstats, ustats] = await Promise.all([ + tryFetch(`${GATEWAY}/health`), + tryFetch(`${SIDECAR}/health`), + tryFetch(`${OBSERVER}/health`), + tryFetch(`${MCP}/health`), + tryFetch(`${CONTEXT7}/health`), + tryFetch(`${GATEWAY}/journal/stats`), + tryFetch(`${GATEWAY}/v1/usage`), + ]); + return { + ts: new Date().toISOString(), + nodes: [ + { id: "gateway", label: "Gateway :3100", status: gw ? "healthy" : "down", health: gw }, + { id: "sidecar", label: "Sidecar :3200", status: sc ? "healthy" : "down", health: sc }, + { id: "observer", label: "Observer :3800", status: obs ? "healthy" : "down", health: obs, + stats: await tryFetch(`${OBSERVER}/stats`) }, + { id: "mcp", label: "MCP :3700", status: mcp ? "healthy" : "down", health: mcp }, + { id: "context7", label: "Context7 :3900", status: c7 ? "healthy" : "down", health: c7 }, + ], + // Virtual nodes — backed by gateway subsystems rather than own ports + subsystems: [ + { id: "journal", label: "Journal", stats: jstats }, + { id: "usage", label: "Usage /v1", stats: ustats }, + { id: "vectord", label: "Vectord", stats: await indexesSummary() }, + { id: "playbook", label: "Playbook", stats: await tryFetch(`${GATEWAY}/vectors/playbook_memory/status`) }, + { id: "agent", label: "Autotune", stats: await tryFetch(`${GATEWAY}/vectors/agent/status`) }, + ], + }; +} + +// Extract phrase-level markers that indicate "this should be removed, +// simplified, or refactored" across scrum suggestions. These are the +// signals that accumulate into a refactor recommendation. +const REFACTOR_PHRASES = [ + "should be removed", "remove this", "dead code", "unused", "unnecessary", + "duplicate of", "duplicates", "redundant", + "consolidate", "merge with", "extract into", + "refactor", "rewrite", "replace with", + "orphaned", "stale", "deprecated", + "pseudocode", "placeholder", "stub", + "split this file", "too large", +]; + +// Signal-class classifier — per file, given 2+ consecutive iterations' +// reviews, tag the file's behavior: +// CONVERGING — resolved > novel, score ↑ +// LOOPING — 3+ same findings repeat, novel = 0, score flat +// ORBITING — novel findings each iter, no resolved (healthy depth) +// PLATEAU — score flat + findings flat (diminishing returns) +// MIXED — partial/unclear +// This is the foundation for iter-6+ auto-routing: each class gets a +// different sub-pipeline (specialist model, reviewer rotation, etc). +const SIGNAL_PHRASES = [ + "pseudocode", "placeholder", "stub", "unwired", "missing", "dead code", "orphaned", + "duplicate", "redundant", "refactor", "rewrite", "remove", "unused", "unnecessary", +]; + +async function signalClasses(): Promise { + const runsDir = `${REPO}/tests/real-world/runs`; + // Load every review, group by file, sort by timestamp + const perFile: Record, score: number | null, conf_avg: number | null, findings: number, ts: number}>> = {}; + try { + const dirs = await Array.fromAsync(new Bun.Glob("scrum_*").scan({ cwd: runsDir, onlyFiles: false })); + for (const d of dirs) { + const files = await Array.fromAsync(new Bun.Glob("review_*.json").scan({ cwd: `${runsDir}/${d}` })); + for (const f of files) { + try { + const p = `${runsDir}/${d}/${f}`; + const j = JSON.parse(await Bun.file(p).text()); + const key = j.file?.replace("/home/profit/lakehouse/", "") ?? "?"; + const sug = (j.suggestions ?? "").toLowerCase(); + const phrases = new Set(); + for (const ph of SIGNAL_PHRASES) if (sug.includes(ph)) phrases.add(ph); + const scoreMatch = sug.match(/(\d(?:\.\d)?)\s*\/\s*10\b/); + const score = scoreMatch ? parseFloat(scoreMatch[1]) : null; + const mconf = [...sug.matchAll(/(?:confidence[*:\s]*\s*|\|\s*)(\d{1,3})\s*%/gi)].map(m=>parseInt(m[1],10)); + const jconf = [...sug.matchAll(/"confidence"\s*:\s*(\d{1,3})(?!\d)/gi)].map(m=>parseInt(m[1],10)); + const all = [...mconf, ...jconf].filter(x => 0 <= x && x <= 100); + const conf_avg = all.length ? Math.round(all.reduce((a,b)=>a+b,0)/all.length) : null; + const ts = (await Bun.file(p).stat()).mtime.getTime(); + (perFile[key] ??= []).push({ run: d, phrases, score, conf_avg, findings: all.length, ts }); + } catch {} + } + } + } catch (e) { + return { error: String(e), classes: {} }; + } + + const classes: Record = {}; + for (const [file, runs] of Object.entries(perFile)) { + runs.sort((a, b) => a.ts - b.ts); + if (runs.length < 2) { classes[file] = { cls: "NEW", runs: runs.length }; continue; } + const last = runs[runs.length - 1]; + const prev = runs[runs.length - 2]; + const novel = [...last.phrases].filter(p => !prev.phrases.has(p)); + const resolved = [...prev.phrases].filter(p => !last.phrases.has(p)); + const looping = [...prev.phrases].filter(p => last.phrases.has(p)); + const dScore = (last.score != null && prev.score != null) ? last.score - prev.score : null; + const dConf = (last.conf_avg != null && prev.conf_avg != null) ? last.conf_avg - prev.conf_avg : null; + const dFindings = last.findings - prev.findings; + + let cls: string; + if (dScore != null && dScore > 0 && resolved.length > novel.length) cls = "CONVERGING"; + else if (looping.length >= 3 && novel.length === 0 && (dScore == null || Math.abs(dScore) < 0.5)) cls = "LOOPING"; + else if (novel.length >= 2 && resolved.length === 0) cls = "ORBITING"; + else if (Math.abs(dFindings) <= 1 && (dScore == null || Math.abs(dScore) < 0.5)) cls = "PLATEAU"; + else cls = "MIXED"; + + classes[file] = { + cls, + runs: runs.length, + iter_span: `${runs[0].run}…${last.run}`, + prev_score: prev.score, + last_score: last.score, + delta_score: dScore, + delta_conf: dConf, + delta_findings: dFindings, + novel, + resolved, + looping, + }; + } + + // Summary counts + const counts: Record = {}; + for (const v of Object.values(classes)) counts[v.cls] = (counts[v.cls] ?? 0) + 1; + + return { generated_at: new Date().toISOString(), counts, classes }; +} + +async function refactorSignals(): Promise { + // Walk every accepted review across all scrum runs. For each file, + // count how many times its suggestions mention a refactor phrase. + // Return a sorted list — files most often flagged for refactor first. + const runsDir = `${REPO}/tests/real-world/runs`; + const perFile: Record; examples: string[]; iterations: number }> = {}; + try { + const dirs = await Array.fromAsync(new Bun.Glob("scrum_*").scan({ cwd: runsDir, onlyFiles: false })); + for (const d of dirs) { + const files = await Array.fromAsync(new Bun.Glob("review_*.json").scan({ cwd: `${runsDir}/${d}` })); + for (const f of files) { + const p = `${runsDir}/${d}/${f}`; + try { + const j = JSON.parse(await Bun.file(p).text()); + const file = j.file?.replace("/home/profit/lakehouse/", "") ?? "?"; + const sug = (j.suggestions ?? "").toLowerCase(); + if (!perFile[file]) perFile[file] = { file, hits: 0, phrases: {}, examples: [], iterations: 0 }; + perFile[file].iterations++; + for (const phrase of REFACTOR_PHRASES) { + const count = (sug.match(new RegExp(phrase, "gi")) ?? []).length; + if (count > 0) { + perFile[file].hits += count; + perFile[file].phrases[phrase] = (perFile[file].phrases[phrase] ?? 0) + count; + // Pull one example sentence around the phrase + if (perFile[file].examples.length < 3) { + const idx = sug.indexOf(phrase); + if (idx >= 0) { + const s = Math.max(0, idx - 60); + const e = Math.min(sug.length, idx + phrase.length + 80); + perFile[file].examples.push("…" + sug.slice(s, e).replace(/\s+/g, " ") + "…"); + } + } + } + } + } catch {} + } + } + } catch (e) { + return { error: String(e), signals: [] }; + } + const signals = Object.values(perFile) + .filter(x => x.hits > 0) + .sort((a, b) => b.hits - a.hits) + .slice(0, 30); + return { signals, scanned: Object.keys(perFile).length }; +} + +async function reverseIndex(query: string, limit = 20): Promise { + // Grep-like substring search across every review's suggestions. + // Returns file + snippet + which iter it was in + score + verdict. + const runsDir = `${REPO}/tests/real-world/runs`; + if (!query || query.length < 2) return { query, hits: [] }; + const q = query.toLowerCase(); + const hits: any[] = []; + try { + const dirs = await Array.fromAsync(new Bun.Glob("scrum_*").scan({ cwd: runsDir, onlyFiles: false })); + for (const d of dirs) { + const files = await Array.fromAsync(new Bun.Glob("review_*.json").scan({ cwd: `${runsDir}/${d}` })); + for (const f of files) { + const p = `${runsDir}/${d}/${f}`; + try { + const j = JSON.parse(await Bun.file(p).text()); + const sug = j.suggestions ?? ""; + const lower = sug.toLowerCase(); + const idx = lower.indexOf(q); + if (idx < 0) continue; + const s = Math.max(0, idx - 80); + const e = Math.min(sug.length, idx + q.length + 200); + hits.push({ + file: j.file?.replace("/home/profit/lakehouse/", ""), + run_id: d, + model: j.escalated_to_model, + snippet: sug.slice(s, e).replace(/\s+/g, " "), + }); + if (hits.length >= limit) break; + } catch {} + } + if (hits.length >= limit) break; + } + } catch (e) { + return { query, error: String(e), hits: [] }; + } + return { query, hits }; +} + +async function fileHistory(relpath: string): Promise { + // Walk all scrum_/review_*.json files and gather every review + // for this file path. Returns timeline rows keyed by run_id. + const runsDir = `${REPO}/tests/real-world/runs`; + const out: any[] = []; + try { + const dirs = await Array.fromAsync(new Bun.Glob("scrum_*").scan({ cwd: runsDir, onlyFiles: false })); + for (const d of dirs) { + const safe = relpath.replaceAll("/", "_"); + const p = `${runsDir}/${d}/review_${safe}.json`; + if (await Bun.file(p).exists()) { + const j = JSON.parse(await Bun.file(p).text()); + const sug = j.suggestions ?? ""; + const scoreMatch = sug.match(/(?:score[\s*:]*)?(\d(?:\.\d)?)\s*\/\s*10\b/i); + const score = scoreMatch ? parseFloat(scoreMatch[1]) : null; + const confs = [...sug.matchAll(/(?:Confidence[*:\s]*\s*|\|\s*)(\d{1,3})\s*%/gi)] + .map(m => parseInt(m[1], 10)).filter(x => x >= 0 && x <= 100); + const jsonConfs = [...sug.matchAll(/"confidence"\s*:\s*(\d{1,3})(?!\d)/gi)] + .map(m => parseInt(m[1], 10)).filter(x => x >= 0 && x <= 100); + const all = [...confs, ...jsonConfs]; + const mt = await Bun.file(p).stat(); + out.push({ + run_id: d, + reviewed_at: j.reviewed_at ?? mt.mtime, + model: j.escalated_to_model, + score, + chars: sug.length, + conf_avg: all.length ? Math.round(all.reduce((a,b)=>a+b,0)/all.length) : null, + conf_min: all.length ? Math.min(...all) : null, + findings: all.length, + output_format: sug.includes('"verdict"') ? "forensic_json" : "markdown", + // first 1200 chars preview + preview: sug.slice(0, 1200), + }); + } + } + } catch (e) { + return { error: String(e), history: [] }; + } + out.sort((a, b) => String(a.reviewed_at).localeCompare(String(b.reviewed_at))); + return { file: relpath, history: out }; +} + +Bun.serve({ + port: PORT, + hostname: "0.0.0.0", + async fetch(req) { + const url = new URL(req.url); + const path = url.pathname; + + // Static shell + if (path === "/" || path === "/index.html") { + return new Response(Bun.file(`${REPO}/ui/index.html`)); + } + if (path === "/ui.css") { + return new Response(Bun.file(`${REPO}/ui/ui.css`), { headers: { "content-type": "text/css" } }); + } + if (path === "/ui.js") { + return new Response(Bun.file(`${REPO}/ui/ui.js`), { headers: { "content-type": "application/javascript" } }); + } + + // Data API + if (path === "/data/services") return Response.json(await servicesSnapshot()); + if (path === "/data/reviews") { + const n = Number(url.searchParams.get("tail") ?? 50); + return Response.json(await tailJsonl(`${KB}/scrum_reviews.jsonl`, n)); + } + if (path === "/data/findings") return Response.json(await tailJsonl(`${KB}/phase_sweep_findings.jsonl`)); + if (path === "/data/metrics") return Response.json(await tailJsonl(`${KB}/scrum_loop_metrics.jsonl`)); + if (path === "/data/trust") return Response.json(await tailJsonl(`${KB}/model_trust.jsonl`, 200)); + if (path === "/data/overrides") return Response.json(await tailJsonl(`${KB}/human_overrides.jsonl`)); + if (path === "/data/outcomes") return Response.json(await tailJsonl(`${KB}/outcomes.jsonl`, 30)); + if (path === "/data/audit_facts") return Response.json(await tailJsonl(`${KB}/audit_facts.jsonl`, 30)); + + // Pathway memory — consensus-designed sidecar (2026-04-24). Two + // exposed metrics: reuse_rate (activity — is it firing?) and + // avg_rungs_saved_per_commit (value — is it earning its keep?). + // Round-3 consensus (qwen3.5:397b) pointed out that activity + // without value tells us nothing; the UI needs both to judge the + // health of the hot-swap learning loop. + if (path === "/data/pathway_stats") { + try { + const r = await fetch("http://localhost:3100/vectors/pathway/stats", { signal: AbortSignal.timeout(3000) }); + if (!r.ok) return Response.json({ error: `vectord ${r.status}`, stats: null }); + const stats = await r.json(); + // Tail recent scrum events to compute avg_rungs_saved_per_commit + // (a committed review = any row in scrum_reviews.jsonl; rungs_saved + // only populates when pathway memory fired AND the recommended + // model actually produced the accept). + const reviews = await tailJsonl(`${KB}/scrum_reviews.jsonl`, 200); + let totalCommits = 0; + let totalRungsSaved = 0; + let hotSwapHits = 0; + for (const r of reviews) { + totalCommits++; + if (r.pathway_hot_swap_hit) hotSwapHits++; + if (typeof r.rungs_saved === "number") totalRungsSaved += r.rungs_saved; + } + return Response.json({ + stats, + scrum_window: { + reviews: totalCommits, + hot_swap_hits: hotSwapHits, + pathway_reuse_rate: totalCommits ? hotSwapHits / totalCommits : 0, + avg_rungs_saved_per_commit: totalCommits ? totalRungsSaved / totalCommits : 0, + }, + }); + } catch (e) { + return Response.json({ error: (e as Error).message, stats: null }); + } + } + + if (path.startsWith("/data/file/")) { + const relpath = decodeURIComponent(path.slice("/data/file/".length)); + return Response.json(await fileHistory(relpath)); + } + if (path === "/data/refactor_signals") { + return Response.json(await refactorSignals()); + } + if (path === "/data/signal_classes") { + return Response.json(await signalClasses()); + } + if (path === "/data/search") { + const q = url.searchParams.get("q") ?? ""; + return Response.json(await reverseIndex(q, 30)); + } + + // Per-service systemd log tail. Allowed service list is fixed so the + // :service path param can never be used to invoke arbitrary units. + if (path.startsWith("/data/logs/")) { + const svc = path.slice("/data/logs/".length).split("?")[0]; + const UNITS: Record = { + gateway: "lakehouse.service", + sidecar: "lakehouse-sidecar.service", + observer: "lakehouse-observer.service", + mcp: "lakehouse-agent.service", + context7: "lakehouse-context7-bridge.service", + auditor: "lakehouse-auditor.service", + langfuse: "lakehouse-langfuse-bridge.service", + }; + const unit = UNITS[svc]; + if (!unit) return Response.json({ error: "unknown service", allowed: Object.keys(UNITS) }, { status: 400 }); + const n = Number(url.searchParams.get("n") ?? 60); + try { + // Use execFile-style API: pass args as array, never shell-interpolate + const proc = Bun.spawn(["journalctl", "-u", unit, "-n", String(n), "--no-pager", "--output=short-iso"], { + stdout: "pipe", + stderr: "pipe", + }); + const text = await new Response(proc.stdout).text(); + await proc.exited; + const lines = text.split("\n").filter(Boolean); + return Response.json({ service: svc, unit, lines }); + } catch (e) { + return Response.json({ service: svc, unit, error: String(e), lines: [] }); + } + } + + // Live scrum log tail — best-effort + if (path === "/data/scrum_log") { + try { + const bg = await Array.fromAsync(new Bun.Glob("scrum_iter*.log").scan({ cwd: "/tmp" })); + if (bg.length === 0) return Response.json({ lines: [] }); + bg.sort(); + const latest = `/tmp/${bg[bg.length - 1]}`; + const text = await Bun.file(latest).text(); + const lines = text.split("\n").slice(-80); + return Response.json({ file: latest, lines }); + } catch (e) { + return Response.json({ error: String(e) }); + } + } + + return new Response("not found", { status: 404 }); + }, +}); + +console.log(`[ui] visual control plane listening on http://0.0.0.0:${PORT}`); diff --git a/ui/ui.css b/ui/ui.css new file mode 100644 index 0000000..6d87c55 --- /dev/null +++ b/ui/ui.css @@ -0,0 +1,440 @@ +/* Lakehouse Visual Control Plane — neo-brutalist dark */ + +:root { + --bg: #0a0c10; + --bg-1: #10141a; + --bg-2: #171c24; + --border: #2a303b; + --border-hi: #3a4252; + --fg: #e8ecf3; + --fg-dim: #8a94a7; + --fg-muted: #525c6f; + --green: #3eed86; + --yellow: #ffbf3c; + --red: #ff4d6e; + --blue: #55c5ff; + --purple: #b57cff; + --orange: #ff9f43; + --shadow: 0 2px 0 #000; + --mono: ui-monospace, "JetBrains Mono", "SF Mono", Menlo, monospace; + --sans: -apple-system, Inter, system-ui, sans-serif; +} + +* { box-sizing: border-box; margin: 0; padding: 0; } +html, body { height: 100%; overflow: hidden; } +body { + background: var(--bg); + color: var(--fg); + font-family: var(--sans); + font-size: 13px; + display: flex; + flex-direction: column; +} + +/* ────── TOP BAR ────── */ +#topbar { + height: 44px; + display: flex; + align-items: center; + gap: 16px; + padding: 0 16px; + border-bottom: 1px solid var(--border); + background: var(--bg-1); + flex-shrink: 0; +} +.brand { display: flex; align-items: center; gap: 8px; font-weight: 700; letter-spacing: 0.08em; } +.brand .sig { color: var(--green); font-size: 16px; } +.brand .build { color: var(--fg-muted); font-size: 10px; font-family: var(--mono); margin-left: 6px; } + +#views { display: flex; gap: 2px; margin-left: 20px; } +#views button { + background: transparent; border: 1px solid var(--border); color: var(--fg-dim); + font-family: var(--mono); font-size: 11px; letter-spacing: 0.1em; + padding: 5px 10px; cursor: pointer; text-transform: uppercase; +} +#views button:hover { border-color: var(--border-hi); color: var(--fg); } +#views button.on { background: var(--fg); color: var(--bg); border-color: var(--fg); font-weight: 700; } + +#hb { margin-left: auto; display: flex; gap: 6px; } +.hbchip { + font-family: var(--mono); font-size: 10px; letter-spacing: 0.05em; + padding: 4px 8px; border: 1px solid var(--border); border-radius: 2px; + color: var(--fg-muted); +} +.hbchip[data-status="healthy"] { border-color: var(--green); color: var(--green); } +.hbchip[data-status="down"] { border-color: var(--red); color: var(--red); } +.hbchip[data-status="degraded"]{ border-color: var(--yellow); color: var(--yellow); } + +/* ────── MAIN ────── */ +main { + flex: 1; + display: grid; + grid-template-columns: 1fr 380px; + min-height: 0; +} +#stage { position: relative; border-right: 1px solid var(--border); min-height: 0; overflow: hidden; } + +.view { display: none; width: 100%; height: 100%; } +.view.on { display: block; } + +.subhead { + height: 32px; display: flex; align-items: center; gap: 10px; + padding: 0 14px; border-bottom: 1px solid var(--border); + background: var(--bg-1); + font-family: var(--mono); font-size: 11px; color: var(--fg-dim); + text-transform: uppercase; letter-spacing: 0.08em; +} +.subhead .spacer { flex: 1; } + +/* ────── MAP ────── */ +#view-map { position: relative; } +#overlay-controls { + position: absolute; top: 10px; left: 10px; z-index: 2; + display: flex; align-items: center; gap: 4px; + background: rgba(16,20,26,0.95); + border: 1px solid var(--border); padding: 4px; +} +#overlay-controls .lbl { font-family: var(--mono); font-size: 10px; color: var(--fg-muted); padding: 0 8px; } +#overlay-controls button { + background: transparent; color: var(--fg-dim); border: 1px solid var(--border); + font-family: var(--mono); font-size: 10px; padding: 3px 8px; cursor: pointer; + text-transform: lowercase; letter-spacing: 0.05em; +} +#overlay-controls button:hover { border-color: var(--border-hi); color: var(--fg); } +#overlay-controls button.on { background: var(--fg); color: var(--bg); border-color: var(--fg); } + +#map { width: 100%; height: 100%; } +#map .node-circle { stroke: var(--fg); stroke-width: 2; cursor: pointer; transition: r 200ms; } +#map .node-circle:hover { stroke-width: 3; } +#map .node-label { + font-family: var(--mono); font-size: 11px; fill: var(--fg); + pointer-events: none; text-anchor: middle; font-weight: 600; +} +#map .node-sub { + font-family: var(--mono); font-size: 9px; fill: var(--fg-muted); + pointer-events: none; text-anchor: middle; +} +#map .edge { stroke: var(--border-hi); stroke-width: 1.5; fill: none; } +#map .edge.active { stroke: var(--blue); stroke-width: 2; stroke-dasharray: 4 3; animation: dash 1.5s linear infinite; } +@keyframes dash { to { stroke-dashoffset: -14; } } + +#map .node-selected { stroke: var(--yellow); stroke-width: 3; } + +#legend { + position: absolute; bottom: 10px; left: 10px; + display: flex; gap: 16px; font-family: var(--mono); font-size: 10px; + background: rgba(16,20,26,0.95); border: 1px solid var(--border); padding: 6px 10px; +} +.lg { color: var(--fg-muted); } +.lg.healthy::before { content: ''; } +.lg.healthy { color: var(--green); } +.lg.degraded { color: var(--yellow); } +.lg.down { color: var(--red); } +.lg.active { color: var(--blue); } + +/* ────── CONTEXT PANEL ────── */ +#context { + background: var(--bg-1); overflow-y: auto; overflow-x: hidden; + display: flex; flex-direction: column; +} +.ctx-header { + height: 44px; display: flex; flex-direction: column; justify-content: center; + padding: 4px 14px; border-bottom: 1px solid var(--border); + background: var(--bg-2); +} +.ctx-eyebrow { font-family: var(--mono); font-size: 10px; color: var(--fg-muted); letter-spacing: 0.1em; } +#ctx-target { font-family: var(--mono); font-size: 12px; color: var(--fg); font-weight: 600; margin-top: 2px; } +#ctx-body { padding: 12px 14px; flex: 1; overflow-y: auto; } +.ctx-hint { color: var(--fg-muted); font-style: italic; font-size: 11px; } + +.ctx-row { padding: 6px 0; border-bottom: 1px solid var(--border); display: flex; justify-content: space-between; gap: 10px; font-family: var(--mono); font-size: 11px; } +.ctx-row .k { color: var(--fg-muted); text-transform: uppercase; letter-spacing: 0.06em; } +.ctx-row .v { color: var(--fg); text-align: right; word-break: break-all; } +.ctx-row .v.good { color: var(--green); } +.ctx-row .v.warn { color: var(--yellow); } +.ctx-row .v.bad { color: var(--red); } + +.ctx-section-hd { font-family: var(--mono); font-size: 10px; color: var(--fg-muted); letter-spacing: 0.1em; margin: 14px 0 4px; text-transform: uppercase; } + +.pill { + display: inline-block; font-family: var(--mono); font-size: 10px; + padding: 2px 7px; border: 1px solid var(--border); margin-right: 4px; +} +.pill.tier-auto { border-color: var(--green); color: var(--green); } +.pill.tier-dry_run { border-color: var(--blue); color: var(--blue); } +.pill.tier-simulation { border-color: var(--yellow); color: var(--yellow); } +.pill.tier-block { border-color: var(--red); color: var(--red); } +.pill.ver-needs_patch { border-color: var(--orange); color: var(--orange); } +.pill.ver-pass { border-color: var(--green); color: var(--green); } +.pill.ver-fail { border-color: var(--red); color: var(--red); } +.pill.fmt-forensic_json { border-color: var(--purple); color: var(--purple); } +.pill.fmt-markdown { border-color: var(--fg-dim); color: var(--fg-dim); } + +/* ────── TRACE ────── */ +#trace-timeline { + display: flex; gap: 0; padding: 20px; + overflow-x: auto; border-bottom: 1px solid var(--border); + min-height: 140px; +} +.trace-node { + position: relative; flex: 0 0 140px; padding: 10px 12px; + border: 2px solid var(--border); background: var(--bg-1); cursor: pointer; + font-family: var(--mono); font-size: 10px; +} +.trace-node:hover { border-color: var(--border-hi); } +.trace-node.active { border-color: var(--yellow); background: var(--bg-2); } +.trace-node::after { + content: '→'; position: absolute; right: -14px; top: 50%; transform: translateY(-50%); + color: var(--fg-muted); font-size: 16px; +} +.trace-node:last-child::after { display: none; } +.trace-node .tn-run { color: var(--fg-muted); letter-spacing: 0.05em; margin-bottom: 4px; } +.trace-node .tn-score { font-size: 22px; font-weight: 700; color: var(--fg); } +.trace-node .tn-conf { color: var(--fg-dim); margin-top: 4px; } +.trace-node .tn-model { color: var(--purple); margin-top: 4px; font-size: 9px; } + +#trace-detail { padding: 16px; overflow-y: auto; height: calc(100% - 172px); } +#trace-detail pre { font-family: var(--mono); font-size: 11px; color: var(--fg-dim); white-space: pre-wrap; word-break: break-word; } + +/* ────── METRICS ────── */ +.metric-grid { + display: grid; grid-template-columns: repeat(auto-fill, minmax(280px, 1fr)); + gap: 12px; padding: 16px; overflow-y: auto; max-height: 100%; +} +.metric { + border: 1px solid var(--border); background: var(--bg-1); + padding: 14px; display: flex; flex-direction: column; gap: 6px; +} +.metric .m-label { font-family: var(--mono); font-size: 10px; color: var(--fg-muted); letter-spacing: 0.08em; text-transform: uppercase; } +.metric .m-big { font-size: 28px; font-weight: 800; letter-spacing: -0.02em; } +.metric .m-sub { font-family: var(--mono); font-size: 11px; color: var(--fg-dim); } +.metric .m-explain { + color: var(--fg); font-family: var(--sans); font-size: 12px; + line-height: 1.45; margin-top: 2px; font-weight: 400; +} +.metric .m-source { + color: var(--fg-muted); font-size: 10px; letter-spacing: 0.05em; + border-top: 1px dashed var(--border); padding-top: 6px; margin-top: 6px; +} +.metric .m-good { + color: var(--green); font-size: 10px; letter-spacing: 0.03em; + line-height: 1.5; opacity: 0.85; +} +.metric.warn .m-good { color: var(--yellow); } +.metric.bad .m-good { color: var(--red); } +.metric.good .m-big { color: var(--green); } +.metric.warn .m-big { color: var(--yellow); } +.metric.bad .m-big { color: var(--red); } + +.bar { display: flex; height: 8px; border: 1px solid var(--border); background: var(--bg); margin-top: 4px; } +.bar > span { display: block; height: 100%; } +.bar .seg-auto { background: var(--green); } +.bar .seg-dry_run { background: var(--blue); } +.bar .seg-simulation { background: var(--yellow); } +.bar .seg-block { background: var(--red); } + +/* ────── KB ────── */ +.kb-grid { + padding: 16px; display: grid; gap: 10px; + grid-template-columns: repeat(auto-fill, minmax(420px, 1fr)); + overflow-y: auto; max-height: 100%; +} +.kb-banner { + grid-column: 1 / -1; + border: 1px solid var(--border); background: var(--bg-1); + padding: 14px 16px; border-left: 3px solid var(--blue); +} +.kb-banner-title { + font-family: var(--mono); font-size: 11px; color: var(--blue); + letter-spacing: 0.1em; font-weight: 700; margin-bottom: 6px; +} +.kb-banner-body { + color: var(--fg); font-size: 12px; line-height: 1.55; +} +.kb-statline { + grid-column: 1 / -1; + display: flex; gap: 18px; + font-family: var(--mono); font-size: 11px; color: var(--fg-dim); + padding: 8px 14px; border: 1px solid var(--border); + background: var(--bg-2); margin-bottom: 2px; +} +.kb-statline .stat-warn { color: var(--yellow); font-weight: 700; } +.kb-file { border: 1px solid var(--border); background: var(--bg-1); padding: 10px 12px; cursor: pointer; } +.kb-file:hover { border-color: var(--border-hi); } +.kb-file .kf-path { font-family: var(--mono); font-size: 11px; color: var(--fg); word-break: break-all; } +.kb-file .kf-meta { font-family: var(--mono); font-size: 10px; color: var(--fg-muted); margin-top: 4px; display: flex; gap: 10px; flex-wrap: wrap; } +.kb-file .kf-score { font-weight: 700; color: var(--fg); } +.kb-file .kf-delta.up { color: var(--green); } +.kb-file .kf-delta.down { color: var(--red); } + +/* ────── CONSOLE ────── */ +#view-console { background: #000; display: none; flex-direction: column; } +#view-console.on { display: flex; } +.console-toolbar { + height: 36px; display: flex; align-items: center; gap: 8px; + padding: 0 12px; background: var(--bg-1); border-bottom: 1px solid var(--border); + flex-shrink: 0; +} +.console-toolbar .con-eyebrow { + font-family: var(--mono); font-size: 10px; color: var(--fg-muted); letter-spacing: 0.1em; + text-transform: uppercase; margin-right: 6px; +} +.console-toolbar .spacer { flex: 1; } +#con-tabs { display: flex; gap: 2px; } +#con-tabs button { + background: transparent; border: 1px solid var(--border); color: var(--fg-dim); + font-family: var(--mono); font-size: 10px; letter-spacing: 0.05em; + padding: 4px 10px; cursor: pointer; text-transform: lowercase; +} +#con-tabs button:hover { border-color: var(--border-hi); color: var(--fg); } +#con-tabs button.on { background: var(--fg); color: var(--bg); border-color: var(--fg); font-weight: 700; } +#con-unit { font-family: var(--mono); font-size: 10px; color: var(--fg-muted); } + +#console-log { + flex: 1; padding: 12px 16px; overflow-y: auto; + font-family: var(--mono); font-size: 11px; color: var(--fg); + line-height: 1.5; +} +#console-log .cl-line { white-space: pre-wrap; word-break: break-all; } +#console-log .cl-info { color: var(--fg-dim); } +#console-log .cl-ok { color: var(--green); } +#console-log .cl-warn { color: var(--yellow); } +#console-log .cl-err { color: var(--red); } + +/* ────── STREAM (bottom) ────── */ +#stream { + height: 180px; background: var(--bg-1); + border-top: 1px solid var(--border); + display: flex; flex-direction: column; flex-shrink: 0; +} +.stream-head { + height: 26px; display: flex; align-items: center; gap: 10px; + padding: 0 14px; border-bottom: 1px solid var(--border); + font-family: var(--mono); font-size: 10px; color: var(--fg-muted); + letter-spacing: 0.1em; text-transform: uppercase; +} +.stream-head .spacer { flex: 1; } +#stream-file { color: var(--fg-dim); font-size: 10px; } +.dot { width: 8px; height: 8px; border-radius: 50%; background: var(--green); animation: pulse 1.4s ease-in-out infinite; } +@keyframes pulse { 50% { opacity: 0.35; transform: scale(0.8); } } + +#stream-body { + flex: 1; padding: 8px 14px; overflow-y: auto; font-family: var(--mono); font-size: 11px; color: var(--fg-dim); + display: flex; flex-direction: column; +} +.sline { padding: 1px 0; white-space: pre; } +.sline.ok { color: var(--green); } +.sline.thin { color: var(--yellow); } +.sline.err { color: var(--red); } +.sline.info { color: var(--fg-dim); } +.sline.head { color: var(--fg); font-weight: 600; } + +/* ────── TRAJECTORY view ────── */ +#view-trajectory { display: none; flex-direction: column; } +#view-trajectory.on { display: flex; } +.traj-header { + border-bottom: 1px solid var(--border); background: var(--bg-1); + padding: 12px 16px; display: flex; flex-direction: column; gap: 6px; +} +#traj-search { + width: 100%; background: var(--bg-2); color: var(--fg); + border: 1px solid var(--border); padding: 8px 10px; + font-family: var(--mono); font-size: 12px; +} +#traj-search:focus { outline: none; border-color: var(--blue); } +#traj-stats { + font-family: var(--mono); font-size: 10px; color: var(--fg-muted); letter-spacing: 0.06em; +} +#traj-body { + flex: 1; overflow-y: auto; padding: 16px; + display: flex; flex-direction: column; gap: 10px; +} +.traj-section-head { + font-family: var(--mono); font-size: 11px; color: var(--blue); + letter-spacing: 0.1em; font-weight: 700; margin-top: 14px; margin-bottom: 4px; + border-bottom: 1px solid var(--border); padding-bottom: 6px; +} +.traj-section-head:first-child { margin-top: 0; } +.traj-section-explain { + color: var(--fg); font-size: 12px; line-height: 1.55; margin-bottom: 6px; + padding: 8px 10px; background: var(--bg-1); border-left: 2px solid var(--blue); +} +.traj-table { display: flex; flex-direction: column; border: 1px solid var(--border); } +.traj-row { + display: grid; grid-template-columns: 40px 1.5fr 80px 2fr 80px; gap: 12px; + padding: 8px 12px; border-bottom: 1px solid var(--border); + font-family: var(--mono); font-size: 11px; cursor: pointer; +} +.traj-row:hover { background: var(--bg-2); } +.traj-row:last-child { border-bottom: none; } +.traj-col-rank { color: var(--fg-muted); font-weight: 700; } +.traj-col-file { color: var(--fg); } +.traj-col-hits { color: var(--red); font-weight: 700; } +.traj-col-phrases { color: var(--fg-dim); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } +.traj-col-iters { color: var(--fg-muted); text-align: right; } + +.traj-spark-grid { + display: grid; grid-template-columns: repeat(auto-fill, minmax(480px, 1fr)); gap: 10px; +} +.traj-spark { + border: 1px solid var(--border); background: var(--bg-1); + padding: 12px; cursor: pointer; +} +.traj-spark:hover { border-color: var(--border-hi); } +.traj-spark-file { font-family: var(--mono); font-size: 11px; color: var(--fg); margin-bottom: 8px; } +.traj-spark-line { display: flex; align-items: center; gap: 6px; } +.traj-spark-pt { + flex: 0 0 80px; padding: 6px 8px; border: 1px solid var(--border); + background: var(--bg-2); text-align: center; +} +.traj-pt-score { font-family: var(--mono); font-size: 14px; font-weight: 800; color: var(--fg); } +.traj-pt-conf { font-family: var(--mono); font-size: 10px; color: var(--fg-dim); } +.traj-pt-label { font-family: var(--mono); font-size: 9px; color: var(--fg-muted); letter-spacing: 0.06em; } +.traj-spark-arrow { color: var(--fg-muted); font-size: 14px; } +.traj-spark-delta { font-family: var(--mono); font-size: 11px; color: var(--fg-dim); margin-top: 8px; } +.traj-spark-delta .delta-up { color: var(--green); } +.traj-spark-delta .delta-down { color: var(--red); } +.traj-spark-empty { font-family: var(--mono); font-size: 10px; color: var(--fg-muted); font-style: italic; } + +.traj-hit { + border: 1px solid var(--border); padding: 10px 12px; background: var(--bg-1); cursor: pointer; +} +.traj-hit:hover { border-color: var(--border-hi); } +.traj-hit-top { display: flex; gap: 14px; margin-bottom: 6px; } +.traj-hit-file { font-family: var(--mono); font-size: 11px; color: var(--fg); font-weight: 600; } +.traj-hit-meta { font-family: var(--mono); font-size: 10px; color: var(--fg-muted); } +.traj-hit-snip { font-family: var(--mono); font-size: 11px; color: var(--fg-dim); line-height: 1.5; } + +/* signal classes */ +.signal-class-row { display: flex; gap: 8px; margin-bottom: 12px; flex-wrap: wrap; } +.signal-chip { + font-family: var(--mono); font-size: 10px; letter-spacing: 0.08em; + padding: 4px 10px; border: 1px solid var(--border); font-weight: 700; +} +.signal-converging { color: var(--green); border-color: var(--green); } +.signal-looping { color: var(--red); border-color: var(--red); } +.signal-orbiting { color: var(--purple); border-color: var(--purple); } +.signal-plateau { color: var(--yellow); border-color: var(--yellow); } +.signal-mixed { color: var(--blue); border-color: var(--blue); } +.signal-new { color: var(--fg-muted); border-color: var(--fg-muted); } +.signal-grid { + display: grid; grid-template-columns: repeat(auto-fill, minmax(480px, 1fr)); gap: 8px; +} +.signal-card { + border: 1px solid var(--border); background: var(--bg-1); + padding: 10px 12px; cursor: pointer; border-left: 3px solid var(--fg-muted); +} +.signal-card.signal-converging { border-left-color: var(--green); } +.signal-card.signal-looping { border-left-color: var(--red); } +.signal-card.signal-orbiting { border-left-color: var(--purple); } +.signal-card.signal-plateau { border-left-color: var(--yellow); } +.signal-card.signal-mixed { border-left-color: var(--blue); } +.signal-card:hover { border-color: var(--border-hi); background: var(--bg-2); } +.signal-card-top { display: flex; gap: 10px; align-items: center; margin-bottom: 6px; } +.signal-card-file { font-family: var(--mono); font-size: 11px; color: var(--fg); } +.signal-card-body { font-family: var(--mono); font-size: 10px; color: var(--fg-dim); line-height: 1.55; } +.signal-card-body > div { margin-top: 2px; } +.signal-novel { color: var(--purple); } +.signal-resolved { color: var(--green); } +.signal-loop { color: var(--red); } + diff --git a/ui/ui.js b/ui/ui.js new file mode 100644 index 0000000..837a0f9 --- /dev/null +++ b/ui/ui.js @@ -0,0 +1,883 @@ +// Visual Control Plane — client (vanilla JS, D3 from CDN) +// Design note: KB data flows from local jsonl files we control, but we +// still use DOM methods (createElement/textContent) for every +// data-derived node to satisfy static analysis and keep a clean XSS +// boundary if the UI ever gets exposed. + +const POLL_MS = 3000; + +const state = { + view: "map", + overlay: "status", + selected: null, + services: null, + reviews: [], + metrics: [], + overrides: [], + trust: [], + findings: [], +}; + +// ───── view switcher ───── +document.querySelectorAll("#views button").forEach(b => { + b.addEventListener("click", () => { + document.querySelectorAll("#views button").forEach(x => x.classList.remove("on")); + b.classList.add("on"); + state.view = b.dataset.view; + document.querySelectorAll(".view").forEach(v => v.classList.remove("on")); + document.getElementById(`view-${state.view}`).classList.add("on"); + renderView(); + }); +}); + +document.querySelectorAll("#overlay-controls button").forEach(b => { + b.addEventListener("click", () => { + document.querySelectorAll("#overlay-controls button").forEach(x => x.classList.remove("on")); + b.classList.add("on"); + state.overlay = b.dataset.ov; + if (state.services) drawMap(state.services); + }); +}); + +// ───── helpers ───── +function el(tag, opts = {}, ...kids) { + const n = document.createElement(tag); + if (opts.className) n.className = opts.className; + if (opts.text != null) n.textContent = String(opts.text); + if (opts.data) for (const k in opts.data) n.dataset[k] = opts.data[k]; + if (opts.attrs) for (const k in opts.attrs) n.setAttribute(k, opts.attrs[k]); + if (opts.style) for (const k in opts.style) n.style[k] = opts.style[k]; + for (const k of kids) if (k != null) n.append(k); + return n; +} +function clear(node) { while (node.firstChild) node.removeChild(node.firstChild); } +function row(k, v, valClass) { + const r = el("div", { className: "ctx-row" }); + r.append(el("span", { className: "k", text: k })); + const vv = el("span", { className: "v" + (valClass ? " " + valClass : ""), text: String(v ?? "-") }); + r.append(vv); + return r; +} +function short(v) { + if (v == null) return "-"; + if (typeof v === "object") return JSON.stringify(v).slice(0, 80); + return String(v).slice(0, 80); +} + +// ───── polling ───── +async function poll() { + try { + const [svc, rev, met, ov, tr, fin] = await Promise.all([ + fetch("/data/services").then(r => r.json()), + fetch("/data/reviews?tail=80").then(r => r.json()), + fetch("/data/metrics").then(r => r.json()), + fetch("/data/overrides").then(r => r.json()), + fetch("/data/trust").then(r => r.json()), + fetch("/data/findings").then(r => r.json()), + ]); + state.services = svc; + state.reviews = Array.isArray(rev) ? rev : []; + state.metrics = Array.isArray(met) ? met : []; + state.overrides = Array.isArray(ov) ? ov : []; + state.trust = Array.isArray(tr) ? tr : []; + state.findings = Array.isArray(fin) ? fin : []; + document.getElementById("build-ts").textContent = new Date(svc.ts).toLocaleTimeString(); + svc.nodes.forEach(n => { + const chip = document.querySelector(`.hbchip[data-svc="${n.id}"]`); + if (chip) chip.setAttribute("data-status", n.status); + }); + renderView(); + renderContext(); + pollStream(); + } catch (e) { console.error("poll error", e); } +} + +async function pollStream() { + try { + const j = await fetch("/data/scrum_log").then(r => r.json()); + if (!j.lines) return; + document.getElementById("stream-file").textContent = j.file ? j.file.split("/").pop() : "—"; + const body = document.getElementById("stream-body"); + clear(body); + j.lines.slice(-30).forEach(line => { + const cls = /✓ ACCEPTED/.test(line) ? "ok" + : /✗ thin/.test(line) ? "thin" + : /error|failed|FAIL/i.test(line) ? "err" + : /^\[scrum\] file:/.test(line) ? "head" + : "info"; + body.append(el("div", { className: "sline " + cls, text: line })); + }); + body.scrollTop = body.scrollHeight; + } catch {} +} + +function renderView() { + if (!state.services) return; + if (state.view === "map") drawMap(state.services); + else if (state.view === "trace") drawTrace(); + else if (state.view === "trajectory") drawTrajectory(); + else if (state.view === "metrics") drawMetrics(); + else if (state.view === "kb") drawKB(); + else if (state.view === "console") drawConsole(); +} + +// ───── MAP ───── +const NODES_STATIC = [ + { id: "gateway", x: 0.5, y: 0.15 }, + { id: "sidecar", x: 0.2, y: 0.3 }, + { id: "observer", x: 0.8, y: 0.3 }, + { id: "mcp", x: 0.85, y: 0.1 }, + { id: "context7", x: 0.15, y: 0.1 }, + { id: "journal", x: 0.35, y: 0.55 }, + { id: "vectord", x: 0.5, y: 0.5 }, + { id: "playbook", x: 0.65, y: 0.55 }, + { id: "agent", x: 0.5, y: 0.75 }, + { id: "usage", x: 0.2, y: 0.75 }, +]; +const EDGES = [ + ["gateway","sidecar"],["gateway","observer"],["gateway","mcp"],["gateway","context7"], + ["gateway","journal"],["gateway","vectord"],["gateway","playbook"],["gateway","agent"],["gateway","usage"], + ["vectord","playbook"],["agent","vectord"],["observer","playbook"],["sidecar","vectord"], +]; + +function drawMap(svc) { + const svg = d3.select("#map"); + const box = svg.node().getBoundingClientRect(); + const W = box.width, H = box.height; + svg.selectAll("*").remove(); + const statusMap = {}; + [...svc.nodes, ...svc.subsystems].forEach(n => statusMap[n.id] = n); + svg.selectAll(".edge").data(EDGES).enter().append("line") + .attr("class", d => "edge" + (overlayEdgeActive(d) ? " active" : "")) + .attr("x1", d => nodePos(d[0]).x * W).attr("y1", d => nodePos(d[0]).y * H) + .attr("x2", d => nodePos(d[1]).x * W).attr("y2", d => nodePos(d[1]).y * H); + const g = svg.selectAll(".node").data(NODES_STATIC).enter().append("g") + .attr("class", "node") + .attr("transform", d => `translate(${d.x * W}, ${d.y * H})`) + .on("click", (_ev, d) => { state.selected = { type:"node", id:d.id }; renderContext(); drawMap(svc); }); + g.append("circle") + .attr("class", d => "node-circle" + (state.selected?.type==="node" && state.selected.id===d.id ? " node-selected" : "")) + .attr("r", d => nodeRadius(d, statusMap)) + .attr("fill", d => nodeColor(d, statusMap)); + // SVG tooltip — hover a node, browser shows a native tooltip with + // what this node DOES, not just its name. + g.append("title").text(d => nodeTooltip(d.id)); + g.append("text").attr("class","node-label").attr("y", -30).text(d => nodeLabel(d.id)); + g.append("text").attr("class","node-sub").attr("y", 40).text(d => nodeSub(d, statusMap)); +} +function nodePos(id) { return NODES_STATIC.find(x => x.id === id) ?? { x:0, y:0 }; } +function nodeLabel(id) { + return ({gateway:"GATEWAY",sidecar:"SIDECAR",observer:"OBSERVER",mcp:"MCP",context7:"CTX7", + journal:"JOURNAL",vectord:"VECTORD",playbook:"PLAYBOOK",agent:"AUTOTUNE",usage:"USAGE"})[id] ?? id; +} +function nodeRadius(d, m) { + const n = m[d.id]; + if (state.overlay === "activity") { + if (d.id === "journal" && n?.stats?.total_events_created != null) return 14 + Math.min(20, Math.log2(n.stats.total_events_created + 1) * 2); + if (d.id === "vectord" && n?.stats?.count != null) return 14 + Math.min(20, Math.log2(n.stats.count + 1) * 2); + if (d.id === "playbook" && n?.stats?.total != null) return 14 + Math.min(20, Math.log2(n.stats.total + 1)); + if (d.id === "observer" && n?.stats?.total != null) return 14 + Math.min(20, Math.log2(n.stats.total + 1)); + if (d.id === "usage" && n?.stats?.requests != null) return 14 + Math.min(20, Math.log2(n.stats.requests + 1) * 2); + } + return 18; +} +function nodeColor(d, m) { + const n = m[d.id]; + const ov = state.overlay; + if (ov === "status" || ov === "activity") { + const st = n?.status ?? (n?.stats ? "healthy" : "unknown"); + return { healthy:"#3eed86", degraded:"#ffbf3c", down:"#ff4d6e", unknown:"#525c6f" }[st] ?? "#525c6f"; + } + if (ov === "confidence") { + const c = recentAvgConfidence(d.id); + if (c == null) return "#525c6f"; + if (c >= 88) return "#3eed86"; + if (c >= 70) return "#55c5ff"; + if (c >= 50) return "#ffbf3c"; + return "#ff4d6e"; + } + if (ov === "gradient") { + const t = recentGradientTier(d.id); + return t ? ({auto:"#3eed86",dry_run:"#55c5ff",simulation:"#ffbf3c",block:"#ff4d6e"}[t] ?? "#525c6f") : "#525c6f"; + } + if (ov === "verdict") { + const v = recentVerdict(d.id); + return {pass:"#3eed86",needs_patch:"#ff9f43",fail:"#ff4d6e"}[v] ?? "#525c6f"; + } + return "#55c5ff"; +} +function nodeSub(d, m) { + const n = m[d.id]; + if (!n) return "…"; + if (d.id === "journal" && n.stats) return `${n.stats.total_events_created ?? 0} events · ${n.stats.persisted_files ?? 0} parquet`; + if (d.id === "usage" && n.stats) return `${n.stats.requests ?? 0} requests · ${Math.round((n.stats.total_tokens ?? 0)/1000)}k tokens`; + if (d.id === "vectord" && typeof n.stats === "object" && n.stats) return `${n.stats.count ?? 0} indexes`; + if (d.id === "playbook" && n.stats) return `${n.stats.active ?? 0} active · ${n.stats.retired ?? 0} retired`; + if (d.id === "agent" && n.stats) return `${n.stats.trials_run ?? 0} trials · ${n.stats.promotions ?? 0} promotions`; + if (d.id === "observer" && n.stats) return `${n.stats.total ?? 0} observed ops`; + return String(n.status ?? ""); +} + +// Describes what each node DOES — shown as SVG tooltip. +function nodeTooltip(id) { + return ({ + gateway: "GATEWAY — Rust/Axum HTTP on :3100. Every external call enters here: /v1/chat, /ingest, /query, /tools, /journal, /vectors. Also hosts gRPC on :3101.", + sidecar: "SIDECAR — Python FastAPI on :3200. Adapter from Rust to local Ollama (:11434). Handles /embed /generate /rerank. Stateless.", + observer: "OBSERVER — Bun on :3800. Ring buffer of recent ops across the system. Feeds analyzeErrors + PLAYBOOK_BUILDER loops. Scrum events now land here (P45 fix).", + mcp: "MCP — Bun on :3700. Model Context Protocol tool gateway. Agent-facing tool endpoints.", + context7: "CONTEXT7 — Bun on :3900. Doc-drift resolver — checks playbook doc_refs against current docs for version drift (Phase 45 target).", + journal: "JOURNAL — ADR-012 append-only mutation log inside the gateway. Every ingest/delta-write/tombstone should record here. Currently ~1 real event (P9-001 still mostly unwired).", + vectord: "VECTORD — Embeddings store + HNSW index + autotune harness. The 'indexes' count = named vector indexes live right now (one per source × model_version).", + playbook: "PLAYBOOK — Meta-index. Each entry = a successful past pattern + geo/role + 768d embedding. Active entries boost future vector-search results (Phase 19).", + agent: "AUTOTUNE — Background agent that continuously proposes HNSW config trials, picks Pareto winners above min_recall, promotes, and rolls back. Self-tuning vector index.", + usage: "USAGE — /v1/chat token counters. Tracks requests, prompt/completion tokens, per-provider breakdown. Grows with scrum + audit traffic.", + })[id] ?? id; +} +function overlayEdgeActive(edge) { + if (!state.reviews.length) return false; + const latest = state.reviews[state.reviews.length - 1]; + if (!latest?.reviewed_at) return false; + const age = Date.now() - new Date(latest.reviewed_at).getTime(); + if (age > 60000) return false; + return edge.includes("gateway") && (edge.includes("observer") || edge.includes("vectord")); +} +function matchesNode(r, id) { + if (!r?.file) return false; + const f = r.file.toLowerCase(); + if (id === "gateway") return f.includes("/gateway/"); + if (id === "vectord") return f.includes("/vectord"); + if (id === "journal") return f.includes("/journald"); + if (id === "playbook")return f.includes("playbook_memory"); + if (id === "sidecar") return f.includes("sidecar"); + if (id === "agent") return f.includes("agent.rs") || f.includes("autotune"); + return false; +} +function recentAvgConfidence(id) { + const rs = state.reviews.filter(r => matchesNode(r, id)); + const vs = rs.map(r => r.confidence_avg).filter(v => v != null); + return vs.length ? vs.reduce((a,b)=>a+b,0)/vs.length : null; +} +function recentGradientTier(id) { + const rs = state.reviews.filter(r => matchesNode(r, id)); + const ts = rs.map(r => r.gradient_tier).filter(Boolean); + return ts[ts.length - 1] ?? null; +} +function recentVerdict(id) { + const rs = state.reviews.filter(r => matchesNode(r, id)); + const vs = rs.map(r => r.verdict).filter(Boolean); + return vs[vs.length - 1] ?? null; +} + +// ───── CONTEXT ───── +function renderContext() { + const target = document.getElementById("ctx-target"); + const body = document.getElementById("ctx-body"); + clear(body); + if (!state.selected) { + target.textContent = "no selection"; + body.append(el("div", { className: "ctx-hint", text: "Click a node or a file in KB to inspect. Context persists across view switches." })); + body.append(el("div", { className: "ctx-section-hd", text: "System totals" })); + appendSummaryKV(body); + return; + } + if (state.selected.type === "node") renderNodeContext(state.selected.id, target, body); + else if (state.selected.type === "file") renderFileContext(state.selected.id, target, body); +} + +function appendSummaryKV(body) { + const s = state.services; + if (!s) { body.append(el("div", { className: "ctx-hint", text: "loading…" })); return; } + const get = id => s.nodes.concat(s.subsystems).find(n => n.id === id); + const journal = get("journal")?.stats ?? {}; + const usage = get("usage")?.stats ?? {}; + const playbook = get("playbook")?.stats ?? {}; + const agent = get("agent")?.stats ?? {}; + const observer = get("observer")?.stats ?? {}; + body.append(row("scrum reviews", state.reviews.length)); + body.append(row("journal events", journal.total_events_created ?? 0)); + body.append(row("usage tokens", (usage.total_tokens ?? 0).toLocaleString())); + body.append(row("playbook active", playbook.active ?? 0)); + body.append(row("autotune trials", agent.trials_run ?? 0)); + body.append(row("observer ops", observer.total ?? 0)); + body.append(row("findings (h/m/l)", `${countFindingsSev("high")}/${countFindingsSev("medium")}/${countFindingsSev("low")}`)); +} + +function countFindingsSev(sev) { + let n = 0; + for (const row of state.findings) for (const f of row.findings ?? []) if (f.severity === sev) n++; + return n; +} + +function renderNodeContext(id, target, body) { + target.textContent = `NODE · ${id.toUpperCase()}`; + const n = [...state.services.nodes, ...state.services.subsystems].find(x => x.id === id); + if (n?.health) { + body.append(el("div", { className: "ctx-section-hd", text: "Health" })); + // Fix 2026-04-24: some /health endpoints return a plain string like + // "lakehouse ok". Don't Object.entries() on strings — that iterates + // characters. Detect primitive vs object explicitly. + if (typeof n.health === "string" || typeof n.health === "number" || typeof n.health === "boolean") { + body.append(row("response", String(n.health).slice(0, 80))); + } else if (typeof n.health === "object" && n.health !== null) { + Object.entries(n.health).slice(0, 8).forEach(([k,v]) => body.append(row(k, short(v)))); + } + } + if (n?.stats) { + body.append(el("div", { className: "ctx-section-hd", text: "Stats" })); + if (typeof n.stats === "string") { + body.append(row("raw", String(n.stats).slice(0, 80))); + } else if (typeof n.stats === "object" && n.stats !== null) { + Object.entries(n.stats).slice(0, 10).forEach(([k,v]) => body.append(row(k, short(v)))); + } + } + const related = state.reviews.filter(r => matchesNode(r, id)).slice(-5).reverse(); + if (related.length) { + body.append(el("div", { className: "ctx-section-hd", text: "Recent reviews" })); + related.forEach(r => { + const rr = row(r.file.split("/").pop(), `${r.confidence_avg ?? "-"}% · ${r.alignment_score ?? "?"}/10`); + rr.style.cursor = "pointer"; + rr.addEventListener("click", () => { state.selected = { type:"file", id:r.file }; renderContext(); }); + body.append(rr); + }); + } + if (!body.firstChild) body.append(el("div", { className: "ctx-hint", text: "no data yet" })); +} + +function renderFileContext(fpath, target, body) { + target.textContent = fpath.split("/").slice(-3).join("/"); + const fileReviews = state.reviews.filter(r => r.file === fpath).slice(-6); + if (!fileReviews.length) { + body.append(el("div", { className: "ctx-hint", text: `no reviews for ${fpath}` })); + return; + } + const latest = fileReviews[fileReviews.length - 1]; + const pillRow = el("div", { style: { paddingBottom: "6px" } }); + if (latest.gradient_tier) pillRow.append(el("span", { className: `pill tier-${latest.gradient_tier}`, text: latest.gradient_tier })); + if (latest.verdict) pillRow.append(el("span", { className: `pill ver-${latest.verdict}`, text: latest.verdict })); + if (latest.output_format) pillRow.append(el("span", { className: `pill fmt-${latest.output_format}`, text: latest.output_format })); + body.append(pillRow); + const rows = [ + ["file", fpath], + ["score", latest.alignment_score != null ? `${latest.alignment_score}/10` : "-"], + ["conf avg", latest.confidence_avg != null ? `${latest.confidence_avg}%` : "-"], + ["conf min", latest.confidence_min != null ? `${latest.confidence_min}%` : "-"], + ["findings", latest.findings_count ?? 0], + ["critical", latest.critical_failures_count ?? 0], + ["verified", latest.verified_components_count ?? 0], + ["missing", latest.missing_components_count ?? 0], + ["model", latest.accepted_model ?? "-"], + ["attempts", latest.attempts_made ?? 1], + ["tree split", latest.tree_split_fired ? "yes" : "no"], + ]; + rows.forEach(([k,v]) => body.append(row(k, short(v)))); + body.append(el("div", { className: "ctx-section-hd", text: "Score history" })); + fileReviews.forEach(r => body.append(row(new Date(r.reviewed_at).toLocaleTimeString(), `${r.alignment_score ?? "?"}/10 · ${r.confidence_avg ?? "-"}%`))); + body.append(el("div", { className: "ctx-section-hd", text: "Preview" })); + const pre = el("pre", { text: latest.suggestions_preview ?? "", style: { whiteSpace: "pre-wrap", fontFamily: "var(--mono)", fontSize: "10px", color: "var(--fg-dim)", maxHeight: "200px", overflowY: "auto" } }); + body.append(pre); + document.getElementById("stream-file").textContent = fpath.split("/").pop(); +} + +// ───── TRACE ───── +async function drawTrace() { + const fpath = state.selected?.type === "file" ? state.selected.id : state.reviews[state.reviews.length-1]?.file; + const tl = document.getElementById("trace-timeline"); + const detail = document.getElementById("trace-detail"); + clear(tl); clear(detail); + document.getElementById("trace-file").textContent = fpath ?? "—"; + if (!fpath) { tl.append(el("div", { className: "ctx-hint", text: "no file selected — pick one in KB view" })); return; } + const r = await fetch(`/data/file/${encodeURIComponent(fpath)}`).then(r => r.json()); + const history = r.history ?? []; + document.getElementById("trace-runs").textContent = `${history.length} runs`; + history.forEach((h, i) => { + const node = el("div", { className: "trace-node" + (i === history.length - 1 ? " active" : "") }); + node.append(el("div", { className: "tn-run", text: h.run_id })); + node.append(el("div", { className: "tn-score", text: h.score != null ? String(h.score) : "?" })); + node.append(el("div", { className: "tn-conf", text: `conf ${h.conf_avg ?? "-"}% · ${h.findings}f` })); + node.append(el("div", { className: "tn-model", text: (h.model ?? "").split("/").pop() })); + node.addEventListener("click", () => { + tl.querySelectorAll(".trace-node").forEach(x => x.classList.remove("active")); + node.classList.add("active"); + clear(detail); + detail.append(el("pre", { text: h.preview ?? "" })); + }); + tl.append(node); + }); + if (history.length) { clear(detail); detail.append(el("pre", { text: history[history.length-1].preview ?? "" })); } +} + +// ───── TRAJECTORY — refactor signals + reverse index + per-file delta ───── + +let trajectorySearchTimer = null; +document.getElementById("traj-search")?.addEventListener("input", (e) => { + const q = e.target.value.trim(); + clearTimeout(trajectorySearchTimer); + trajectorySearchTimer = setTimeout(() => runReverseIndex(q), 300); +}); + +async function runReverseIndex(query) { + const body = document.getElementById("traj-body"); + if (!query) { drawTrajectory(); return; } + clear(body); + const res = await fetch(`/data/search?q=${encodeURIComponent(query)}`).then(r => r.json()); + const hdr = el("div", { className: "traj-section-head", text: `REVERSE INDEX · "${query}" · ${res.hits?.length ?? 0} hits` }); + body.append(hdr); + (res.hits ?? []).forEach(h => { + const card = el("div", { className: "traj-hit" }); + card.append(el("div", { className: "traj-hit-top" }, + el("span", { className: "traj-hit-file", text: h.file }), + el("span", { className: "traj-hit-meta", text: `${h.run_id} · ${(h.model ?? "").split("/").pop()}` }) + )); + card.append(el("div", { className: "traj-hit-snip", text: h.snippet })); + card.addEventListener("click", () => { + state.selected = { type: "file", id: `/home/profit/lakehouse/${h.file}` }; + renderContext(); + document.querySelector('#views button[data-view="trace"]').click(); + }); + body.append(card); + }); +} + +async function drawTrajectory() { + const body = document.getElementById("traj-body"); + clear(body); + const statsEl = document.getElementById("traj-stats"); + clear(statsEl); + + // SECTION 0 — signal classes (CONVERGING/LOOPING/ORBITING/PLATEAU/MIXED) + try { + const sc = await fetch("/data/signal_classes").then(r => r.json()); + body.append(el("div", { className: "traj-section-head", text: "SIGNAL CLASSES · iter-to-iter behavior per file" })); + body.append(el("div", { className: "traj-section-explain", text: + "Each file compared iter-to-iter: CONVERGING = fix landed (resolved > novel + score↑), " + + "LOOPING = same findings repeating (deadlock candidate for hyper-focus), " + + "ORBITING = novel findings every iter (healthy depth-first), " + + "PLATEAU = score+findings flat (diminishing returns, needs different angle), " + + "MIXED = partial movement, NEW = only 1 iter so far." + })); + const classRow = el("div", { className: "signal-class-row" }); + for (const [cls, n] of Object.entries(sc.counts ?? {})) { + const chip = el("span", { className: `signal-chip signal-${cls.toLowerCase()}`, text: `${cls} ${n}` }); + classRow.append(chip); + } + body.append(classRow); + const grid = el("div", { className: "signal-grid" }); + const sorted = Object.entries(sc.classes ?? {}).sort((a, b) => { + const order = { CONVERGING: 0, LOOPING: 1, ORBITING: 2, MIXED: 3, PLATEAU: 4, NEW: 5 }; + return (order[a[1].cls] ?? 9) - (order[b[1].cls] ?? 9); + }); + for (const [file, info] of sorted) { + const card = el("div", { className: `signal-card signal-${info.cls.toLowerCase()}` }); + card.append(el("div", { className: "signal-card-top" }, + el("span", { className: `signal-chip signal-${info.cls.toLowerCase()}`, text: info.cls }), + el("span", { className: "signal-card-file", text: file }) + )); + const body2 = el("div", { className: "signal-card-body" }); + if (info.prev_score != null || info.last_score != null) { + body2.append(el("div", { text: `score ${info.prev_score ?? "?"} → ${info.last_score ?? "?"} (Δ ${info.delta_score != null ? (info.delta_score > 0 ? "+" : "") + info.delta_score.toFixed(1) : "?"})` })); + } + if (info.novel?.length) body2.append(el("div", { className: "signal-novel", text: `NEW: ${info.novel.join(", ")}` })); + if (info.resolved?.length) body2.append(el("div", { className: "signal-resolved", text: `RESOLVED: ${info.resolved.join(", ")}` })); + if (info.looping?.length) body2.append(el("div", { className: "signal-loop", text: `LOOPING: ${info.looping.join(", ")}` })); + card.append(body2); + card.addEventListener("click", () => { + state.selected = { type: "file", id: `/home/profit/lakehouse/${file}` }; + renderContext(); + document.querySelector('#views button[data-view="trace"]').click(); + }); + grid.append(card); + } + body.append(grid); + } catch (e) { + body.append(el("div", { className: "ctx-hint", text: `signal classes error: ${e}` })); + } + + // SECTION 1 — refactor signals + const sig = await fetch("/data/refactor_signals").then(r => r.json()); + const sigs = sig.signals ?? []; + const totalHits = sigs.reduce((a,s) => a + s.hits, 0); + statsEl.textContent = `${sig.scanned ?? 0} files scanned · ${sigs.length} with refactor hints · ${totalHits} phrase hits total`; + + const sigHead = el("div", { className: "traj-section-head", text: "REFACTOR SIGNALS · files the scrum repeatedly flagged as dead / redundant / stub / needs-rewrite" }); + body.append(sigHead); + + const explain = el("div", { className: "traj-section-explain", text: + "Aggregates across all scrum iterations. A phrase hit = one time the reviewer used language like 'remove', 'duplicate', 'refactor', 'pseudocode', 'orphaned'. " + + "Files near the top are the strongest refactor candidates — the scrum keeps calling them out. Click a row to jump to its per-iteration trace." + }); + body.append(explain); + + const table = el("div", { className: "traj-table" }); + sigs.slice(0, 30).forEach(s => { + const r = el("div", { className: "traj-row" }); + r.append(el("div", { className: "traj-col-rank", text: String(sigs.indexOf(s) + 1) })); + r.append(el("div", { className: "traj-col-file", text: s.file })); + r.append(el("div", { className: "traj-col-hits", text: `${s.hits}×` })); + const topPhrases = Object.entries(s.phrases).sort((a,b)=>b[1]-a[1]).slice(0,3) + .map(([p,n]) => `${p} (${n})`).join(", "); + r.append(el("div", { className: "traj-col-phrases", text: topPhrases })); + r.append(el("div", { className: "traj-col-iters", text: `${s.iterations} iter` })); + r.addEventListener("click", () => { + state.selected = { type: "file", id: `/home/profit/lakehouse/${s.file}` }; + renderContext(); + document.querySelector('#views button[data-view="trace"]').click(); + }); + table.append(r); + }); + body.append(table); + + // SECTION 2 — per-file trajectory: pick the top-5 refactor candidates and + // show their score/conf delta across iterations inline. + if (sigs.length) { + body.append(el("div", { className: "traj-section-head", text: "SCORE TRAJECTORY — top refactor candidates" })); + const grid = el("div", { className: "traj-spark-grid" }); + for (const s of sigs.slice(0, 6)) { + const card = el("div", { className: "traj-spark" }); + card.append(el("div", { className: "traj-spark-file", text: s.file })); + // pull history + const hist = await fetch(`/data/file/${encodeURIComponent("/home/profit/lakehouse/" + s.file)}`) + .then(r => r.json()).catch(() => ({ history: [] })); + const runs = hist.history ?? []; + if (runs.length === 0) { card.append(el("div", { className: "traj-spark-empty", text: "no history" })); } + else { + const line = el("div", { className: "traj-spark-line" }); + runs.forEach((h,i) => { + const pt = el("div", { className: "traj-spark-pt" }); + pt.append(el("div", { className: "traj-pt-score", text: h.score != null ? `${h.score}/10` : "?" })); + pt.append(el("div", { className: "traj-pt-conf", text: `${h.conf_avg ?? "-"}%` })); + pt.append(el("div", { className: "traj-pt-label", text: `iter${i+1}` })); + line.append(pt); + if (i < runs.length - 1) line.append(el("div", { className: "traj-spark-arrow", text: "→" })); + }); + card.append(line); + // delta summary + if (runs.length >= 2) { + const first = runs[0], last = runs[runs.length - 1]; + const dScore = (last.score != null && first.score != null) ? (last.score - first.score) : null; + const dConf = (last.conf_avg != null && first.conf_avg != null) ? (last.conf_avg - first.conf_avg) : null; + const delta = el("div", { className: "traj-spark-delta" }); + if (dScore != null) delta.append(el("span", { text: `Δscore ${dScore > 0 ? "+" : ""}${dScore.toFixed(1)}`, className: dScore < 0 ? "delta-down" : dScore > 0 ? "delta-up" : "" })); + if (dConf != null) delta.append(el("span", { text: ` · Δconf ${dConf > 0 ? "+" : ""}${dConf}%`, className: dConf > 0 ? "delta-up" : dConf < 0 ? "delta-down" : "" })); + card.append(delta); + } + } + card.addEventListener("click", () => { + state.selected = { type: "file", id: `/home/profit/lakehouse/${s.file}` }; + renderContext(); + document.querySelector('#views button[data-view="trace"]').click(); + }); + grid.append(card); + } + body.append(grid); + } +} + +// ───── METRICS ───── +function metricBox(label, big, kind, opts = {}) { + // opts: { source, good, explain } + // source = where the number comes from (data path) + // good = the "what's a healthy value" sentence + // explain = one-line definition of what this counts + const box = el("div", { className: "metric" + (kind ? " " + kind : "") }); + box.append(el("div", { className: "m-label", text: label })); + box.append(el("div", { className: "m-big", text: big })); + if (opts.explain) box.append(el("div", { className: "m-sub m-explain", text: opts.explain })); + if (opts.source) box.append(el("div", { className: "m-sub m-source", text: "SOURCE · " + opts.source })); + if (opts.good) box.append(el("div", { className: "m-sub m-good", text: "GOOD · " + opts.good })); + return box; +} +function drawMetrics() { + const grid = document.getElementById("metric-grid"); + clear(grid); + // Kick off pathway fetch in parallel; render when it resolves so the + // rest of the metrics grid appears immediately. The cards append to + // the grid after the synchronous block below — they'll show up at + // the bottom of the grid within a tick of first render. + fetch("/data/pathway_stats").then(r => r.ok ? r.json() : null).then(j => { + if (!j || !j.stats) return; + const s = j.stats; + const w = j.scrum_window ?? {}; + // Activity metric — is the hot-swap firing at all? + grid.append(metricBox("pathway reuse rate", `${Math.round((w.pathway_reuse_rate ?? 0) * 100)}%`, + (w.pathway_reuse_rate ?? 0) > 0.1 ? "good" : (w.pathway_reuse_rate ?? 0) > 0 ? "warn" : "bad", { + explain: "% of recent reviews where a pathway hot-swap fired (narrow fingerprint match + 0.80 success rate + ≥3 replays + audit_consensus pass + 0.90 similarity).", + source: `scrum_reviews.jsonl .pathway_hot_swap_hit over last ${w.reviews ?? 0} reviews (${w.hot_swap_hits ?? 0} hits)`, + good: "≥10% sustained = index earning its keep. <10% over many iters = fingerprint too narrow or probation too strict. 0% on fresh install is expected (no replays yet).", + })); + // Value metric — how much compute did hot-swap actually save? + const saved = w.avg_rungs_saved_per_commit ?? 0; + grid.append(metricBox("avg rungs saved", saved.toFixed(2), + saved >= 1 ? "good" : saved > 0 ? "warn" : "bad", { + explain: "Average ladder rungs skipped per committed review by hot-swap. Rungs_saved = recommended_rung - 1 when the recommended model succeeded (otherwise 0).", + source: "scrum_reviews.jsonl .rungs_saved averaged", + good: "Every 1.0 here ≈ one less model call per review. At 21 files/iter, 1.0 saved = 21 cloud calls avoided. Value only counts when the replay actually succeeded.", + })); + // Stability metric — retired pathways indicate the learning loop is correcting itself. + grid.append(metricBox("pathways tracked", String(s.total_pathways), + s.total_pathways > 0 ? "good" : "warn", { + explain: `Total pathway traces stored. ${s.retired} retired (below 0.80 success after ≥3 replays). ${s.with_audit_pass} audit-passed, eligible for hot-swap probation.`, + source: "/vectors/pathway/stats", + good: `Grows monotonically with scrum runs. Retired=${s.retired} is HEALTHY — it means the learning loop is pruning pathways that stopped working. replay_success_rate=${(s.replay_success_rate*100).toFixed(0)}% aggregates all historical replays.`, + })); + }).catch(() => {}); + const byTier = { auto:0, dry_run:0, simulation:0, block:0, unknown:0 }; + state.reviews.forEach(r => { const t = r.gradient_tier ?? "unknown"; if (byTier[t] != null) byTier[t]++; }); + const total = state.reviews.length || 1; + const confRows = state.reviews.filter(r => r.confidence_avg != null); + const avg = confRows.length ? Math.round(confRows.reduce((a,r)=>a+r.confidence_avg,0)/confRows.length) : 0; + const verdictCount = { pass:0, needs_patch:0, fail:0, unknown:0 }; + state.reviews.forEach(r => { const v=r.verdict??"unknown"; if(verdictCount[v]!=null) verdictCount[v]++; }); + const findingsTotal = state.reviews.reduce((a,r)=>a+(r.findings_count??0),0); + const critTotal = state.reviews.reduce((a,r)=>a+(r.critical_failures_count??0),0); + const verTotal = state.reviews.reduce((a,r)=>a+(r.verified_components_count??0),0); + const usage = state.services?.subsystems?.find(n=>n.id==="usage")?.stats ?? {}; + const journal = state.services?.subsystems?.find(n=>n.id==="journal")?.stats ?? {}; + + grid.append(metricBox("avg confidence", `${avg}%`, avg>=85?"good":avg>=70?"warn":"bad", { + explain: "Self-assessed probability per suggestion, averaged across every review.", + source: "scrum_reviews.jsonl .confidence_avg", + good: "≥85% — model is confident. 70-84% routine. <70% means the scrum is uncertain and findings need human review.", + })); + grid.append(metricBox("scrum reviews", String(state.reviews.length), "good", { + explain: "Every source file reviewed by the scrum master, across all iterations.", + source: `${state.metrics.length} scrum runs tracked in scrum_loop_metrics.jsonl`, + good: "Grows every run — 21 files × N iterations. Stall = pipeline broken.", + })); + grid.append(metricBox("critical failures", String(critTotal), critTotal>50?"bad":critTotal>10?"warn":"good", { + explain: "Hard FAILs flagged by the forensic reviewer — pseudocode, fake implementations, unwired invariants. Each one is a concrete code-level gap.", + source: "scrum_reviews.jsonl .critical_failures_count (forensic JSON format only)", + good: "Trending DOWN each iteration = fixes are landing. Rising = new gaps surfacing faster than we close them.", + })); + grid.append(metricBox("verified components", String(verTotal), verTotal>0?"good":"warn", { + explain: "What the scrum CONFIRMED is working — with file/line evidence. The inverse of critical_failures.", + source: "scrum_reviews.jsonl .verified_components_count", + good: "Trending UP = the system has more provably-real parts over time. Should grow as fixes land.", + })); + grid.append(metricBox("findings captured", String(findingsTotal), "good", { + explain: "Total individual suggestions the scrum produced across all reviews (tables + JSON).", + source: "scrum_reviews.jsonl .findings_count summed", + good: "Higher = more scrutiny per file. Per-file average ≥10 means the review is substantive.", + })); + grid.append(metricBox("journal events", String(journal.total_events_created ?? 0), "good", { + explain: "Mutation events recorded via ADR-012 append-only journal. Every ingest/delta-write should emit one.", + source: "/journal/stats → total_events_created", + good: "Should grow with ingest traffic. 1 = only a test probe fired; internal callers still unwired on most paths (P9-001).", + })); + grid.append(metricBox("v1 requests", String(usage.requests ?? 0), "good", { + explain: "Calls through the Universal API /v1/chat endpoint (Phase 38). Captures all scrum + audit traffic.", + source: `/v1/usage → requests. ${(usage.total_tokens ?? 0).toLocaleString()} tokens total`, + good: "Every iteration adds ~21 requests. Stall = scrum paused OR callers bypassing the gateway (P44-style bypass).", + })); + + // gradient bar + const gb = el("div", { className: "metric" }); + gb.append(el("div", { className: "m-label", text: "permission gradient" })); + gb.append(el("div", { className: "m-big", text: String(state.reviews.length) })); + gb.append(el("div", { className: "m-sub m-explain", text: "Tiers the scrum's suggestions by confidence: how much auto-apply we can trust per file." })); + const bar = el("div", { className: "bar" }); + bar.append(el("span", { className: "seg-auto", style: { width: `${100*byTier.auto/total}%` } })); + bar.append(el("span", { className: "seg-dry_run", style: { width: `${100*byTier.dry_run/total}%` } })); + bar.append(el("span", { className: "seg-simulation", style: { width: `${100*byTier.simulation/total}%` } })); + bar.append(el("span", { className: "seg-block", style: { width: `${100*byTier.block/total}%` } })); + gb.append(bar); + gb.append(el("div", { className: "m-sub", text: `auto ${byTier.auto} · dry_run ${byTier.dry_run} · sim ${byTier.simulation} · block ${byTier.block}` })); + gb.append(el("div", { className: "m-sub m-good", text: + "AUTO (≥90%): ship the suggestion. DRY_RUN (70-89): apply then diff. SIMULATION (50-69): test first. BLOCK (<50): human review — the model doesn't trust itself." + })); + grid.append(gb); + + const vb = el("div", { className: "metric" }); + vb.append(el("div", { className: "m-label", text: "verdict distribution" })); + vb.append(el("div", { className: "m-big", text: String(verdictCount.pass + verdictCount.needs_patch + verdictCount.fail) })); + vb.append(el("div", { className: "m-sub m-explain", text: "Forensic audit verdict per file: pass = works, needs_patch = fixable gaps, fail = not trustable." })); + vb.append(el("div", { className: "m-sub", text: `pass ${verdictCount.pass} · needs_patch ${verdictCount.needs_patch} · fail ${verdictCount.fail}` })); + vb.append(el("div", { className: "m-sub m-source", text: "SOURCE · scrum_reviews.jsonl .verdict (forensic JSON only — markdown rows count as unknown)" })); + grid.append(vb); +} + +// ───── KB ───── +function drawKB() { + const grid = document.getElementById("kb-grid"); + clear(grid); + + // Explanatory banner — each iteration the scrum re-reviews every + // target file and writes a row here. A card = one file's latest + // review. Click to drill into its trace across all iterations. + const banner = el("div", { className: "kb-banner" }); + banner.append(el("div", { className: "kb-banner-title", text: "KNOWLEDGE BASE — every source file reviewed by the scrum master" })); + banner.append(el("div", { className: "kb-banner-body", text: + "Each card below is the LATEST scrum review of one source file. The review itself lives in data/_kb/scrum_reviews.jsonl. " + + "Fields: score (scrum's alignment rating, 1-10 vs PRD intent), conf (model's self-assessed confidence per suggestion, avg'd), " + + "findings (# of suggestions), crit (critical_failures — hard FAILs found), verified (verified_components — what's confirmed working). " + + "Pills show: permission gradient (can we trust auto-apply), verdict (pass/needs_patch/fail), output format (JSON = forensic, markdown = legacy). " + + "Click a card to see its trace across all iterations (iter 1 → iter N) and watch scores trend." + })); + grid.append(banner); + + const byFile = new Map(); + state.reviews.forEach(r => { if (r.file) byFile.set(r.file, r); }); + const rows = [...byFile.values()].sort((a,b) => (b.confidence_avg??0) - (a.confidence_avg??0)); + + // Quick stats above the cards + const statLine = el("div", { className: "kb-statline" }); + const avgConf = rows.length ? Math.round(rows.reduce((a,r)=>a+(r.confidence_avg??0),0) / rows.length) : 0; + const scoreMean = rows.filter(r=>r.alignment_score!=null); + const avgScore = scoreMean.length ? (scoreMean.reduce((a,r)=>a+r.alignment_score,0) / scoreMean.length).toFixed(1) : "?"; + const blockCount = rows.filter(r => r.gradient_tier === "block").length; + statLine.append(el("span", { text: `${rows.length} files tracked` })); + statLine.append(el("span", { text: `mean score ${avgScore}/10` })); + statLine.append(el("span", { text: `mean confidence ${avgConf}%` })); + statLine.append(el("span", { text: `${blockCount} blocked (need human review)`, className: blockCount > 0 ? "stat-warn" : "" })); + grid.append(statLine); + + rows.forEach(r => { + const card = el("div", { className: "kb-file", data: { file: r.file } }); + card.append(el("div", { className: "kf-path", text: r.file })); + const meta = el("div", { className: "kf-meta" }); + const scoreSpan = el("span", { className: "kf-score", text: `${r.alignment_score ?? "?"}/10` }); + scoreSpan.title = "Scrum's alignment score (1-10) — how well this file matches PRD intent. Lower = more gaps."; + meta.append(scoreSpan); + const confSpan = el("span", { text: `conf ${r.confidence_avg ?? "-"}%` }); + confSpan.title = "Average self-confidence across suggestions. <70% = model uncertain, treat carefully."; + meta.append(confSpan); + const findingsSpan = el("span", { text: `${r.findings_count ?? 0} findings` }); + findingsSpan.title = "Total suggestions in this review (table rows or JSON array entries)."; + meta.append(findingsSpan); + const critSpan = el("span", { text: `${r.critical_failures_count ?? 0} crit` }); + critSpan.title = "Critical failures: pseudocode, fake implementations, unwired invariants. Hard FAILs."; + if ((r.critical_failures_count ?? 0) > 0) critSpan.style.color = "var(--red)"; + meta.append(critSpan); + const verSpan = el("span", { text: `${r.verified_components_count ?? 0} verified` }); + verSpan.title = "Verified components: things the scrum CONFIRMED work, with file/line evidence."; + if ((r.verified_components_count ?? 0) > 0) verSpan.style.color = "var(--green)"; + meta.append(verSpan); + meta.append(el("span", { text: (r.accepted_model ?? "").split("/").pop(), attrs: { title: "Which model produced this review" } })); + card.append(meta); + const pills = el("div", { className: "kf-meta" }); + if (r.gradient_tier) { + const p = el("span", { className: `pill tier-${r.gradient_tier}`, text: r.gradient_tier }); + p.title = ({ + auto: "AUTO — confidence ≥90%, suggestions safe to apply automatically", + dry_run: "DRY_RUN — confidence 70-89%, apply then review the diff", + simulation: "SIMULATION — confidence 50-69%, test in sandbox first", + block: "BLOCK — confidence <50%, requires human review, do not auto-apply", + })[r.gradient_tier] ?? r.gradient_tier; + pills.append(p); + } + if (r.verdict) { + const p = el("span", { className: `pill ver-${r.verdict}`, text: r.verdict }); + p.title = ({ + pass: "PASS — scrum confirms this file meets its PRD intent", + needs_patch: "NEEDS_PATCH — gaps exist but are fixable; scrum has concrete suggestions", + fail: "FAIL — file cannot be trusted for its claimed purpose without structural changes", + })[r.verdict] ?? r.verdict; + pills.append(p); + } + if (r.output_format) { + const p = el("span", { className: `pill fmt-${r.output_format}`, text: r.output_format }); + p.title = r.output_format === "forensic_json" + ? "FORENSIC_JSON — structured output with verdict/critical/verified/missing fields. Richer signal." + : "MARKDOWN — legacy tabular output. Lower structure; we only extract confidence scalars from these."; + pills.append(p); + } + card.append(pills); + card.addEventListener("click", () => { + state.selected = { type: "file", id: r.file }; + renderContext(); + document.querySelector('#views button[data-view="trace"]').click(); + }); + grid.append(card); + }); +} + +// ───── CONSOLE ───── +// Persistent selection across polls so tab switches survive. +state.consoleSvc = "gateway"; + +// Hook tab buttons once +document.querySelectorAll("#con-tabs button").forEach(b => { + b.addEventListener("click", () => { + document.querySelectorAll("#con-tabs button").forEach(x => x.classList.remove("on")); + b.classList.add("on"); + state.consoleSvc = b.dataset.svc; + drawConsole(); + }); +}); + +async function drawConsole() { + const log = document.getElementById("console-log"); + clear(log); + const unit = document.getElementById("con-unit"); + if (unit) unit.textContent = ""; + + if (state.consoleSvc === "summary") { + drawConsoleSummary(log); + return; + } + + // Per-service log tail + const svc = state.consoleSvc; + try { + const res = await fetch(`/data/logs/${svc}?n=120`).then(r => r.json()); + if (unit && res.unit) unit.textContent = `unit · ${res.unit}`; + if (res.error) { + log.append(lineInfo(`[error] ${res.error}`, "cl-err")); + return; + } + const lines = res.lines ?? []; + if (!lines.length) { log.append(lineInfo("(no log lines — unit may have just started)", "cl-info")); return; } + lines.forEach(l => { + const cls = /\berror\b|\bERROR\b|panic|\[ERROR|failed/.test(l) ? "cl-err" + : /\bwarn\b|\bWARN\b|\bwarning\b|\[WARN/.test(l) ? "cl-warn" + : /\baccepted\b|\bok\b|\bOK\b|success|complete|ready/.test(l) ? "cl-ok" + : "cl-info"; + log.append(lineInfo(l, cls)); + }); + // autoscroll to bottom + log.scrollTop = log.scrollHeight; + } catch (e) { + log.append(lineInfo(`[fetch-error] ${e}`, "cl-err")); + } +} + +function lineInfo(text, cls) { + return el("div", { className: "cl-line " + cls, text }); +} + +function drawConsoleSummary(log) { + const info = t => lineInfo(t, "cl-info"); + const ok = t => lineInfo(t, "cl-ok"); + const warn = t => lineInfo(t, "cl-warn"); + const err = t => lineInfo(t, "cl-err"); + log.append(info(`# Lakehouse VCP · ${new Date().toLocaleTimeString()}`)); + log.append(info(`# Services`)); + for (const n of state.services?.nodes ?? []) { + const line = `[${String(n.status).padEnd(8)}] ${n.label}`; + log.append(n.status === "healthy" ? ok(line) : n.status === "down" ? err(line) : warn(line)); + } + log.append(info(`# Subsystems`)); + for (const s of state.services?.subsystems ?? []) { + log.append(info(` ${String(s.id).padEnd(10)} ${JSON.stringify(s.stats ?? {}).slice(0, 120)}`)); + } + log.append(info(`# Recent overrides (layer 10)`)); + for (const o of state.overrides.slice(-6)) { + log.append(warn(` [${o.ts}] ${o.task_signature}: ${o.human_fix}`)); + } + log.append(info(`# Model trust accumulated`)); + const agg = {}; + for (const t of state.trust) { + const k = t.accepted_model ?? "?"; + agg[k] = agg[k] ?? { accepts:0, thin:0, attempts:0 }; + agg[k].accepts++; + agg[k].thin += t.thin_rejections ?? 0; + agg[k].attempts += t.attempts_made ?? 0; + } + for (const [m, s] of Object.entries(agg)) { + log.append(info(` ${String(m).padEnd(48)} accepts=${s.accepts} thin=${s.thin} attempts=${s.attempts}`)); + } +} + +// ───── boot ───── +poll(); +setInterval(poll, POLL_MS); +window.addEventListener("resize", () => { if (state.services && state.view === "map") drawMap(state.services); });