pi-harness-runtime 1.1.394 → 1.1.396

package/packages/jev-judge/tests/validation-ledger.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Tests for the validation ledger - the durable record of which tier ran.
+ *
+ * The ledger is the only mechanical answer to "did the final tier pass?", so
+ * it must survive malformed input, report the latest run of a tier and never
+ * throw into its caller.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	ValidationLedger,
+	defaultLedgerPath,
+	parseLedgerContent,
+	parseRunRecord,
+} from "../src/validation-ledger.js";
+import type { TodoItem } from "../src/todo-provider.js";
+
+let dir: string;
+let path: string;
+
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "validation-ledger-"));
+	path = join(dir, "validation-runs.jsonl");
+});
+
+afterEach(() => {
+	rmSync(dir, { recursive: true, force: true });
+});
+
+function itemWithPlan(metadata: Record<string, unknown>): TodoItem {
+	return {
+		id: 1,
+		subject: "staged work",
+		status: "in_progress",
+		metadata,
+	};
+}
+
+const PLAN = {
+	validationPlan: {
+		fast: { command: "bun test tests/fast", expectedDurationMs: 18_000, datasetSize: 100 },
+		full: { command: "bun test tests/full", expectedDurationMs: 2_400_000, datasetSize: 10_000 },
+		budgetMinutes: 90,
+		finalTierRequired: true,
+	},
+};
+
+describe("parseRunRecord", () => {
+	it("reads a complete record", () => {
+		const record = parseRunRecord(
+			JSON.stringify({
+				ts: "2026-10-24T00:00:00.000Z",
+				tier: "full",
+				status: "passed",
+				itemId: 3,
+				durationMs: 1200,
+			}),
+		);
+		expect(record?.tier).toBe("full");
+		expect(record?.status).toBe("passed");
+		expect(record?.itemId).toBe(3);
+		expect(record?.durationMs).toBe(1200);
+	});
+
+	it("rejects malformed lines", () => {
+		expect(parseRunRecord("")).toBeNull();
+		expect(parseRunRecord("not json")).toBeNull();
+		expect(parseRunRecord("[]")).toBeNull();
+		expect(parseRunRecord(JSON.stringify({ tier: "medium", status: "passed" }))).toBeNull();
+		expect(parseRunRecord(JSON.stringify({ tier: "fast", status: "weird" }))).toBeNull();
+	});
+});
+
+describe("parseLedgerContent", () => {
+	it("skips malformed lines and keeps the rest", () => {
+		const content = [
+			JSON.stringify({ ts: "2026-10-24T00:00:00.000Z", tier: "fast", status: "passed" }),
+			"garbage",
+			"",
+			JSON.stringify({ ts: "2026-10-24T00:01:00.000Z", tier: "full", status: "failed" }),
+		].join("\n");
+		const records = parseLedgerContent(content);
+		expect(records).toHaveLength(2);
+		expect(records[1].tier).toBe("full");
+	});
+});
+
+describe("ValidationLedger", () => {
+	it("writes NDJSON that can be read back", () => {
+		const ledger = new ValidationLedger({ path });
+		ledger.record({ tier: "fast", status: "passed", itemId: 1, durationMs: 500 });
+
+		const raw = readFileSync(path, "utf-8");
+		expect(raw.trim().split("\n")).toHaveLength(1);
+		expect(JSON.parse(raw.trim()).tier).toBe("fast");
+		expect(ledger.read()).toHaveLength(1);
+	});
+
+	it("keeps only the runs of the requested item", () => {
+		const ledger = new ValidationLedger({ path });
+		ledger.record({ tier: "fast", status: "passed", itemId: 1 });
+		ledger.record({ tier: "fast", status: "passed", itemId: 2 });
+		expect(ledger.runsFor(1)).toHaveLength(1);
+		expect(ledger.runsFor(3)).toHaveLength(0);
+	});
+
+	it("returns the latest run of a tier", () => {
+		const ledger = new ValidationLedger({ path });
+		ledger.record({ tier: "fast", status: "failed", itemId: 1, ts: "2026-10-24T00:00:00.000Z" });
+		ledger.record({ tier: "fast", status: "passed", itemId: 1, ts: "2026-10-24T00:05:00.000Z" });
+		const latest = ledger.latestFor(1, "fast");
+		expect(latest?.status).toBe("passed");
+	});
+
+	it("mirrors every record to the sink", () => {
+		const mirrored: string[] = [];
+		const ledger = new ValidationLedger({ path, onRecord: (r) => mirrored.push(r.tier) });
+		ledger.record({ tier: "fast", status: "passed", itemId: 1 });
+		ledger.record({ tier: "full", status: "passed", itemId: 1 });
+		expect(mirrored).toEqual(["fast", "full"]);
+	});
+
+	it("never throws when the sink throws", () => {
+		const ledger = new ValidationLedger({
+			path,
+			onRecord: () => {
+				throw new Error("sink is broken");
+			},
+		});
+		expect(() => ledger.record({ tier: "fast", status: "passed", itemId: 1 })).not.toThrow();
+		expect(ledger.read()).toHaveLength(1);
+	});
+
+	it("rotates the file when it grows past the limit", () => {
+		const ledger = new ValidationLedger({ path, maxBytes: 200 });
+		for (let i = 0; i < 10; i++) {
+			ledger.record({ tier: "fast", status: "passed", itemId: i, note: "x".repeat(50) });
+		}
+		expect(existsSync(`${path}.1`)).toBe(true);
+	});
+
+	it("reports a pending final tier until the full tier passed", () => {
+		const ledger = new ValidationLedger({ path });
+		const item = itemWithPlan(PLAN);
+
+		expect(ledger.stateFor(item).finalTierPending).toBe(true);
+		expect(ledger.isFinalTierPending(item)).toBe(true);
+
+		ledger.record({ tier: "fast", status: "passed", itemId: 1 });
+		expect(ledger.stateFor(item).finalTierPending).toBe(true);
+
+		ledger.record({ tier: "full", status: "failed", itemId: 1 });
+		expect(ledger.stateFor(item).finalTierPending).toBe(true);
+
+		ledger.record({ tier: "full", status: "passed", itemId: 1 });
+		expect(ledger.stateFor(item).finalTierPending).toBe(false);
+		expect(ledger.stateFor(item).full.status).toBe("passed");
+	});
+
+	it("reports no pending tier for an item without a plan", () => {
+		const ledger = new ValidationLedger({ path });
+		const item: TodoItem = { id: 9, subject: "plain", status: "in_progress" };
+		const state = ledger.stateFor(item);
+		expect(state.hasPlan).toBe(false);
+		expect(state.finalTierPending).toBe(false);
+	});
+
+	it("survives a truncated file", () => {
+		writeFileSync(path, '{"ts":"2026-10-24T00:00:00.000Z","tier":"fast","status":"passed"}\n{"ts":"2026-10-2');
+		const ledger = new ValidationLedger({ path });
+		expect(ledger.read()).toHaveLength(1);
+	});
+
+	it("uses a default path under the harness home", () => {
+		expect(defaultLedgerPath()).toContain(".pi-harness-runtime");
+		expect(defaultLedgerPath().endsWith("validation-runs.jsonl")).toBe(true);
+	});
+});

