@fiale-plus/pi-rogue 0.2.3 → 0.3.0

package/node_modules/@fiale-plus/pi-rogue-orchestration/src/novelty-guard.ts

@@ -6,6 +6,8 @@ const STATE_FILE = "repetition-guard.json";
 const MAX_ASSISTANT_TURNS = 6;
 const REPEAT_COUNT = 3;
 const REPEAT_THRESHOLD = 0.8;
+const NO_PROGRESS_COUNT = 3;
+const BOUNDED_RECOVERY_COUNT = 5;
 
 export interface RepetitionGuardTurn {
   at: string;
@@ -18,9 +20,17 @@ export interface RepetitionGuardRepeat {
   text: string;
 }
 
+export interface NoProgressSignal {
+  at: string;
+  count: number;
+  text: string;
+  reason: string;
+}
+
 export interface RepetitionGuardState {
   recentAssistantTurns: RepetitionGuardTurn[];
   assistantRepeat?: RepetitionGuardRepeat;
+  noProgress?: NoProgressSignal;
 }
 
 export function defaultRepetitionGuardState(): RepetitionGuardState {
@@ -70,7 +80,18 @@ export function detectAssistantRepetition(state: RepetitionGuardState, minCount
   };
 }
 
-export function recordAssistantTurn(state: RepetitionGuardState, text: string): RepetitionGuardState {
+export function looksLikeNoProgressTurn(text: string): boolean {
+  const normalized = normalizeTurn(text);
+  if (normalized.length < 24) return false;
+
+  const planning = /\b(i will|i'll|let me|going to|we need to|we should|next i|plan|planning|approach|think through|summarize|restate)\b/i.test(text);
+  if (!planning) return false;
+
+  const concreteProgress = /\b(changed|edited|created|wrote|updated|implemented|removed|ran|tested|passed|failed|verified|validated|found|inspected|read|opened|committed|pushed|fixed|completed|result|error|diff)\b/i.test(text);
+  return !concreteProgress;
+}
+
+export function recordAssistantTurn(state: RepetitionGuardState, text: string, options: { activeOrchestration?: boolean } = {}): RepetitionGuardState {
   const trimmed = String(text ?? "").trim();
   if (!trimmed) return state;
   const next: RepetitionGuardState = {
@@ -78,7 +99,22 @@ export function recordAssistantTurn(state: RepetitionGuardState, text: string):
     recentAssistantTurns: [...state.recentAssistantTurns, { at: new Date().toISOString(), text: truncate(trimmed, 1200) }].slice(-MAX_ASSISTANT_TURNS),
   };
   const repeat = detectAssistantRepetition(next);
-  return repeat ? { ...next, assistantRepeat: repeat } : { ...next, assistantRepeat: undefined };
+  const noProgressCount = options.activeOrchestration && looksLikeNoProgressTurn(trimmed)
+    ? (state.noProgress?.count ?? 0) + 1
+    : 0;
+
+  return {
+    ...next,
+    assistantRepeat: repeat ?? undefined,
+    noProgress: noProgressCount > 0
+      ? {
+          at: new Date().toISOString(),
+          count: noProgressCount,
+          text: truncate(trimmed, 240),
+          reason: "repeated planning/self-talk without concrete progress while orchestration is active",
+        }
+      : undefined,
+  };
 }
 
 function parseState(raw: string): RepetitionGuardState {
@@ -96,6 +132,14 @@ function parseState(raw: string): RepetitionGuardState {
             text: parsed.assistantRepeat.text,
           }
         : undefined,
+      noProgress: parsed.noProgress && typeof parsed.noProgress.text === "string"
+        ? {
+            at: String(parsed.noProgress.at ?? new Date().toISOString()),
+            count: Number(parsed.noProgress.count) || NO_PROGRESS_COUNT,
+            text: parsed.noProgress.text,
+            reason: String(parsed.noProgress.reason ?? "no concrete progress detected"),
+          }
+        : undefined,
     };
   } catch {
     return defaultRepetitionGuardState();
@@ -110,6 +154,44 @@ function writeGuardState(ctx: any, state: RepetitionGuardState): void {
   writeText(sessionFile(FEATURE, ctx, STATE_FILE), `${JSON.stringify(state, null, 2)}\n`);
 }
 
+export function clearNoProgressRecovery(ctx: any): void {
+  const state = readGuardState(ctx);
+  if (!state.noProgress) return;
+  writeGuardState(ctx, { ...state, noProgress: undefined });
+}
+
+function hasActiveOrchestration(ctx: any): boolean {
+  if (readText(sessionFile(FEATURE, ctx, "goal.md")).trim()) return true;
+  for (const file of ["loop.json", "autoresearch.json"]) {
+    try {
+      const parsed = JSON.parse(readText(sessionFile(FEATURE, ctx, file), "{}"));
+      if (parsed?.enabled || parsed?.instruction) return true;
+    } catch {
+      // ignore malformed state files; they should not trigger recovery
+    }
+  }
+  return false;
+}
+
+function recoveryPrompt(repeat?: RepetitionGuardRepeat, noProgress?: NoProgressSignal): string | null {
+  if (noProgress && noProgress.count < NO_PROGRESS_COUNT) noProgress = undefined;
+  if (!repeat && !noProgress) return null;
+  const count = Math.max(repeat?.count ?? 0, noProgress?.count ?? 0);
+  const bounded = count >= BOUNDED_RECOVERY_COUNT;
+  const signal = repeat
+    ? `Repeated assistant output (${repeat.count} turns): ${truncate(repeat.text, 180)}`
+    : `No-progress streak (${noProgress?.count} turns): ${truncate(noProgress?.text ?? "", 180)}`;
+
+  return [
+    bounded ? "Pi-Rogue bounded no-progress recovery:" : "Pi-Rogue no-progress recovery:",
+    signal,
+    noProgress?.reason ? `Reason: ${noProgress.reason}.` : "Reason: repeated output suggests the current approach is stuck.",
+    bounded
+      ? "Recovery is bounded now: do not stack another retry. If one safe, concrete alternative action is available, take exactly that action; otherwise stop and ask the user for direction with the current blocker."
+      : "Summarize the current state in one sentence, choose one concrete alternative action, and take it now. Do not only restate the plan or repeat the same response.",
+  ].join("\n");
+}
+
 export function registerNoveltyGuard(pi: ExtensionAPI): void {
   const p = pi as any;
   if (p.__piRogueNoveltyGuardRegistered) return;
@@ -117,16 +199,16 @@ export function registerNoveltyGuard(pi: ExtensionAPI): void {
 
   pi.on("before_agent_start", async (event, ctx) => {
     const state = readGuardState(ctx);
-    const repeat = detectAssistantRepetition(state) ?? state.assistantRepeat;
-    if (!repeat) return { systemPrompt: event.systemPrompt };
+    const active = hasActiveOrchestration(ctx);
+    const noProgress = active ? state.noProgress : undefined;
+    if (!active && state.noProgress) {
+      clearNoProgressRecovery(ctx);
+    }
+    const prompt = recoveryPrompt(detectAssistantRepetition(state) ?? state.assistantRepeat, noProgress);
+    if (!prompt) return { systemPrompt: event.systemPrompt };
 
     return {
-      systemPrompt: [
-        event.systemPrompt,
-        "Pi-Rogue repetition guard:",
-        `The previous assistant output repeated ${repeat.count} times: ${truncate(repeat.text, 180)}`,
-        "Inspect current state before continuing, then apply only the smallest missing delta. Do not repeat the same response.",
-      ].join("\n\n"),
+      systemPrompt: [event.systemPrompt, prompt].join("\n\n"),
     };
   });
 
@@ -136,10 +218,13 @@ export function registerNoveltyGuard(pi: ExtensionAPI): void {
     if (!text) return;
 
     const previous = readGuardState(ctx);
-    const next = recordAssistantTurn(previous, text);
+    const next = recordAssistantTurn(previous, text, { activeOrchestration: hasActiveOrchestration(ctx) });
     writeGuardState(ctx, next);
     if (next.assistantRepeat && (!previous.assistantRepeat || next.assistantRepeat.count > previous.assistantRepeat.count)) {
       ctx.ui.notify("Repetition guard detected repeated assistant output; the next turn will inspect current state before retrying.", "warning");
     }
+    if (next.noProgress && next.noProgress.count >= NO_PROGRESS_COUNT && (!previous.noProgress || next.noProgress.count > previous.noProgress.count)) {
+      ctx.ui.notify("No-progress recovery detected repeated planning without concrete progress; the next turn will take one alternative action or stop.", "warning");
+    }
   });
 }

package/node_modules/@fiale-plus/pi-rogue-router/README.md

@@ -11,24 +11,63 @@ npm run router:rebuild -- --session ./current-session.jsonl --workspace-diff --o
 npm run router:decide -- --checkpoint-file .pi/router/checkpoints.jsonl --ledger .pi/router/events.jsonl
 npm run router:cards -- --events .pi/router/events.jsonl --output .pi/router/model-cards.jsonl
 npm run router:outcomes -- --checkpoint-file .pi/router/checkpoints.jsonl --events .pi/router/events.jsonl --output .pi/router/outcomes.jsonl
+npm run router:outcome-enrich -- --outcomes .pi/router/outcomes.jsonl --checkpoint-file .pi/router/checkpoints.jsonl --events .pi/router/events.jsonl --output .pi/router/outcomes.enriched.jsonl
 npm run router:teacher-requests -- --checkpoint-file .pi/router/checkpoints.jsonl --output .pi/router/teacher-requests.jsonl --teacher openai-codex/gpt-5.5
-npm run router:reflect -- --checkpoint-file .pi/router/checkpoints.jsonl --labels .pi/router/labels/teacher-labels.jsonl --reflection .pi/router/reflections/session.md --teacher local-rule
+npm run router:teacher-label -- --requests .pi/router/teacher-requests.jsonl --teacher-output .pi/router/teacher-decisions.jsonl --labels .pi/router/labels/teacher-labels.jsonl --teacher openai-codex/gpt-5.5
+npm run router:reflect -- --checkpoint-file .pi/router/checkpoints.jsonl --labels .pi/router/labels/teacher-labels.jsonl --reflection .pi/router/reflections/session.md --teacher openai-codex/gpt-5.5 --teacher-output .pi/router/teacher-decisions.jsonl
 npm run router:dataset -- --checkpoint-file .pi/router/checkpoints.jsonl --events .pi/router/events.jsonl --outcomes .pi/router/outcomes.jsonl --labels .pi/router/labels/teacher-labels.jsonl --output .pi/router/training.jsonl
+npm run router:gate-train -- --dataset .pi/router/training.train.jsonl --eval-dataset .pi/router/training.eval.jsonl --artifact .pi/router/binary-gate.json --report .pi/router/binary-gate-report.json
+npm run router:report -- --events .pi/router/events.jsonl --outcomes .pi/router/outcomes.jsonl --dataset .pi/router/training.eval.jsonl --gate-report .pi/router/binary-gate-report.json --output .pi/router/report.json --markdown .pi/router/report.md
+npm run router:sharpen -- --events .pi/router/events.jsonl --outcomes .pi/router/outcomes.jsonl --cards .pi/router/model-cards.jsonl --output .pi/router/sharpening-hints.json
 npm run router:shadow -- --checkpoint-file .pi/router/checkpoints.jsonl --ledger .pi/router/events.jsonl --output .pi/router/shadow-report.json
 
-# Live observe-only extension commands:
-# /router on|off|status|profile|profiles|models|configure|cycle
+# Live router extension commands:
+# /router status|help|on|off|mode|profile|print|profiles|models|configure|cycle
+# /router mode observe      # default: recommendations only
+# /router mode auto_model   # explicit: apply model switches only
+# /router profile spark-smart
+# /router print mismatch_only|all|off
 # ctrl+alt+p cycles router profiles (Ctrl-P is reserved by Pi model cycling).
 ```
 
 ## V1 telemetry notes
 
-Router v1 is still observe-only. It adds outcome skeletons, stronger diff/error fingerprints, teacher-label request export, binary gate dataset export, and subagent-aware telemetry schemas. It does not switch models, spawn agents, or promote policies automatically.
+Router v1 defaults to observe-only. It adds outcome skeletons, stronger diff/error fingerprints, teacher-label request export, binary gate dataset export, and subagent-aware telemetry schemas. It does not spawn agents/subagents or promote policies automatically. The explicit `auto_model` mode may only switch the active model for future turns.
 
-Live config is repo-global at `.pi/router/config.json`, while mutable live state and route ledgers are isolated per Pi session under `.pi/router/sessions/<session-key>/state.json` and `events.jsonl`.
+Live config is repo-global at `.pi/router/config.json`, while mutable live state and route ledgers are isolated per Pi session under `.pi/router/sessions/<session-key>/state.json` and `events.jsonl`. The default `mode` is `observe`; `auto_model` must be explicitly selected and does not alter agents, subagents, tools, or execution paths.
 
 - Diff telemetry stores counts and hashes from `git diff`, not raw patches. Offline rebuilds remain deterministic by default; use `--workspace-diff` only with one current live session/worktree snapshot.
+- `router:outcome-enrich` upgrades conservative outcome skeletons with checkpoint/event-derived verifier, rework, interruption, override, and accepted-diff signals.
 - Error fingerprints normalize paths, line numbers, timestamps, UUIDs, ports, and object ids before hashing.
-- `router:teacher-requests` writes local JSONL requests for an explicit teacher model; imported teacher decisions are still required before labels become training truth.
+- `router:teacher-requests` writes local JSONL requests for an explicit teacher model; `router:teacher-label` calls the explicitly configured teacher and writes decision/label JSONL artifacts.
 - `router:dataset` excludes `local-rule` labels by default so a future model does not merely imitate the current rules.
+- `router:gate-train` trains a local binary continue-vs-intervene gate and evaluates it on a distinct labeled eval dataset; local-rule labels are rejected as training/eval truth and promotion remains manual/eval-gated.
+- `router:report` writes JSON plus optional Markdown summaries across route ledgers, enriched outcomes, dataset labels, and gate evaluation reports.
+- `router:sharpen` writes local-only `pi-router.sharpening-hints.v1` recommendations from route ledgers, optional outcomes, and optional capability cards. Hints include sample-size/confidence/auto-use guardrails, repo-local learning policy, and provenance, but never mutate config or promote policy automatically.
+
+### Automated, upgrade-safe sharpening persistence
+
+Use this one-shot command for cron/background automation:
+
+```bash
+npm run router:sharpen:auto -- --workspace .
+```
+
+By default it stores artifacts at:
+
+- Linux/BSD: `<XDG_DATA_HOME || ~/.local/share>/pi-rogue-router/learning/<repo-name>-<hash>/`
+- macOS: `~/Library/Application Support/pi-rogue-router/learning/<repo-name>-<hash>/`
+
+The script:
+- writes `latest.json` and `history/*.json` artifacts;
+- writes `manifest.json` with source fingerprints for change detection;
+- skips re-computation if inputs are unchanged (unless `--force`);
+- migrates legacy `.pi/router/sharpening-hints.json` into the stable learning directory when present.
+
+Cron example:
+
+```bash
+*/30 * * * * cd /path/to/pi-rogue && npm run router:sharpen:auto -- --workspace /path/to/pi-rogue
+```
+
 - Subagent route/ledger schemas describe parent-child evidence flow, but live autonomous spawning remains out of scope.

package/node_modules/@fiale-plus/pi-rogue-router/src/binary-gate.test.ts

@@ -0,0 +1,88 @@
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { trainBinaryGate, writeBinaryGateTraining } from "./binary-gate.js";
+import type { RouterTrainingRow } from "./dataset.js";
+
+function tempFile(name: string): string {
+  return join(mkdtempSync(join(tmpdir(), "pi-router-gate-")), name);
+}
+
+function row(id: string, label: "continue" | "intervene" | "unknown", overrides: Partial<RouterTrainingRow["features"]> = {}, source: RouterTrainingRow["labels"]["source"] = label === "unknown" ? "unknown" : "teacher"): RouterTrainingRow {
+  return {
+    schema: "pi-router.training-row.v1",
+    checkpointId: id,
+    sessionId: "session-1",
+    rawSessionRef: { schema: "pi-router.raw-session-ref.v1", path: "/tmp/session.jsonl", fromEvent: 0, toEvent: 1, fromByte: 0, toByte: 1, contentHash: "hash" },
+    features: {
+      phase: "implementation",
+      activeModel: "qwen",
+      provider: "local",
+      contextTokensApprox: 1000,
+      sameCommandRepeatedCount: 1,
+      sameErrorRepeatedCount: 0,
+      loopScore: 0.1,
+      progressScore: 0.9,
+      verifierUsed: true,
+      noVerifierUsed: false,
+      diffLines: 10,
+      diffFilesChanged: 1,
+      diffChurnScore: 0.01,
+      filesTouched: 1,
+      ...overrides,
+    },
+    labels: { routeAction: label === "intervene" ? "run_verifier" : label === "continue" ? "continue_current" : null, binaryGate: label, source, confidence: label === "unknown" ? null : 0.8 },
+    outcome: { taskStatus: "unknown", testsPassedAfter: null, acceptedDiff: null, userOverrodeDecision: null, reworkTurns: null },
+    provenance: { localRuleAction: label === "intervene" ? "run_verifier" : "continue_current", excludedLocalRuleAsTruth: false },
+  };
+}
+
+describe("router binary gate training", () => {
+  it("trains a threshold artifact and reports candidate vs rule baseline", () => {
+    const rows = [
+      row("continue-1", "continue"),
+      row("intervene-1", "intervene", { phase: "debug", loopScore: 0.8, progressScore: 0.2, sameErrorRepeatedCount: 3, noVerifierUsed: true, verifierUsed: false }),
+      row("unknown-1", "unknown"),
+    ];
+
+    const evalRows = [
+      row("eval-continue-1", "continue"),
+      row("eval-intervene-1", "intervene", { phase: "debug", loopScore: 0.7, progressScore: 0.3, sameErrorRepeatedCount: 2 }),
+    ];
+
+    const { artifact, report } = trainBinaryGate(rows, evalRows, "2026-06-14T00:00:00.000Z");
+
+    expect(artifact).toMatchObject({ schema: "pi-router.binary-gate-artifact.v1", manualPromotionRequired: true, training: { rows: 3, labeledRows: 2 }, evaluation: { rows: 2, labeledRows: 2 } });
+    expect(report).toMatchObject({ schema: "pi-router.binary-gate-eval.v1", trainRows: 3, trainLabeledRows: 2, evalRows: 2, evalLabeledRows: 2, manualPromotionRequired: true });
+    expect(report.thresholdSweep.length).toBeGreaterThan(1);
+    expect(report.candidate.truePositive + report.candidate.trueNegative + report.candidate.falsePositive + report.candidate.falseNegative).toBe(2);
+  });
+
+  it("writes gate artifact and eval report", () => {
+    const input = tempFile("training.jsonl");
+    const evalInput = tempFile("eval.jsonl");
+    const artifact = tempFile("gate.json");
+    const report = tempFile("report.json");
+    writeFileSync(input, [
+      JSON.stringify(row("continue-1", "continue")),
+      JSON.stringify(row("intervene-1", "intervene", { loopScore: 0.9, progressScore: 0.1, noVerifierUsed: true })),
+    ].join("\n") + "\n");
+    writeFileSync(evalInput, [
+      JSON.stringify(row("eval-continue-1", "continue")),
+      JSON.stringify(row("eval-intervene-1", "intervene", { loopScore: 0.8, progressScore: 0.2, sameErrorRepeatedCount: 3 })),
+    ].join("\n") + "\n");
+
+    const summary = writeBinaryGateTraining({ trainingRowsPath: input, evalRowsPath: evalInput, artifactPath: artifact, reportPath: report });
+
+    expect(summary).toMatchObject({ schema: "pi-router.binary-gate-train-summary.v1", trainRows: 2, trainLabeledRows: 2, evalRows: 2, evalLabeledRows: 2 });
+    expect(JSON.parse(readFileSync(artifact, "utf8")).schema).toBe("pi-router.binary-gate-artifact.v1");
+    expect(JSON.parse(readFileSync(report, "utf8")).schema).toBe("pi-router.binary-gate-eval.v1");
+    expect(() => writeBinaryGateTraining({ trainingRowsPath: input, evalRowsPath: input, artifactPath: tempFile("bad-gate.json"), reportPath: tempFile("bad-report.json") })).toThrow(/distinct --eval-dataset/);
+  });
+
+  it("rejects unusable labels", () => {
+    expect(() => trainBinaryGate([row("rule-1", "continue", {}, "local-rule"), row("rule-2", "intervene", {}, "local-rule")], [row("eval-1", "continue"), row("eval-2", "intervene")])).toThrow(/no usable/);
+    expect(() => trainBinaryGate([row("only-continue", "continue")], [row("eval-1", "continue"), row("eval-2", "intervene")])).toThrow(/both continue and intervene/);
+  });
+});

package/node_modules/@fiale-plus/pi-rogue-router/src/binary-gate.ts

@@ -0,0 +1,232 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import type { BinaryGateLabel, RouterTrainingRow } from "./dataset.js";
+
+export const BINARY_GATE_ARTIFACT_SCHEMA = "pi-router.binary-gate-artifact.v1" as const;
+export const BINARY_GATE_EVAL_SCHEMA = "pi-router.binary-gate-eval.v1" as const;
+
+export interface BinaryGateArtifact {
+  schema: typeof BINARY_GATE_ARTIFACT_SCHEMA;
+  generatedAt: string;
+  policyVersion: string;
+  model: {
+    kind: "linear-threshold";
+    threshold: number;
+    weights: Record<string, number>;
+  };
+  training: {
+    rows: number;
+    labeledRows: number;
+    positiveIntervene: number;
+    negativeContinue: number;
+  };
+  evaluation: {
+    rows: number;
+    labeledRows: number;
+    positiveIntervene: number;
+    negativeContinue: number;
+  };
+  manualPromotionRequired: true;
+}
+
+export interface ConfusionMatrix {
+  truePositive: number;
+  trueNegative: number;
+  falsePositive: number;
+  falseNegative: number;
+}
+
+export interface BinaryGateEvalReport {
+  schema: typeof BINARY_GATE_EVAL_SCHEMA;
+  generatedAt: string;
+  policyVersion: string;
+  trainRows: number;
+  trainLabeledRows: number;
+  evalRows: number;
+  evalLabeledRows: number;
+  candidate: ConfusionMatrix & { accuracy: number; precision: number; recall: number; f1: number };
+  ruleBaseline: ConfusionMatrix & { accuracy: number; precision: number; recall: number; f1: number };
+  thresholdSweep: Array<{ threshold: number; trainAccuracy: number; trainF1: number; evalAccuracy: number; evalF1: number }>;
+  manualPromotionRequired: true;
+}
+
+export interface GateTrainSummary {
+  schema: "pi-router.binary-gate-train-summary.v1";
+  artifact: string;
+  report: string;
+  trainRows: number;
+  trainLabeledRows: number;
+  evalRows: number;
+  evalLabeledRows: number;
+  threshold: number;
+}
+
+function round(value: number): number {
+  return Number(value.toFixed(4));
+}
+
+export function readTrainingRows(path: string): RouterTrainingRow[] {
+  const resolved = resolve(path);
+  if (!existsSync(resolved)) throw new Error(`training rows file not found: ${path}`);
+  return readFileSync(resolved, "utf8")
+    .split("\n")
+    .filter((line) => line.trim())
+    .map((line, index) => {
+      const row = JSON.parse(line) as RouterTrainingRow;
+      if (row.schema !== "pi-router.training-row.v1") throw new Error(`invalid training row schema at ${path}:${index + 1}`);
+      return row;
+    });
+}
+
+function scoreRow(row: RouterTrainingRow): number {
+  const weights = DEFAULT_WEIGHTS;
+  const context = row.features.contextTokensApprox ? Math.min(row.features.contextTokensApprox / 100_000, 1) : 0;
+  const diff = Math.min(row.features.diffLines / 600, 1);
+  const repeatErrors = Math.min(row.features.sameErrorRepeatedCount / 4, 1);
+  const repeatCommands = Math.min(row.features.sameCommandRepeatedCount / 4, 1);
+  const noVerifier = row.features.noVerifierUsed ? 1 : 0;
+  const lowProgress = 1 - row.features.progressScore;
+  const phaseRisk = row.features.phase === "debug" || row.features.phase === "review" ? 0.15 : 0;
+  return Math.max(0, Math.min(1,
+    weights.bias
+    + weights.loopScore * row.features.loopScore
+    + weights.lowProgress * lowProgress
+    + weights.sameErrorRepeatedCount * repeatErrors
+    + weights.sameCommandRepeatedCount * repeatCommands
+    + weights.noVerifierUsed * noVerifier
+    + weights.diffLines * diff
+    + weights.contextPressure * context
+    + phaseRisk,
+  ));
+}
+
+const DEFAULT_WEIGHTS: Record<string, number> = {
+  bias: -0.08,
+  loopScore: 0.38,
+  lowProgress: 0.22,
+  sameErrorRepeatedCount: 0.18,
+  sameCommandRepeatedCount: 0.08,
+  noVerifierUsed: 0.16,
+  diffLines: 0.08,
+  contextPressure: 0.12,
+};
+
+function isIntervene(label: BinaryGateLabel): boolean | null {
+  if (label === "intervene") return true;
+  if (label === "continue") return false;
+  return null;
+}
+
+function ruleGate(row: RouterTrainingRow): BinaryGateLabel {
+  return row.provenance.localRuleAction === "continue_current" || row.provenance.localRuleAction === "continue_local" ? "continue" : "intervene";
+}
+
+function metrics(matrix: ConfusionMatrix): ConfusionMatrix & { accuracy: number; precision: number; recall: number; f1: number } {
+  const total = matrix.truePositive + matrix.trueNegative + matrix.falsePositive + matrix.falseNegative;
+  const precision = matrix.truePositive + matrix.falsePositive ? matrix.truePositive / (matrix.truePositive + matrix.falsePositive) : 0;
+  const recall = matrix.truePositive + matrix.falseNegative ? matrix.truePositive / (matrix.truePositive + matrix.falseNegative) : 0;
+  const f1 = precision + recall ? (2 * precision * recall) / (precision + recall) : 0;
+  return {
+    ...matrix,
+    accuracy: total ? round((matrix.truePositive + matrix.trueNegative) / total) : 0,
+    precision: round(precision),
+    recall: round(recall),
+    f1: round(f1),
+  };
+}
+
+function confusion(rows: RouterTrainingRow[], predict: (row: RouterTrainingRow) => BinaryGateLabel): ConfusionMatrix {
+  const matrix: ConfusionMatrix = { truePositive: 0, trueNegative: 0, falsePositive: 0, falseNegative: 0 };
+  for (const row of rows) {
+    const truth = isIntervene(row.labels.binaryGate);
+    if (truth === null) continue;
+    const predicted = predict(row) === "intervene";
+    if (truth && predicted) matrix.truePositive++;
+    else if (!truth && !predicted) matrix.trueNegative++;
+    else if (!truth && predicted) matrix.falsePositive++;
+    else matrix.falseNegative++;
+  }
+  return matrix;
+}
+
+function thresholdValues(): number[] {
+  return Array.from({ length: 19 }, (_, index) => round(0.05 + index * 0.05));
+}
+
+function usableLabeledRows(rows: RouterTrainingRow[], label: string): RouterTrainingRow[] {
+  const labeled = rows.filter((row) => row.labels.binaryGate !== "unknown" && row.labels.source !== "local-rule");
+  const positives = labeled.filter((row) => row.labels.binaryGate === "intervene").length;
+  const negatives = labeled.filter((row) => row.labels.binaryGate === "continue").length;
+  if (labeled.length === 0) throw new Error(`${label} dataset has no usable teacher/human labeled rows`);
+  if (positives === 0 || negatives === 0) throw new Error(`${label} dataset must contain both continue and intervene labels`);
+  return labeled;
+}
+
+function labelCounts(rows: RouterTrainingRow[]): { positiveIntervene: number; negativeContinue: number } {
+  return {
+    positiveIntervene: rows.filter((row) => row.labels.binaryGate === "intervene").length,
+    negativeContinue: rows.filter((row) => row.labels.binaryGate === "continue").length,
+  };
+}
+
+export function trainBinaryGate(trainRows: RouterTrainingRow[], evalRows: RouterTrainingRow[], generatedAt = new Date().toISOString()): { artifact: BinaryGateArtifact; report: BinaryGateEvalReport } {
+  const trainLabeled = usableLabeledRows(trainRows, "training");
+  const evalLabeled = usableLabeledRows(evalRows, "eval");
+  const trainSweep = thresholdValues().map((threshold) => {
+    const result = metrics(confusion(trainLabeled, (row) => scoreRow(row) >= threshold ? "intervene" : "continue"));
+    return { threshold, accuracy: result.accuracy, f1: result.f1 };
+  });
+  const best = trainSweep.reduce((winner, item) => item.f1 > winner.f1 || (item.f1 === winner.f1 && item.accuracy > winner.accuracy) ? item : winner, trainSweep[0]);
+  const policyVersion = `pi-router.binary-gate.v1.threshold-${best.threshold}`;
+  const trainCounts = labelCounts(trainLabeled);
+  const evalCounts = labelCounts(evalLabeled);
+  const thresholdSweep = thresholdValues().map((threshold) => {
+    const train = metrics(confusion(trainLabeled, (row) => scoreRow(row) >= threshold ? "intervene" : "continue"));
+    const evaluation = metrics(confusion(evalLabeled, (row) => scoreRow(row) >= threshold ? "intervene" : "continue"));
+    return { threshold, trainAccuracy: train.accuracy, trainF1: train.f1, evalAccuracy: evaluation.accuracy, evalF1: evaluation.f1 };
+  });
+  const artifact: BinaryGateArtifact = {
+    schema: BINARY_GATE_ARTIFACT_SCHEMA,
+    generatedAt,
+    policyVersion,
+    model: { kind: "linear-threshold", threshold: best.threshold, weights: DEFAULT_WEIGHTS },
+    training: { rows: trainRows.length, labeledRows: trainLabeled.length, ...trainCounts },
+    evaluation: { rows: evalRows.length, labeledRows: evalLabeled.length, ...evalCounts },
+    manualPromotionRequired: true,
+  };
+  const report: BinaryGateEvalReport = {
+    schema: BINARY_GATE_EVAL_SCHEMA,
+    generatedAt,
+    policyVersion,
+    trainRows: trainRows.length,
+    trainLabeledRows: trainLabeled.length,
+    evalRows: evalRows.length,
+    evalLabeledRows: evalLabeled.length,
+    candidate: metrics(confusion(evalLabeled, (row) => scoreRow(row) >= best.threshold ? "intervene" : "continue")),
+    ruleBaseline: metrics(confusion(evalLabeled, ruleGate)),
+    thresholdSweep,
+    manualPromotionRequired: true,
+  };
+  return { artifact, report };
+}
+
+export function writeBinaryGateTraining(options: { trainingRowsPath: string; evalRowsPath: string; artifactPath: string; reportPath: string }): GateTrainSummary {
+  const rows = readTrainingRows(options.trainingRowsPath);
+  const evalRows = readTrainingRows(options.evalRowsPath);
+  if (resolve(options.trainingRowsPath) === resolve(options.evalRowsPath)) throw new Error("gate training requires a distinct --eval-dataset file for out-of-sample evaluation");
+  const { artifact, report } = trainBinaryGate(rows, evalRows);
+  mkdirSync(dirname(resolve(options.artifactPath)), { recursive: true });
+  mkdirSync(dirname(resolve(options.reportPath)), { recursive: true });
+  writeFileSync(resolve(options.artifactPath), `${JSON.stringify(artifact, null, 2)}\n`);
+  writeFileSync(resolve(options.reportPath), `${JSON.stringify(report, null, 2)}\n`);
+  return {
+    schema: "pi-router.binary-gate-train-summary.v1",
+    artifact: resolve(options.artifactPath),
+    report: resolve(options.reportPath),
+    trainRows: rows.length,
+    trainLabeledRows: artifact.training.labeledRows,
+    evalRows: evalRows.length,
+    evalLabeledRows: artifact.evaluation.labeledRows,
+    threshold: artifact.model.threshold,
+  };
+}