@sema-agent/server 7.43.0 → 7.44.0

package/dist/plugins/memory-sync-store-pg.js

@@ -1,12 +1,10 @@
 import { pgSafeJsonStringify, pgProtocolJsonStringify } from "./pg-safe-json.js";
-import { assertMemoryScopeWidth } from "./memory-key-guards.js"; // #271 件1:scope 列宽写前守卫(engine 两表同守)
-/** Table names (single source). SAME names as the TiDB twin (the two dialects never share one DB). */
+import { assertMemoryScopeWidth } from "./memory-key-guards.js";
 export const PG_MEMORY_SYNC_TABLES = {
     syncCursor: "agent_memory_engine_sync_cursor",
     pushQueue: "agent_memory_engine_push_queue",
     history: "agent_memory_engine_history",
 };
-/** Idempotent DDL for the sync plane (PG dialect). Call once at startup. */
 export async function ensurePgMemorySyncSchema(query) {
     await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_SYNC_TABLES.syncCursor} (
     scope         varchar(190) COLLATE "C" NOT NULL,
@@ -24,18 +22,13 @@ export async function ensurePgMemorySyncSchema(query) {
     next_attempt_at_ms bigint       NOT NULL,
     last_error         text COLLATE "C"         NULL
   )`);
-    // Scan face (§1.2): the reaper/consumer sweeps by due time. Perf add-on, never correctness.
     await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_SYNC_TABLES.pushQueue}_next_attempt_ms ON ${PG_MEMORY_SYNC_TABLES.pushQueue} (next_attempt_at_ms)`);
 }
-/** jsonb defense: node-pg hands back parsed objects, but a text-typed round-trip (or a foreign
- *  writer) may yield a string — same posture as parseJson in run-store-sql.ts. */
 function fromJsonb(v) {
     if (typeof v === "string")
         return JSON.parse(v);
     return v;
 }
-/** node-pg returns bigint columns as strings (int8 overflows JS numbers in general; ours are epoch
- *  ms, safely within 2^53) — normalize defensively. */
 function toMs(v) {
     return typeof v === "number" ? v : Number(v);
 }
@@ -50,7 +43,6 @@ export class PgMemorySyncStore {
         }
         this.claimLeaseMs = lease;
     }