package/packages/jev-judge/tests/validation-plan.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Tests for the staged validation plan.
+ *
+ * The plan is what lets the harness say "run the cheap tier while the code
+ * changes, run the expensive tier once at the end" instead of letting the
+ * agent repeat a 40 minute regression after every fix.
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	parseValidationPlan,
+	formatValidationContext,
+	buildValidationSteerSuffix,
+	parseDurationMs,
+	formatDuration,
+	parseTier,
+} from "../src/validation-plan.js";
+import type { TodoItem } from "../src/todo-provider.js";
+
+function item(metadata?: Record<string, unknown>): TodoItem {
+	return {
+		id: 1,
+		subject: "seed data",
+		status: "in_progress",
+		metadata,
+	};
+}
+
+describe("parseValidationPlan", () => {
+	it("returns null when the todo declares no plan", () => {
+		expect(parseValidationPlan(item())).toBeNull();
+		expect(parseValidationPlan(item({ other: "value" }))).toBeNull();
+		expect(parseValidationPlan(null)).toBeNull();
+	});
+
+	it("parses object tiers with cost and dataset size", () => {
+		const plan = parseValidationPlan(
+			item({
+				validationPlan: {
+					fast: { command: "bun test fast", expectedDurationMs: 18000, datasetSize: 100 },
+					full: { command: "bun test full", expectedDurationMs: 2400000, datasetSize: 10000 },
+				},
+			}),
+		);
+		expect(plan?.fast?.command).toBe("bun test fast");
+		expect(plan?.fast?.expectedDurationMs).toBe(18000);
+		expect(plan?.fast?.datasetSize).toBe(100);
+		expect(plan?.full?.expectedDurationMs).toBe(2400000);
+	});
+
+	it("parses plain command strings as tiers", () => {
+		const plan = parseValidationPlan(
+			item({ validationPlan: { fast: "bun test fast", full: "bun test full" } }),
+		);
+		expect(plan?.fast?.command).toBe("bun test fast");
+		expect(plan?.full?.command).toBe("bun test full");
+	});
+
+	it("parses flat command aliases and duration strings", () => {
+		const plan = parseValidationPlan(
+			item({ validationPlan: { fastCommand: "bun test fast", fullCommand: "bun test full", budgetMinutes: 90 } }),
+		);
+		expect(plan?.fast?.command).toBe("bun test fast");
+		expect(plan?.full?.command).toBe("bun test full");
+		expect(plan?.budgetMinutes).toBe(90);
+	});
+
+	it("reads a duration given as a string", () => {
+		const plan = parseValidationPlan(
+			item({ validationPlan: { full: { command: "bun test full", expectedDuration: "40m" } } }),
+		);
+		expect(plan?.full?.expectedDurationMs).toBe(40 * 60 * 1000);
+	});
+
+	it("keeps finalTierRequired and notes", () => {
+		const plan = parseValidationPlan(
+			item({
+				validationPlan: {
+					fast: "bun test fast",
+					full: "bun test full",
+					finalTierRequired: true,
+					notes: "fast tier must cover the aggregate query",
+				},
+			}),
+		);
+		expect(plan?.finalTierRequired).toBe(true);
+		expect(plan?.notes).toBe("fast tier must cover the aggregate query");
+	});
+
+	it("returns null for a plan that declares nothing usable", () => {
+		expect(parseValidationPlan(item({ validationPlan: { fast: {} } }))).toBeNull();
+		expect(parseValidationPlan(item({ validationPlan: "not an object" }))).toBeNull();
+	});
+});
+
+describe("duration helpers", () => {
+	it("parses explicit units", () => {
+		expect(parseDurationMs("45s")).toBe(45_000);
+		expect(parseDurationMs("40m")).toBe(2_400_000);
+		expect(parseDurationMs("1h")).toBe(3_600_000);
+		expect(parseDurationMs("1h30m")).toBe(5_400_000);
+		expect(parseDurationMs("garbage")).toBeUndefined();
+		expect(parseDurationMs("")).toBeUndefined();
+	});
+
+	it("treats a bare number below 1000 as seconds", () => {
+		expect(parseDurationMs(45)).toBe(45_000);
+		expect(parseDurationMs(45_000)).toBe(45_000);
+	});
+
+	it("formats durations for a status line", () => {
+		expect(formatDuration(18_000)).toBe("18s");
+		expect(formatDuration(2_400_000)).toBe("40m");
+		expect(formatDuration(5_400_000)).toBe("1h 30m");
+		expect(formatDuration(3_600_000)).toBe("1h");
+	});
+});
+
+describe("parseTier", () => {
+	it("ignores empty tiers", () => {
+		expect(parseTier("", "fast")).toBeUndefined();
+		expect(parseTier({}, "fast")).toBeUndefined();
+		expect(parseTier(undefined, "fast")).toBeUndefined();
+	});
+
+	it("keeps a label-only tier", () => {
+		const tier = parseTier({ label: "unit tests" }, "fast");
+		expect(tier?.label).toBe("unit tests");
+	});
+});
+
+describe("formatValidationContext", () => {
+	it("is empty when there is no plan", () => {
+		expect(formatValidationContext({})).toBe("");
+		expect(buildValidationSteerSuffix(item())).toBe("");
+	});
+
+	it("states both tiers and the staged rule", () => {
+		const plan = parseValidationPlan(
+			item({
+				validationPlan: {
+					fast: { command: "bun test fast", expectedDurationMs: 18_000, datasetSize: 100 },
+					full: { command: "bun test full", expectedDurationMs: 2_400_000, datasetSize: 10_000 },
+					finalTierRequired: true,
+				},
+			}),
+		);
+		const text = formatValidationContext(plan!);
+		expect(text).toContain("fast=");
+		expect(text).toContain("full=");
+		expect(text).toContain("bun test fast");
+		expect(text).toContain("~18s");
+		expect(text).toContain("100 records");
+		expect(text).toContain("bun test full");
+		expect(text).toContain("~40m");
+		expect(text).toContain("10000 records");
+		expect(text).toContain("Run the fast tier after every edit");
+		expect(text).toContain("do not complete this todo");
+	});
+
+	it("reports the remaining budget", () => {
+		const plan = parseValidationPlan(
+			item({ validationPlan: { fast: "bun test fast", budgetMinutes: 90 } }),
+		);
+		const text = formatValidationContext(plan!, { elapsedMs: 12 * 60 * 1000 });
+		expect(text).toContain("Time budget: 90m");
+		expect(text).toContain("elapsed 12m");
+		expect(text).toContain("remaining 1h 18m");
+	});
+});

package/packages/jev-judge/tests/validation-tie-breaker.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Tests for the validation tie-breaker - the typed verdict that decides
+ * whether an item may count as done.
+ */
+
+import { describe, it, expect } from "bun:test";
+import { tieBreakValidation, formatTieBreaker } from "../src/validation-tie-breaker.js";
+import { summarizeValidationState } from "../src/validation-plan.js";
+import type { TodoItem } from "../src/todo-provider.js";
+
+const item: TodoItem = {
+	id: 4,
+	subject: "staged work",
+	status: "in_progress",
+	metadata: {
+		validationPlan: {
+			fast: { command: "bun test tests/fast" },
+			full: { command: "bun test tests/full" },
+			finalTierRequired: true,
+		},
+	},
+};
+
+const plan = {
+	fast: { kind: "fast" as const, command: "bun test tests/fast" },
+	full: { kind: "full" as const, command: "bun test tests/full" },
+	finalTierRequired: true,
+};
+
+describe("tieBreakValidation", () => {
+	it("reports no-plan for an item without a plan", () => {
+		const state = summarizeValidationState(null, []);
+		const verdict = tieBreakValidation({ id: 1, subject: "plain", status: "in_progress" }, state);
+		expect(verdict.verdict).toBe("no-plan");
+		expect(verdict.blocksCompletion).toBe(false);
+	});
+
+	it("blocks the completion while the final tier did not run", () => {
+		const state = summarizeValidationState(plan, []);
+		const verdict = tieBreakValidation(item, state);
+		expect(verdict.verdict).toBe("final-tier-pending");
+		expect(verdict.blocksCompletion).toBe(true);
+		expect(verdict.reason).toContain("has not run");
+	});
+
+	it("blocks the completion when the final tier failed", () => {
+		const state = summarizeValidationState(plan, [
+			{ ts: "2026-10-24T00:00:00.000Z", tier: "full", status: "failed" },
+		]);
+		const verdict = tieBreakValidation(item, state);
+		expect(verdict.verdict).toBe("final-tier-failed");
+		expect(verdict.blocksCompletion).toBe(true);
+		expect(verdict.tierStatus).toBe("failed");
+	});
+
+	it("allows the completion when the final tier passed", () => {
+		const state = summarizeValidationState(plan, [
+			{ ts: "2026-10-24T00:00:00.000Z", tier: "full", status: "passed" },
+		]);
+		const verdict = tieBreakValidation(item, state);
+		expect(verdict.verdict).toBe("complete");
+		expect(verdict.blocksCompletion).toBe(false);
+	});
+
+	it("allows the completion when no final tier is required", () => {
+		const state = summarizeValidationState(
+			{ fast: { kind: "fast", command: "bun test tests/fast" } },
+			[],
+		);
+		const verdict = tieBreakValidation(item, state);
+		expect(verdict.verdict).toBe("complete");
+		expect(verdict.blocksCompletion).toBe(false);
+	});
+
+	it("flags a plan that requires a final tier but declares none", () => {
+		const state = summarizeValidationState({ finalTierRequired: true }, []);
+		const verdict = tieBreakValidation(item, state);
+		expect(verdict.verdict).toBe("plan-incomplete");
+		expect(verdict.blocksCompletion).toBe(true);
+	});
+
+	it("formats the verdict for a log line", () => {
+		const state = summarizeValidationState(plan, []);
+		const verdict = tieBreakValidation(item, state);
+		expect(formatTieBreaker(verdict)).toContain("staged work");
+		expect(formatTieBreaker(verdict)).toContain("final-tier-pending");
+	});
+});