-    // ── cursors ────────────────────────────────────────────────────────────────
     async getCursor(scope, peer) {
         const res = await this.query(`SELECT base_revs, updated_at_ms FROM ${PG_MEMORY_SYNC_TABLES.syncCursor} WHERE scope = $1 AND peer = $2`, [scope, peer]);
         const row = res.rows[0];
@@ -64,44 +56,20 @@ export class PgMemorySyncStore {
         };
     }
     async putCursor(cursor) {
-        // #271 件1:scope 是 PK 的一半(varchar(190))——超宽此前落不可分类的裸 22001,而 MySQL-protocol
-        // twin 上同一份数据会**静默截断**成另一个盘的基线。两方言同点、同文案拒(engine 两表同守)。
         assertMemoryScopeWidth(cursor.scope);
-        // PK (scope,peer) is the table's ONLY unique key ⇒ ON CONFLICT has exactly one target, no
-        // hijack face (纪律:the entries-table ban on blind upserts does NOT apply here).
         await this.query(`INSERT INTO ${PG_MEMORY_SYNC_TABLES.syncCursor} (scope, peer, base_revs, updated_at_ms)
        VALUES ($1, $2, $3::jsonb, $4)
-       ON CONFLICT (scope, peer) DO UPDATE SET base_revs = EXCLUDED.base_revs, updated_at_ms = EXCLUDED.updated_at_ms`, 
-        // codex R11:baseRevs=对账基线(entry id→rev,协议数据)——有损改写=peer 收到的与库里存的
-        // 是两份 map,对账决策对着被改写的身份/rev 做。拒绝式(与 outbox/add/update 同族)。
-        [cursor.scope, cursor.peer, pgProtocolJsonStringify(cursor.baseRevs, "memory sync cursor baseRevs"), cursor.updatedAtMs]);
+       ON CONFLICT (scope, peer) DO UPDATE SET base_revs = EXCLUDED.base_revs, updated_at_ms = EXCLUDED.updated_at_ms`, [cursor.scope, cursor.peer, pgProtocolJsonStringify(cursor.baseRevs, "memory sync cursor baseRevs"), cursor.updatedAtMs]);
     }
-    // ── push queue ─────────────────────────────────────────────────────────────
     async enqueue(item) {
-        assertMemoryScopeWidth(item.scope); // #271 件1:出站队列行的 scope 截断 = 推给对端时说错了盘
-        // Plain INSERT, fail-loud on a duplicate id: the caller mints uuidv7 per enqueue, so a dup is a
-        // caller bug (or a replay the caller must decide about) — never silently absorbed here.
+        assertMemoryScopeWidth(item.scope);
         await this.query(`INSERT INTO ${PG_MEMORY_SYNC_TABLES.pushQueue} (id, scope, entry_id, payload, attempts, next_attempt_at_ms, last_error)
-       VALUES ($1, $2, $3, $4::jsonb, 0, $5, NULL)`, 
-        // codex R10:payload=协议数据(文档明言 verbatim;rev=内容哈希)——jsonb 列存不了脏值,但有损
-        // 改写=payload 与 rev 内部矛盾(消费端永拒/应用脏内容)。协议纪律:拒绝式(与 memory add/update
-        // 的 unstorable_bytes 同族;上游 add/update 已拒,此处=纵深防御)。
-        [item.id, item.scope, item.entryId, pgProtocolJsonStringify(item.payload, "memory outbox payload"), item.nextAttemptAtMs]);
+       VALUES ($1, $2, $3, $4::jsonb, 0, $5, NULL)`, [item.id, item.scope, item.entryId, pgProtocolJsonStringify(item.payload, "memory outbox payload"), item.nextAttemptAtMs]);
     }
     async claimDue(nowMs, limit) {
         if (limit <= 0)
             return [];
         const leasedUntilMs = nowMs + this.claimLeaseMs;
-        // ONE statement = one implicit transaction: SKIP LOCKED excludes claimers overlapping in time,
-        // the next_attempt_at_ms bump (lease) excludes everyone arriving after we commit. RETURNING gives
-        // the post-update row, so attempts/last_error are the pre-claim values (fail() is the only
-        // incrementer) and next_attempt_at_ms is the lease we just wrote.
-        // ⚠️ MATERIALIZED CTE, NOT `WHERE id IN (SELECT … LIMIT n FOR UPDATE SKIP LOCKED)`: the IN-subquery
-        // form lets the planner RESCAN the locking subquery (e.g. as a rescanned semi-join inner), and each
-        // rescan skips the rows the previous pass locked and picks the NEXT due ones — an over-claim beyond
-        // LIMIT. Plan-dependent ⇒ intermittent: caught live on the build-host test DB (claimDue(limit=2) returned
-        // 3 rows, serial single-claimer run — the "sync-store env flake" real root cause). AS MATERIALIZED
-        // (PG12+) pins one evaluation; UPDATE … FROM joins the pinned id set.
         const res = await this.query(`WITH due AS MATERIALIZED (
          SELECT id FROM ${PG_MEMORY_SYNC_TABLES.pushQueue}
          WHERE next_attempt_at_ms <= $1
@@ -126,19 +94,12 @@ export class PgMemorySyncStore {
         await this.query(`DELETE FROM ${PG_MEMORY_SYNC_TABLES.pushQueue} WHERE id = $1`, [id]);
     }
     async fail(id, error, nextAttemptAtMs) {
-        // attempts = attempts + 1 is SQL-atomic — a read-modify-write in JS would race a concurrent
-        // failer and lose increments (the attempt cap is the fail-loud stop, it must count honestly).
         await this.query(`UPDATE ${PG_MEMORY_SYNC_TABLES.pushQueue}
        SET attempts = attempts + 1, last_error = $2, next_attempt_at_ms = $3
        WHERE id = $1`, [id, error, nextAttemptAtMs]);
     }
 }
-/** Idempotent DDL for the history table (PG dialect). Separate from the sync-plane ensure so S5.1
- *  can wire the write point independently of the S4 sync wiring. */
 export async function ensurePgMemoryHistorySchema(query) {
-    // scope column = design-doc amendment (see MemoryHistoryAppendRow.scope). written_at_ms BIGINT
-    // (caller-injected epoch ms) instead of the draft's TIMESTAMP — the family's clock discipline
-    // (sync_cursors.updated_at_ms precedent; DB clocks never judge anything).
     await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_SYNC_TABLES.history} (
     id            char(36) COLLATE "C"     NOT NULL,
     rev           varchar(128) COLLATE "C" NOT NULL,
@@ -149,7 +110,6 @@ export async function ensurePgMemoryHistorySchema(query) {
     written_at_ms bigint       NOT NULL,
     PRIMARY KEY (id, rev)
   )`);
-    // countByScope / future per-scope export-with-history scan face. Perf add-on, never correctness.
     await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_SYNC_TABLES.history}_scope ON ${PG_MEMORY_SYNC_TABLES.history} (scope)`);
 }
 export class PgMemoryHistoryStore {
@@ -160,9 +120,6 @@ export class PgMemoryHistoryStore {
     async appendHistory(rows) {
         if (rows.length === 0)
             return;
-        // ONE multi-row INSERT (the batch is "one applyPatches commit's worth" — small). ON CONFLICT
-        // (id, rev) DO NOTHING = idempotent replay; PK is the table's ONLY unique key, so the conflict
-        // target is unambiguous (no hijack face — append-only, nothing is ever updated).
         const params = [];
         const tuples = rows.map((r, i) => {
             params.push(r.id, r.rev, r.prevRev ?? null, r.op, r.scope, r.snapshot === undefined || r.snapshot === null ? null : pgSafeJsonStringify(r.snapshot), r.writtenAtMs);
@@ -181,12 +138,10 @@ export class PgMemoryHistoryStore {
         return res.rows.map((r) => historyRowFrom(r));
     }
     async countByScope(scope) {
-        // COUNT(*) comes back as a bigint-string from node-pg — normalize (toMs posture).
         const res = await this.query(`SELECT COUNT(*) AS n FROM ${PG_MEMORY_SYNC_TABLES.history} WHERE scope = $1`, [scope]);
         return toMs(res.rows[0]?.n ?? 0);
     }
 }
-/** Shared row mapper (both dialects' SELECTs project the same column set). */
 export function historyRowFrom(r) {
     return {
         id: String(r.id),

package/dist/plugins/memory-sync-store-tidb.js

@@ -1,14 +1,10 @@
 import { historyRowFrom } from "./memory-sync-store-pg.js";
-import { assertMemoryScopeWidth } from "./memory-key-guards.js"; // #271 件1:scope 列宽写前守卫(engine 两表同守)
-/** Table names (single source) — SAME names as PG_MEMORY_SYNC_TABLES (the two dialects never share
- *  one database). */
+import { assertMemoryScopeWidth } from "./memory-key-guards.js";
 export const TIDB_MEMORY_SYNC_TABLES = {
     syncCursor: "agent_memory_engine_sync_cursor",
     pushQueue: "agent_memory_engine_push_queue",
     history: "agent_memory_engine_history",
 };
-/** Idempotent DDL for the sync plane (TiDB dialect). Call once at startup.
- *  Key budget: utf8mb4 = 4 bytes/char, index cap 3072 bytes ⇒ PK(scope,peer) = 380 chars = 1520 B ✓. */
 export async function ensureTiDBMemorySyncSchema(pool) {
     await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_SYNC_TABLES.syncCursor} (
     scope         VARCHAR(190) NOT NULL,
@@ -29,14 +25,11 @@ export async function ensureTiDBMemorySyncSchema(pool) {
     KEY idx_agent_memory_engine_push_queue_next_attempt_ms (next_attempt_at_ms)
   ) COLLATE utf8mb4_bin`);
 }