package/packages/knowledge-graph/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/knowledge-graph",
-  "version": "1.1.394",
+  "version": "1.1.396",
   "description": "Knowledge Graph extraction and provenance linking for SKILL.md files",
   "type": "module",
   "main": "./dist/index.js",

package/packages/knowledge-retrieval/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/knowledge-retrieval",
-  "version": "1.1.394",
+  "version": "1.1.396",
   "description": "Knowledge retrieval via TencentDB-Agent-Memory MCP (RFC-0105)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/laravel-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/laravel-plugin",
-  "version": "1.1.394",
+  "version": "1.1.396",
   "description": "Laravel framework analysis — artisan commands, Eloquent models, Blade",
   "type": "module",
   "main": "./dist/index.js",

package/packages/learning-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/learning-engine",
-  "version": "1.1.394",
+  "version": "1.1.396",
   "description": "Learning engine for extracting lessons from runtime execution (RFC-0058)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/logging/README.md

@@ -0,0 +1,37 @@
+# @pi-harness/logging
+
+Centralized structured application logging for pi-harness.
+
+```text
+producer -> redact -> sample -> buffer -> R2 -> webhook -> local spool
+```
+
+- **Redaction**: credential-looking keys, bearer tokens, JWTs and long token runs are
+  replaced; strings are truncated and structures are depth limited.
+- **Sampling**: minimum level, a deterministic sample rate for `debug` records and a
+  per source+event rate limit. Errors are never sampled away.
+- **Buffering**: bounded in-memory buffer; when it is full the least severe record is
+  dropped and the drop is counted.
+- **Delivery**: transports are tried in order (R2, webhook). If all of them fail the
+  batch is spooled to disk as NDJSON and retried on the next flush.
+
+## Usage
+
+```ts
+import { centralInfo, centralWarn, initCentralLogging } from "./packages/logging/dist/index.js";
+
+initCentralLogging();                       // reads the environment and the key files
+centralInfo("harness", "startup", "ready", { pid: process.pid });
+```
+
+## Transports
+
+| Transport | Purpose |
+|-----------|---------|
+| `createR2Transport` | Cloudflare R2 (S3 API), gzipped NDJSON under a date prefix |
+| `createWebhookTransport` | HTTP POST to the unified webhook server (`/api/logs`) |
+| `LogSpool` | Local NDJSON fallback, rotated by size, with retention |
+
+## Configuration
+
+See the "Centralized Application Logging" section in the repository `AGENTS.md`.

package/packages/logging/dist/buffer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * In-memory batching buffer for the centralized log pipeline.
+ *
+ * The buffer is bounded on purpose: a logging subsystem must never be the
+ * reason a process runs out of memory. When the buffer is full the LEAST
+ * severe record is dropped first, and the drop is counted so the loss is
+ * visible instead of silent.
+ */
+import { type LogRecord } from "./types.js";
+export interface LogBufferOptions {
+    /** Maximum number of records held in memory. Default 1000. */
+    maxSize?: number;
+    /** Maximum number of records per batch. Default 100. */
+    maxBatchSize?: number;
+}
+export declare class LogBuffer {
+    private readonly records;
+    private readonly maxSize;
+    private readonly maxBatchSize;
+    private droppedCount;
+    constructor(options?: LogBufferOptions);
+    get size(): number;
+    get dropped(): number;
+    get batchSize(): number;
+    push(record: LogRecord): void;
+    /** Remove and return up to `maxBatchSize` of the oldest records. */
+    takeBatch(maxBatchSize?: number): LogRecord[];
+    /** Peek without removing (used by the synchronous exit path). */
+    peekAll(): LogRecord[];
+    clear(): void;
+    private dropLowestSeverity;
+}
+//# sourceMappingURL=buffer.d.ts.map