-/** JSON-column defense: mysql2 normally hands back parsed objects for JSON columns, but string
- *  shapes leak through (connection flags/proxies) — same posture as memory-engine-tidb.ts. */
 function fromJson(v) {
     if (typeof v === "string")
         return JSON.parse(v);
     return v;
 }
-/** BIGINT columns may arrive as string depending on driver flags — normalize defensively. */
 function toMs(v) {
     return typeof v === "number" ? v : Number(v);
 }
@@ -51,7 +44,6 @@ export class TiDBMemorySyncStore {
         }
         this.claimLeaseMs = lease;
     }
-    // ── cursors ────────────────────────────────────────────────────────────────
     async getCursor(scope, peer) {
         const [rows] = await this.pool.query(`SELECT base_revs, updated_at_ms FROM ${TIDB_MEMORY_SYNC_TABLES.syncCursor} WHERE scope = ? AND peer = ?`, [scope, peer]);
         const row = rows[0];
@@ -65,20 +57,13 @@ export class TiDBMemorySyncStore {
         };
     }
     async putCursor(cursor) {
-        // #271 件1:scope 是 PK 的一半(VARCHAR(190))——非严格 MySQL 的静默截断会把两个盘的同步基线
-        // 折叠成一行(对账基线互串),写前响亮拒(engine 两表同守;Pg twin 同注)。
         assertMemoryScopeWidth(cursor.scope);
-        // The table's ONLY unique key is PK(scope,peer) ⇒ ON DUPLICATE KEY UPDATE has exactly one
-        // possible trigger — no hijack face (the entries-table ban does NOT apply; see header).
         await this.pool.query(`INSERT INTO ${TIDB_MEMORY_SYNC_TABLES.syncCursor} (scope, peer, base_revs, updated_at_ms)
        VALUES (?, ?, ?, ?)
        ON DUPLICATE KEY UPDATE base_revs = VALUES(base_revs), updated_at_ms = VALUES(updated_at_ms)`, [cursor.scope, cursor.peer, JSON.stringify(cursor.baseRevs), cursor.updatedAtMs]);
     }