package/packages/logging/dist/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../src/buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAsB,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAChC,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,SAAS;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,YAAY,CAAK;IAEzB,YAAY,OAAO,GAAE,gBAAqB,EAGzC;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAK5B;IAED,oEAAoE;IACpE,SAAS,CAAC,YAAY,GAAE,MAA0B,GAAG,SAAS,EAAE,CAG/D;IAED,iEAAiE;IACjE,OAAO,IAAI,SAAS,EAAE,CAErB;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,OAAO,CAAC,kBAAkB;CAa1B"}

package/packages/logging/dist/buffer.js

@@ -0,0 +1,60 @@
+/**
+ * In-memory batching buffer for the centralized log pipeline.
+ *
+ * The buffer is bounded on purpose: a logging subsystem must never be the
+ * reason a process runs out of memory. When the buffer is full the LEAST
+ * severe record is dropped first, and the drop is counted so the loss is
+ * visible instead of silent.
+ */
+import { LOG_LEVEL_SEVERITY } from "./types.js";
+export class LogBuffer {
+    records = [];
+    maxSize;
+    maxBatchSize;
+    droppedCount = 0;
+    constructor(options = {}) {
+        this.maxSize = Math.max(1, options.maxSize ?? 1000);
+        this.maxBatchSize = Math.max(1, options.maxBatchSize ?? 100);
+    }
+    get size() {
+        return this.records.length;
+    }
+    get dropped() {
+        return this.droppedCount;
+    }
+    get batchSize() {
+        return this.maxBatchSize;
+    }
+    push(record) {
+        if (this.records.length >= this.maxSize) {
+            this.dropLowestSeverity();
+        }
+        this.records.push(record);
+    }
+    /** Remove and return up to `maxBatchSize` of the oldest records. */
+    takeBatch(maxBatchSize = this.maxBatchSize) {
+        const count = Math.min(Math.max(0, maxBatchSize), this.records.length);
+        return this.records.splice(0, count);
+    }
+    /** Peek without removing (used by the synchronous exit path). */
+    peekAll() {
+        return [...this.records];
+    }
+    clear() {
+        this.records.length = 0;
+    }
+    dropLowestSeverity() {
+        let index = 0;
+        let lowest = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < this.records.length; i++) {
+            const severity = LOG_LEVEL_SEVERITY[this.records[i].level];
+            if (severity < lowest) {
+                lowest = severity;
+                index = i;
+            }
+        }
+        this.records.splice(index, 1);
+        this.droppedCount++;
+    }
+}
+//# sourceMappingURL=buffer.js.map

package/packages/logging/dist/buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.js","sourceRoot":"","sources":["../src/buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,kBAAkB,EAAkB,MAAM,YAAY,CAAC;AAShE,MAAM,OAAO,SAAS;IACJ,OAAO,GAAgB,EAAE,CAAC;IAC1B,OAAO,CAAS;IAChB,YAAY,CAAS;IAC9B,YAAY,GAAG,CAAC,CAAC;IAEzB,YAAY,OAAO,GAAqB,EAAE;QACzC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC;QACpD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,IAAI,GAAG,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,IAAI;QACP,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAC5B,CAAC;IAED,IAAI,OAAO;QACV,OAAO,IAAI,CAAC,YAAY,CAAC;IAC1B,CAAC;IAED,IAAI,SAAS;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC;IAC1B,CAAC;IAED,IAAI,CAAC,MAAiB;QACrB,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACzC,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3B,CAAC;IAED,oEAAoE;IACpE,SAAS,CAAC,YAAY,GAAW,IAAI,CAAC,YAAY;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACvE,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,iEAAiE;IACjE,OAAO;QACN,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAED,KAAK;QACJ,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;IACzB,CAAC;IAEO,kBAAkB;QACzB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,MAAM,GAAG,MAAM,CAAC,iBAAiB,CAAC;QACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,MAAM,QAAQ,GAAG,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YAC3D,IAAI,QAAQ,GAAG,MAAM,EAAE,CAAC;gBACvB,MAAM,GAAG,QAAQ,CAAC;gBAClB,KAAK,GAAG,CAAC,CAAC;YACX,CAAC;QACF,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC9B,IAAI,CAAC,YAAY,EAAE,CAAC;IACrB,CAAC;CACD"}

package/packages/logging/dist/config.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Configuration for the centralized log pipeline.
+ *
+ * Resolution order for credentials:
+ *   environment variable -> key file in ~/.pi-harness-runtime/keys
+ *
+ * Secrets are never hardcoded here. A key file that is missing simply means
+ * the corresponding transport is not configured.
+ */
+import type { LogBufferOptions } from "./buffer.js";
+import type { SamplingPolicy } from "./sampler.js";
+import type { LogTransport } from "./types.js";
+export type LogSinkMode = "off" | "auto" | "r2" | "webhook" | "r2+webhook";
+export interface LogSinkConfig {
+    /** False when nothing should be shipped (no transports, no spool). */
+    enabled: boolean;
+    /** Application name reported with every batch. */
+    app: string;
+    /** Transports in delivery priority order. */
+    transports: LogTransport[];
+    /** Directory of the local spool (undefined when logging is off). */
+    spoolDir?: string;
+    sampling: Partial<SamplingPolicy>;
+    buffer: LogBufferOptions;
+    flushIntervalMs: number;
+    /** Human readable notes about what was enabled and why. */
+    notes: string[];
+}
+export interface ResolveConfigOptions {
+    env?: Record<string, string | undefined>;
+    /** Directory holding the credential key files. */
+    keysDir?: string;
+}
+export declare function defaultKeysDir(): string;
+export declare function defaultSpoolDir(): string;
+/**
+ * Build the log sink configuration from the environment and the key files.
+ */
+export declare function resolveLogSinkConfig(options?: ResolveConfigOptions): LogSinkConfig;
+//# sourceMappingURL=config.d.ts.map

package/packages/logging/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,CAAC;AAE3E,MAAM,WAAW,aAAa;IAC7B,sEAAsE;IACtE,OAAO,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,UAAU,EAAE,YAAY,EAAE,CAAC;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IAClC,MAAM,EAAE,gBAAgB,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACzC,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAoBD,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,oBAAyB,GAAG,aAAa,CA0FtF"}