-    // ── push queue ─────────────────────────────────────────────────────────────
     async enqueue(item) {
-        assertMemoryScopeWidth(item.scope); // #271 件1:出站队列行的 scope 截断 = 推给对端时说错了盘
-        // Plain INSERT, fail-loud on a duplicate id (ER_DUP_ENTRY 1062) — caller mints uuidv7 per
-        // enqueue, a dup is a caller bug, never silently absorbed. Same posture as the PG twin.
+        assertMemoryScopeWidth(item.scope);
         await this.pool.query(`INSERT INTO ${TIDB_MEMORY_SYNC_TABLES.pushQueue} (id, scope, entry_id, payload, attempts, next_attempt_at_ms, last_error)
        VALUES (?, ?, ?, ?, 0, ?, NULL)`, [item.id, item.scope, item.entryId, JSON.stringify(item.payload), item.nextAttemptAtMs]);
     }
@@ -86,10 +71,6 @@ export class TiDBMemorySyncStore {
         if (limit <= 0)
             return [];
         const leasedUntilMs = nowMs + this.claimLeaseMs;
-        // Optimistic CAS claim (header rationale): read the due candidates, then win each row with a
-        // conditional UPDATE on the exact next_attempt_at_ms we read. Losers (another worker claimed, or
-        // fail()/a re-schedule moved the row) see affectedRows=0 and are skipped — the SKIP LOCKED
-        // equivalent, without pessimistic locks or a held connection.
         const [candidates] = await this.pool.query(`SELECT id, scope, entry_id, payload, attempts, next_attempt_at_ms, last_error
        FROM ${TIDB_MEMORY_SYNC_TABLES.pushQueue}
        WHERE next_attempt_at_ms <= ?
@@ -97,13 +78,11 @@ export class TiDBMemorySyncStore {
        LIMIT ?`, [nowMs, limit]);
         const claimed = [];
         for (const row of candidates) {
-            // affectedRows=CHANGED 语义坑防御:lease = nowMs + claimLeaseMs > nowMs ≥ 读到的 next_attempt_at_ms
-            // (WHERE 已保证),新值严格大于旧值 ⇒ 匹配必 change ⇒ affectedRows=1 恒等于「真的赢了」。
             const [res] = await this.pool.query(`UPDATE ${TIDB_MEMORY_SYNC_TABLES.pushQueue}
          SET next_attempt_at_ms = ?
          WHERE id = ? AND next_attempt_at_ms = ?`, [leasedUntilMs, row.id, toMs(row.next_attempt_at_ms)]);
             if (res.affectedRows !== 1)
-                continue; // lost the race — skip, never block
+                continue;
             claimed.push({
                 id: row.id,
                 scope: row.scope,
@@ -120,20 +99,12 @@ export class TiDBMemorySyncStore {
         await this.pool.query(`DELETE FROM ${TIDB_MEMORY_SYNC_TABLES.pushQueue} WHERE id = ?`, [id]);
     }
     async fail(id, error, nextAttemptAtMs) {
-        // attempts = attempts + 1 is SQL-atomic (never read-modify-write in JS); the increment also
-        // guarantees the row CHANGES — the claim verdict is honest under BOTH affectedRows semantics
-        // (mysql2 default = FOUND_ROWS/matched; changed-only would also work here).
         await this.pool.query(`UPDATE ${TIDB_MEMORY_SYNC_TABLES.pushQueue}
        SET attempts = attempts + 1, last_error = ?, next_attempt_at_ms = ?
        WHERE id = ?`, [error, nextAttemptAtMs, id]);
     }
 }
-// ── 142-S5 §1.3 — history table (tombstone + rev chain), TiDB dialect ───────────────────────────
-/** Idempotent DDL for the history table (TiDB dialect). Key budget: PK(id,rev) = CHAR(36)+
- *  VARCHAR(128) = 164 chars ≤ 3072-byte utf8mb4 index cap ✓; KEY(scope) = 190 chars ✓. */
 export async function ensureTiDBMemoryHistorySchema(pool) {
-    // scope column + written_at_ms BIGINT = the same design-doc amendments as the Pg twin (see
-    // MemoryHistoryAppendRow.scope / ensurePgMemoryHistorySchema).
     await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_SYNC_TABLES.history} (
     id            CHAR(36)     NOT NULL,
     rev           VARCHAR(128) NOT NULL,
@@ -154,9 +125,6 @@ export class TiDBMemoryHistoryStore {
     async appendHistory(rows) {
         if (rows.length === 0)
             return;
-        // ONE multi-row INSERT; dup (id,rev) replay = no-op via `ON DUPLICATE KEY UPDATE id = id`
-        // (header rationale: NOT INSERT IGNORE — IGNORE swallows non-dup errors too). PK(id,rev) is the
-        // only unique key ⇒ the ODKU trigger is unambiguous, and the "update" writes nothing.
         const params = [];
         for (const r of rows) {
             params.push(r.id, r.rev, r.prevRev ?? null, r.op, r.scope, r.snapshot === undefined || r.snapshot === null ? null : JSON.stringify(r.snapshot), r.writtenAtMs);

package/dist/plugins/outcome-ledger-sql.js

@@ -1,41 +1,5 @@
-/**
- * Outcome ledger (design/73 §7) — the read-only first step of grounded self-evolution. SINGLE-FILE
- * DUAL-DIALECT (design/158 A12 定型半场): ONE implementation, TWO dialects; the historical
- * `TiDBOutcomeLedger` / `PgOutcomeLedger` class names survive as thin ctor subclasses so every consumer
- * (store-backend.ts, pg-pool.ts, the unit + real-DB suites) is untouched.
- *
- * One row per graded task run, keyed by (taskSignature, model). v1 is STRICTLY READ-ONLY: it records
- * outcomes for a dashboard + as the dataset for an offline backtest (bandit vs fixed routing). It drives
- * NO automatic policy change — that is flag-gated and must first pass the offline-backtest gate
- * (council blocker 3 / major 7).
- *
- * 🔴 Signal-hardness split is the load-bearing invariant (council blocker 1): only `mechanical` fields
- * (oracle pass/total, build exits, mergeOk, cost, turns, route, replan) may ever drive an automatic
- * policy change. `llmAssisted` (stuck counts, verifier verdict+confidence) is dashboard-only, carried in
- * its own blob, never co-weighted with mechanical. `outcome` is DERIVED from mechanical fields ONLY.
- *
- * ── Dialect deltas, kept EXPLICIT ────────────────────────────────────────────────────────────────────
- *   - `?` placeholders vs `$n`                          - JSON columns bound `CAST(? AS JSON)`-free (TiDB
- *     stores the string verbatim) vs `$n::jsonb`
- *   - JSON encode: TiDB `JSON.stringify` verbatim vs PG `pgSafeJsonStringify` (deep NUL/lone-surrogate
- *     sanitize — a raw tool_result/core blob can carry bytes PG's text/jsonb columns reject, ERRCODE 22P05)
- *   - affected/SELECT rows via `result.rowCount` / `result.rows` (not RowDataPacket/ResultSetHeader) — via SqlDriver
- *   - BIGINT (cost_micro_usd) read back as a STRING by node-pg → wrapped in `Number(...)`
- *   - `AVG(outcome = 'pass')` (MySQL boolean→1/0) vs `AVG((outcome = 'pass')::int)` (PG has no boolean→int coercion)
- *   - merge_ok TINYINT(1) vs SMALLINT (0/1 in/out)       - DATETIME(3) vs TIMESTAMPTZ(3) (Date in/out)
- *   - schema ownership: TiDB DDL lives in tidb-pool.ts SCHEMA_STATEMENTS; the PG DDL is exported from HERE
- *     (`PG_OUTCOME_LEDGER_SCHEMA` + `ensurePgOutcomeLedgerSchema`) for pg-pool.ts + the integration test.
- *
- * Kept in lock-step across dialects by the shared real-DB integration suite
- * (test/pg-outcome-ledger-integration.test.ts, both engines run the SAME scenarios in parallel).
- */
 import { randomUUID, createHash } from "node:crypto";
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
-/**
- * v1 task-signature (council Q11, recommended candidate (a)): a deterministic structural hash — zero
- * embedder, coarse on purpose (routing is a coarse decision). An explicit `tag` short-circuits to the
- * tag itself (candidate (c)).
- */
 export function taskSignature(s) {
     if (s.tag)
         return `tag:${s.tag}`;
@@ -47,14 +11,7 @@ export function taskSignature(s) {
     });
     return `h:${createHash("sha256").update(canon).digest("hex").slice(0, 16)}`;
 }
-/**
- * Derive the coarse outcome from MECHANICAL fields only (council blocker 1: llmAssisted never participates).
- * pass = all hidden tests green AND both build exits 0 AND merge ok; fail = nothing graded green; else partial.
- */
 export function deriveOutcome(m, runStatus = "completed-graded") {
-    // An infra-aborted run never reached the grader — its 0/total is infra, not task quality. Don't let it
-    // read as "fail" (which a self-scheduler would mistake for task difficulty); mark it "aborted" so the
-    // backtest can exclude it (council blocker 3).
     if (runStatus === "infra-aborted")
         return "aborted";
     const oracleGreen = m.oracleTotal != null && m.oracleTotal > 0 && m.oraclePassed === m.oracleTotal;
@@ -62,24 +19,9 @@ export function deriveOutcome(m, runStatus = "completed-graded") {
     const mergeGreen = m.mergeOk !== false;
     if (oracleGreen && buildGreen && mergeGreen)
         return "pass";
-    // "partial" needs POSITIVE green evidence. An OMITTED mergeOk is non-evidence — counting it green (the
-    // pre-2026-07 behavior) made "fail" unreachable for any row without an explicit mergeOk:false, so a
-    // fully-red oracle read as "partial" (caught wiring the design/73 §1 bridge, whose rows carry no mergeOk).
     const anyGreen = oracleGreen || (m.oraclePassed != null && m.oraclePassed > 0) || m.mergeOk === true;
     return anyGreen ? "partial" : "fail";
 }
-/**
- * design/73 §1 → §7 bridge: project one CORE `TaskOutcome` fact (the `RunnerDeps.onTaskOutcome` seam,
- * core 1.226) onto a v1 ledger row. Lossless: the verbatim fact rides `core` → the `core_outcome` JSON
- * column (red-line ② `oracleHadRedRun` + the free-form oracle blob have no v1 columns); the mapped
- * mechanical fields keep the existing aggregate surface working. Mapping rules:
- *  - `signatureInputs.tag = o.taskSignature` — core already emits THE aggregation key, so the ledger's
- *    tag short-circuit adopts it verbatim (no re-derivation drift);
- *  - oracle counts: `oracle.oraclePassed/oracleTotal` when the harness supplied numeric counts, else the
- *    required `green` bit as 1/0 over 1 (an honest degenerate count, not a fabrication);
- *  - `runStatus` stays "completed-graded": core's red line ③ means emission only happens at a REAL
- *    mechanical-oracle terminal (an infra-aborted run never reaches the emit point).
- */
 export function coreOutcomeToLedgerRow(o) {
     const passed = typeof o.oracle?.oraclePassed === "number" ? o.oracle.oraclePassed : o.oracle?.green ? 1 : 0;
     const total = typeof o.oracle?.oracleTotal === "number" ? o.oracle.oracleTotal : 1;
@@ -87,8 +29,6 @@ export function coreOutcomeToLedgerRow(o) {
         taskId: o.runId.slice(0, 64),
         model: (o.model ?? "unknown").slice(0, 190),
         signatureInputs: {
-            // 🔴 `taskSignature()` prepends "tag:" → the final task_signature must fit VARCHAR(190).
-            // Cap the raw tag at 190 − len("tag:") = 186 so the prefixed key never overflows/truncates the column.
             tag: o.taskSignature.slice(0, 186),
             ...(o.signatureInputs?.toolset ? { toolset: o.signatureInputs.toolset } : {}),
             ...(o.signatureInputs?.targetLang ? { targetLang: o.signatureInputs.targetLang } : {}),
@@ -103,14 +43,6 @@ export function coreOutcomeToLedgerRow(o) {
         core: o,
     };
 }
-/**
- * PG translation of the `outcome_ledger` DDL in tidb-pool.ts SCHEMA_STATEMENTS:
- * JSON→JSONB, DATETIME(3)→TIMESTAMPTZ(3), TINYINT(1)→SMALLINT, INT→INTEGER, inline KEY→separate CREATE INDEX.
- * The table is DISJOINT from every other store's tables, so this self-contained set is safe (no shadowing).
- *
- * SCHEMA POLICY: see the header of pg-pool.ts — the code is the single source of truth, schema changes are
- * drop-and-recreate, and NO new `ALTER TABLE` seams are added here; fold into the CREATE instead.
- */
 export const PG_OUTCOME_LEDGER_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS outcome_ledger (
      id             VARCHAR(64) COLLATE "C"  NOT NULL,
@@ -142,44 +74,31 @@ export const PG_OUTCOME_LEDGER_SCHEMA = [
     `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_outcome ON outcome_ledger (outcome)`,
     `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_created ON outcome_ledger (created_at)`,
 ];
-/** Idempotent self-contained PG schema apply (for the integration test; central aggregation via pg-pool.ts). */
 export async function ensurePgOutcomeLedgerSchema(pool) {
     for (const stmt of PG_OUTCOME_LEDGER_SCHEMA)
         await pool.query(stmt);
 }
-/** Dual-dialect outcome ledger. See the file header for the dialect-delta ledger. */
 export class SqlOutcomeLedger {
     db;
     constructor(db) {
         this.db = db;
     }
-    /** Pick the dialect's SQL text. Both statements stay written out at the call site ON PURPOSE. */
     q(tidb, pg) {
         return this.db.dialect === "tidb" ? tidb : pg;
     }
-    /** JSON column encode: TiDB stores `JSON.stringify` verbatim; PG runs the deep NUL/lone-surrogate
-     *  sanitize (a raw tool_result/core blob can carry bytes PG's jsonb column rejects, ERRCODE 22P05) — this
-     *  store's blobs are observability/dashboard data, so the lossy (U+FFFD) sanitize is the right tier
-     *  (not the lossless envelope checkpoint-store-sql.ts uses for the approval trust boundary). */
     json(value) {
         return dialectJsonEncoder(this.db.dialect)(value);
     }
-    /** Record one graded task run. Idempotent only by row id; callers pass distinct runs. */
     async record(o) {
         const id = randomUUID().replace(/-/g, "").slice(0, 32);
         const sig = taskSignature(o.signatureInputs);
         const m = o.mechanical;
         const runStatus = o.runStatus ?? "completed-graded";
-        await this.db.query(this.q(
-        // 🔴 byte-for-byte preserved from tidb-outcome-ledger.ts (pre-collapse) — the parity harness
-        // diffs this literally, so its indentation is NOT reflowed to the new call-site nesting.
-        `INSERT INTO outcome_ledger
+        await this.db.query(this.q(`INSERT INTO outcome_ledger
         (id, task_signature, model, task_id, run_status, route, worker_count, oracle_passed, oracle_total,
          assemble_exit, lint_exit, merge_ok, replan_triggers, cost_micro_usd, turns, outcome,
          llm_assisted, signature_inputs, core_outcome, created_at)
-       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, 
-        // 🔴 byte-for-byte preserved from pg-outcome-ledger.ts (pre-collapse).
-        `INSERT INTO outcome_ledger
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, `INSERT INTO outcome_ledger
         (id, task_signature, model, task_id, run_status, route, worker_count, oracle_passed, oracle_total,
          assemble_exit, lint_exit, merge_ok, replan_triggers, cost_micro_usd, turns, outcome,
          llm_assisted, signature_inputs, core_outcome, created_at)
@@ -194,16 +113,9 @@ export class SqlOutcomeLedger {
         ]);
         return id;
     }
-    /** design/73 §1 seam consumption: record one CORE outcome fact (see {@link coreOutcomeToLedgerRow}). */
     async recordCore(o) {
         await this.record(coreOutcomeToLedgerRow(o));
     }
-    /**
-     * Read-only aggregate for the dashboard / offline backtest: pass-rate + mean cost per (signature, model).
-     * 🔴 Defaults to `completed-graded` rows ONLY — the route/budget-learning signal must exclude infra-aborted
-     * runs (council blocker 3: a basework death is not a task-difficulty signal). Pass
-     * `includeAborted: true` only for the infra-health view, never for training.
-     */
     async summary(opts = {}) {
         const clauses = [];
         const params = [];
@@ -211,14 +123,10 @@ export class SqlOutcomeLedger {
             clauses.push("run_status = 'completed-graded'");
         if (opts.taskSignature) {
             params.push(opts.taskSignature);
-            // 🔴 placeholder ARITY differs, not just the token: TiDB's `?` is positional-anonymous (always just
-            // "?"), while PG's `$n` must name the actual ordinal — `params.length` after the push IS that ordinal.
             clauses.push(this.q("task_signature = ?", `task_signature = $${params.length}`));
         }
         const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-        const { rows } = await this.db.query(this.q(
-        // 🔴 byte-for-byte preserved (both statements) — not reflowed to the new call-site nesting.
-        `SELECT task_signature, model, COUNT(*) n,
+        const { rows } = await this.db.query(this.q(`SELECT task_signature, model, COUNT(*) n,
               AVG(outcome = 'pass') pass_rate, AVG(cost_micro_usd) mean_cost
          FROM outcome_ledger ${where}
         GROUP BY task_signature, model
@@ -236,13 +144,11 @@ export class SqlOutcomeLedger {
         }));
     }
 }
-/** MySQL-protocol (TiDB) binding — historical class name + ctor shape preserved. */
 export class TiDBOutcomeLedger extends SqlOutcomeLedger {
     constructor(pool) {
         super(mysqlDriver(pool));
     }
 }
-/** PostgreSQL binding — historical class name + ctor shape preserved. */
 export class PgOutcomeLedger extends SqlOutcomeLedger {
     constructor(pool) {
         super(pgDriver(pool));