attention-manifest-protocol 0.4.2 → 0.4.3

package/tools/annotation-server.ts

@@ -1,230 +0,0 @@
-#!/usr/bin/env node
-/**
- * Local annotation UI. Two annotators open separate URLs, label with 1/2/3,
- * and the server writes one JSONL row per case (last write wins).
- */
-import { createServer } from "node:http";
-import type { IncomingMessage, Server, ServerResponse } from "node:http";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import type { AddressInfo } from "node:net";
-import { pathToFileURL } from "node:url";
-
-interface CampaignRow {
-    caseId: string;
-    source: string;
-    input: string;
-    answer: string;
-    expected: string;
-}
-
-interface LabelRow {
-    caseId: string;
-    annotator: string;
-    label: string;
-    note?: string;
-}
-
-export interface AnnotationServerOptions {
-    annotator: string;
-    port: number;
-    campaignPath?: string;
-    outputPath?: string;
-}
-
-export interface AnnotationServer {
-    server: Server;
-    url: string;
-    close: () => Promise<void>;
-}
-
-type CasePayload = {
-    caseId: string;
-    source: string;
-    input: string;
-    answer: string;
-    expected: string;
-    annotator?: string;
-    label?: string;
-    note: string;
-};
-
-type ParsedLabel = {
-    caseId?: string;
-    label?: string;
-    note?: string;
-};
-
-type SendResponse = (response: ServerResponse, status: number, body: string, type?: string) => void;
-
-type AnnotationServerFactory = (options: AnnotationServerOptions) => Promise<AnnotationServer>;
-
-const loadCsvRows: (path: string) => CampaignRow[] = (path: string): CampaignRow[] => {
-    const raw: string = readFileSync(path, "utf8");
-    const lines: string[] = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
-    if (lines.length === 0) {
-        return [];
-    }
-    const records: string[][] = [];
-    let record: string[] = [];
-    let cell: string = "";
-    let quoted: boolean = false;
-    for (let index: number = 0; index < raw.length; index += 1) {
-        const char: string = raw[index];
-        if (char === '"') {
-            if (quoted && raw[index + 1] === '"') {
-                cell += '"';
-                index += 1;
-            } else {
-                quoted = !quoted;
-            }
-        } else if (char === "," && !quoted) {
-            record.push(cell);
-            cell = "";
-        } else if ((char === "\n" || char === "\r") && !quoted) {
-            if (char === "\r" && raw[index + 1] === "\n") {
-                index += 1;
-            }
-            record.push(cell);
-            records.push(record);
-            record = [];
-            cell = "";
-        } else {
-            cell += char;
-        }
-    }
-    if (cell.length > 0 || record.length > 0) {
-        record.push(cell);
-        records.push(record);
-    }
-    const header: string[] = records[0].map((entry) => entry.trim());
-    const get: (row: string[], name: string) => string = (row: string[], name: string): string => row[header.indexOf(name)] ?? "";
-    return records.slice(1).map((row) => ({
-        caseId: get(row, "caseId"),
-        source: get(row, "source"),
-        input: get(row, "input"),
-        answer: get(row, "answer"),
-        expected: get(row, "expected"),
-    }));
-};
-
-const readLabels: (path: string) => LabelRow[] = (path: string): LabelRow[] => {
-    if (!existsSync(path)) {
-        return [];
-    }
-    return readFileSync(path, "utf8")
-        .split(/\r?\n/)
-        .filter((line) => line.trim().length > 0)
-        .map((line) => JSON.parse(line) as LabelRow);
-};
-
-const saveLabels: (path: string, labels: Map<string, LabelRow>) => void = (path: string, labels: Map<string, LabelRow>): void => {
-    writeFileSync(path, [...labels.values()].map((row) => JSON.stringify(row)).join("\n") + (labels.size > 0 ? "\n" : ""), "utf8");
-};
-
-const html: (annotator: string) => string = (annotator: string): string => `<!doctype html>
-<html lang="zh-CN"><head><meta charset="utf-8"><title>AMP annotation ${annotator}</title>
-<style>
-body{font:16px/1.5 system-ui,sans-serif;max-width:860px;margin:40px auto;padding:0 20px;color:#111}
-.card{border:1px solid #ddd;border-radius:12px;padding:20px;margin:16px 0;background:#fff}
-.meta{color:#666;font-size:13px}.pre{white-space:pre-wrap;background:#f7f7f7;padding:12px;border-radius:8px}
-button{font-size:16px;padding:10px 18px;margin:6px 6px 6px 0;border-radius:8px;border:1px solid #bbb;background:#fafafa;cursor:pointer}
-button:hover{background:#eee}.ok{border-color:#2a7}.bad{border-color:#c33}.unsure{border-color:#ca0}
-textarea{width:100%;min-height:70px;margin-top:8px;padding:8px;box-sizing:border-box}
-.bar{position:sticky;bottom:0;background:#fff;padding:12px 0;border-top:1px solid #eee}
-</style></head><body>
-<h2>AMP 盲标 <small>${annotator}</small></h2>
-<p class="meta">1=correct 2=incorrect 3=unsure｜不要看 repo 里的 humanLabel/actual｜共 <b id="total">?</b> 条</p>
-<div class="card" id="case"><div class="meta">loading…</div></div>
-<div class="bar"><button class="ok" onclick="mark('correct')">1 correct</button><button class="bad" onclick="mark('incorrect')">2 incorrect</button><button class="unsure" onclick="mark('unsure')">3 unsure</button><button onclick="skip()">跳过</button><span id="prog"></span></div>
-<textarea id="note" placeholder="note（可选）"></textarea>
-<script>
-let rows=[], index=0;
-const esc=s=>String(s??'').replace(/[&<>]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]));
-async function load(){rows=await (await fetch('/api/cases')).json(); document.getElementById('total').textContent=rows.length; render();}
-function render(){const r=rows[index]; if(!r){document.getElementById('case').innerHTML='<b>done</b>'; document.getElementById('prog').textContent=''; return;}
-document.getElementById('case').innerHTML='<div class="meta">'+esc(r.caseId)+' · '+esc(r.source)+'</div><h3>Input</h3><div class="pre">'+esc(r.input)+'</div><h3>Answer</h3><div class="pre">'+esc(r.answer)+'</div>'+(r.expected?'<div class="meta">expected: '+esc(r.expected)+'</div>':'');
-document.getElementById('note').value=r.note||''; document.getElementById('prog').textContent=(index+1)+'/'+rows.length;}
-async function mark(label){const r=rows[index]; if(!r)return; await fetch('/api/labels',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({caseId:r.caseId,label,note:document.getElementById('note').value})}); index++; render();}
-function skip(){index++; render();}
-document.addEventListener('keydown',e=>{if(e.key==='1')mark('correct'); if(e.key==='2')mark('incorrect'); if(e.key==='3')mark('unsure');});
-load();
-</script></body></html>`;
-
-export const startAnnotationServer: AnnotationServerFactory = async (options: AnnotationServerOptions): Promise<AnnotationServer> => {
-    const campaignPath: string = options.campaignPath ?? "docs/annotation-campaign.csv";
-    const outputPath: string = options.outputPath ?? `docs/eval/annotations-${options.annotator}.jsonl`;
-    const campaign: CampaignRow[] = loadCsvRows(campaignPath);
-    const labels: Map<string, LabelRow> = new Map<string, LabelRow>(readLabels(outputPath).map((row) => [row.caseId, row]));
-    const send: SendResponse = (response: ServerResponse, status: number, body: string, type: string = "application/json"): void => {
-        response.writeHead(status, { "content-type": type, "cache-control": "no-store" });
-        response.end(body);
-    };
-    const handler: (request: IncomingMessage, response: ServerResponse) => void = (request: IncomingMessage, response: ServerResponse): void => {
-        const url: URL = new URL(request.url ?? "/", "http://127.0.0.1");
-        if (request.method === "GET" && url.pathname === "/") {
-            return send(response, 200, html(options.annotator), "text/html; charset=utf-8");
-        }
-        if (request.method === "GET" && url.pathname === "/api/cases") {
-            const rows: CasePayload[] = campaign.map((row) => ({ ...row, ...(labels.get(row.caseId) ?? {}), note: labels.get(row.caseId)?.note ?? "" }));
-            return send(response, 200, JSON.stringify(rows));
-        }
-        if (request.method === "GET" && url.pathname === "/api/progress") {
-            return send(response, 200, JSON.stringify({ done: labels.size, total: campaign.length }));
-        }
-        if (request.method === "POST" && url.pathname === "/api/labels") {
-            let body: string = "";
-            request.on("data", (chunk) => {
-                body += chunk;
-                if (body.length > 100_000) {
-                    request.destroy();
-                }
-            });
-            request.on("end", () => {
-                try {
-                    const parsed: ParsedLabel = JSON.parse(body) as ParsedLabel;
-                    if (typeof(parsed.caseId) !== "string" || typeof(parsed.label) !== "string" || !["correct", "incorrect", "unsure"].includes(parsed.label)) {
-                        return send(response, 400, JSON.stringify({ error: "invalid label" }));
-                    }
-                    if (!campaign.some((row) => row.caseId === parsed.caseId)) {
-                        return send(response, 400, JSON.stringify({ error: "unknown case" }));
-                    }
-                    labels.set(parsed.caseId, {
-                        caseId: parsed.caseId,
-                        annotator: options.annotator,
-                        label: parsed.label,
-                        ...(typeof(parsed.note) === "string" && parsed.note.trim().length > 0 ? { note: parsed.note.trim() } : {}),
-                    });
-                    saveLabels(outputPath, labels);
-                    return send(response, 200, JSON.stringify({ done: labels.size, total: campaign.length }));
-                } catch {
-                    return send(response, 400, JSON.stringify({ error: "bad json" }));
-                }
-            });
-            return;
-        }
-        return send(response, 404, JSON.stringify({ error: "not found" }));
-    };
-
-    const server: Server = createServer(handler);
-    await new Promise<void>((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(options.port, "127.0.0.1", () => resolve());
-    });
-    const address: AddressInfo | string | null = server.address();
-    const port: number = typeof(address) === "object" && address !== null ? address.port : options.port;
-    return {
-        server,
-        url: `http://127.0.0.1:${port}/`,
-        close: () => new Promise<void>((resolve, reject) => server.close((error) => (error === (void 0) ? resolve() : reject(error)))),
-    };
-};
-
-const IsMain: boolean = process.argv[1] !== (void 0) && import.meta.url === pathToFileURL(process.argv[1]).href;
-if (IsMain) {
-    const args: string[] = process.argv.slice(2);
-    const annotator: string = args.find((arg) => arg.startsWith("--annotator="))?.split("=")[1] ?? "A";
-    const port: number = Number(args.find((arg) => arg.startsWith("--port="))?.split("=")[1] ?? "8787");
-    const running: AnnotationServer = await startAnnotationServer({ annotator, port });
-    console.log(`annotation UI: ${running.url} (${annotator})`);
-    console.log("Ctrl+C to stop");
-}

package/tools/annotation-status.ts

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-/**
- * Progress/validation for the two blind annotation packets.
- */
-import assert from "node:assert/strict";
-import { existsSync, readFileSync } from "node:fs";
-
-import type { Annotation } from "../src/evaluation/labels.ts";
-import { importAnnotationsCsv } from "../src/evaluation/labels.ts";
-
-type InspectResult = {
-    filled: number;
-    invalid: string[];
-    unknown: string[];
-    duplicate: string[];
-};
-
-const Allowed: Set<string> = new Set(["correct", "incorrect", "unsure"]);
-const Campaign: Annotation[] = importAnnotationsCsv(readFileSync("docs/annotation-campaign.csv", "utf8"));
-const Expected: Set<string> = new Set(Campaign.map((row) => row.caseId));
-
-const inspect: (path: string) => InspectResult = (path: string): InspectResult => {
-    const rows: Annotation[] = importAnnotationsCsv(readFileSync(path, "utf8"));
-    const seen: Set<string> = new Set<string>();
-    const duplicate: string[] = [];
-    for (let index: number = 0; index < rows.length; index += 1) {
-        const row: Annotation = rows[index];
-        if (seen.has(row.caseId)) {
-            duplicate.push(row.caseId);
-        }
-        seen.add(row.caseId);
-    }
-    return {
-        filled: rows.filter((row) => row.label.trim().length > 0).length,
-        invalid: rows.filter((row) => row.label.length > 0 && !Allowed.has(row.label)).map((row) => `${row.caseId}:${row.label}`),
-        unknown: rows.filter((row) => !Expected.has(row.caseId)).map((row) => row.caseId),
-        duplicate,
-    };
-};
-
-const Left: InspectResult = inspect("docs/annotation-campaign-A.csv");
-const Right: InspectResult = inspect("docs/annotation-campaign-B.csv");
-const Results: InspectResult[] = [Left, Right];
-for (let index: number = 0; index < Results.length; index += 1) {
-    const result: InspectResult = Results[index];
-    assert.equal(result.unknown.length, 0);
-    assert.equal(result.duplicate.length, 0);
-    assert.equal(result.invalid.length, 0);
-}
-
-console.log(
-    `A=${Left.filled}/${Campaign.length} B=${Right.filled}/${Campaign.length} invalid=${Left.invalid.length + Right.invalid.length} unknown=${Left.unknown.length + Right.unknown.length}`,
-);
-const jsonl: (path: string) => number = (path: string): number =>
-    existsSync(path)
-        ? readFileSync(path, "utf8")
-              .split(/\r?\n/)
-              .filter((line) => line.trim().length > 0).length
-        : 0;
-console.log(`UI A=${jsonl("docs/eval/annotations-A.jsonl")}/${Campaign.length} UI B=${jsonl("docs/eval/annotations-B.jsonl")}/${Campaign.length}`);
-if (Left.filled < Campaign.length || Right.filled < Campaign.length) {
-    console.log("status=pending human labels");
-} else {
-    console.log("status=ready to import");
-}

package/tools/approval-access-check.ts

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-/**
- * Approval audit access control + field redaction.
- */
-import assert from "node:assert/strict";
-
-import { openStore } from "../src/database/store/database.ts";
-import { RuntimeApprovalRepository } from "../src/database/repository/runtimeApprovalRepository.ts";
-import { outboxEventSink } from "../src/database/adapter/runtimeSink.ts";
-import { createProcess } from "../src/process/process.ts";
-import { grant } from "../src/authz/authz.ts";
-import type { Subject } from "../src/authz/authz.ts";
-import { AuthzError } from "../src/error/authzError.ts";
-
-const At = "2026-10-24T00:00:00.000Z";
-const db = openStore(":memory:");
-const owner = createProcess(db, { id: "a.approval.owner", name: "Owner" }, At);
-const stranger = createProcess(db, { id: "a.approval.stranger", name: "Stranger" }, At);
-const ownerSubject: Subject = { kind: "process", id: "a.approval.owner", pid: owner.pid };
-const strangerSubject: Subject = { kind: "process", id: "a.approval.stranger", pid: stranger.pid };
-const approvals = new RuntimeApprovalRepository(db);
-
-outboxEventSink(
-    db,
-    {
-        topic: "runtime.approval",
-        payload: {
-            pid: owner.pid,
-            turnId: "rt.1",
-            operationId: "op.1",
-            tool: "deploy.rollback",
-            risk: "destructive",
-            decision: "token sk-abcdefghijklmnop123456",
-            status: "denied",
-        },
-    },
-    At,
-);
-
-const rows = approvals.list(owner.pid);
-assert.equal(rows.length, 1);
-assert.equal(rows[0].decision.includes("sk-abcdefghijklmnop123456"), false);
-assert.equal(rows[0].decision.includes("[REDACTED]"), true);
-
-assert.equal(approvals.listForSubject(ownerSubject, owner.pid, At).length, 1);
-assert.throws(
-    () => approvals.listForSubject(strangerSubject, owner.pid, At),
-    (error: unknown) => error instanceof AuthzError && error.code === "permission_denied",
-);
-
-grant(
-    db,
-    {
-        grantor: ownerSubject,
-        grantee: strangerSubject,
-        resource: { kind: "object", id: `approval:${owner.pid}`, ownerPid: owner.pid },
-        rights: ["read"],
-    },
-    At,
-);
-assert.equal(approvals.listForSubject(strangerSubject, owner.pid, At).length, 1);
-assert.equal(approvals.prune("2026-10-25T00:00:00.000Z"), 1);
-
-db.close();
-console.log("\x1b[32m✓\x1b[0m approval audit is authz-gated and redacted");
-console.log("\n1 passed, 0 failed");

package/tools/arch-check.ts

@@ -1,72 +0,0 @@
-#!/usr/bin/env node
-/**
- * Architecture fitness checks. These are intentionally cheap textual guards;
- * they fail the verify when a dependency rule regresses.
- */
-import assert from "node:assert/strict";
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-
-assert.equal(existsSync("src/cycle"), false, "legacy cycle directory must stay deleted");
-assert.equal(existsSync("tools/support/ampRuntime.ts"), false, "legacy AmpRuntime fixture must stay deleted");
-
-const walk: (dir: string) => string[] = (dir: string): string[] => {
-    const files: string[] = [];
-    const names: string[] = readdirSync(dir);
-    for (let index: number = 0; index < names.length; index += 1) {
-        const name: string = names[index];
-        const path: string = join(dir, name);
-        if (statSync(path).isDirectory()) {
-            files.push(...walk(path));
-        } else if (path.endsWith(".ts")) {
-            files.push(path);
-        }
-    }
-    return files;
-};
-
-const RuntimeFiles: string[] = walk("src/runtime");
-const RuntimeText: string = RuntimeFiles.map((file) => readFileSync(file, "utf8")).join("\n");
-assert.equal(/from\s+["'][^"']*database/.test(RuntimeText), false, "runtime must not import database");
-assert.equal(/node:sqlite/.test(RuntimeText), false, "runtime must not import node:sqlite");
-
-const Kernel: string = readFileSync("src/kernel/scheduler.ts", "utf8");
-const WorkspaceServiceFiles: string[] = [
-    "src/context/workspaceService.ts", "src/context/workspaceProtocol.ts",
-    "src/module/tool/workspaceExecutor.ts", "src/module/mcp/workspaceServer.ts",
-];
-const WorkspaceServiceText: string = WorkspaceServiceFiles.map((file: string): string => readFileSync(file, "utf8")).join("\n");
-assert.equal(/from\s+["'][^"']*(?:database|tools\/support)/.test(WorkspaceServiceText), false, "workspace service must not import database or offline parsers");
-assert.equal(/from\s+["'](?:typescript|fflate|fast-xml-parser|node:sqlite)["']/.test(WorkspaceServiceText), false, "workspace service must stay independent of parsers and SQL");
-assert.equal(/\bdb\.prepare\(/.test(Kernel), false, "kernel must use the execution port, not raw SQL");
-
-const ProcessSqlBaseline: number = 0;
-const ProcessSql: number =
-    ["src/process/process.ts", "src/thread/thread.ts"]
-        .map((file) => readFileSync(file, "utf8"))
-        .join("\n")
-        .match(/\.prepare\(/g)?.length ?? 0;
-assert.ok(ProcessSql <= ProcessSqlBaseline, `process/thread raw SQL grew to ${ProcessSql} (baseline ${ProcessSqlBaseline})`);
-
-const RuntimeIndex: string = readFileSync("src/runtime/index.ts", "utf8");
-assert.equal(RuntimeIndex.includes("database"), false, "runtime index must not re-export database");
-
-const GovernanceFiles: string[] = walk("src/governance");
-const GovernanceText: string = GovernanceFiles.map((file) => readFileSync(file, "utf8")).join("\n");
-assert.equal(/from\s+["'][^"']*database/.test(GovernanceText), false, "governance must not import database");
-assert.equal(/node:sqlite/.test(GovernanceText), false, "governance must not import node:sqlite");
-assert.equal(/from\s+["'][^"']*\/runtime\//.test(GovernanceText), false, "governance must not import runtime");
-const RuntimeCoreFiles: string[] = RuntimeFiles.filter((file: string) => !file.endsWith("governedTask.ts"));
-const RuntimeCoreText: string = RuntimeCoreFiles.map((file: string) => readFileSync(file, "utf8")).join("\n");
-assert.equal(/from\s+["'][^"']*\/governance\//.test(RuntimeCoreText), false, "runtime core must not import governance directly; use governedTask.ts");
-
-const LegacyUsers: string[] = readdirSync("tools")
-    .filter((name) => name.endsWith(".ts") && name !== "arch-check.ts")
-    .filter((name) => readFileSync(join("tools", name), "utf8").includes("support/ampRuntime"))
-    .sort();
-assert.deepEqual(LegacyUsers, [], `legacy AmpRuntime references must be gone, found: ${LegacyUsers.join(", ")}`);
-
-console.log(
-    `\x1b[32m✓\x1b[0m architecture fitness: runtime database-free, kernel SQL-free, process/thread SQL=${ProcessSql}<=${ProcessSqlBaseline}, legacy runtime deleted`,
-);
-console.log("\n1 passed, 0 failed");

package/tools/attention-core-check.ts

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-/** One Attention state: stable window, attraction/distraction forces, shift as Action. */
-import assert from "node:assert/strict";
-
-import { Attention, toShiftAction } from "../src/attention/index.ts";
-import type { AttentionItem } from "../src/attention/index.ts";
-
-const At = "2026-10-24T00:00:00.000Z";
-const item = (id: string, order: number): AttentionItem => ({ target: { kind: "evidence", id }, order, weight: 0.5 });
-
-const attention = new Attention({
-    subject: { pid: 1 },
-    capacity: { slots: 2, tokens: 100 },
-    items: [item("a", 0), item("b", 1), item("c", 2), item("d", 3)],
-    now: () => At,
-});
-
-assert.deepEqual(attention.focus().map((entry) => entry.target.id), ["a", "b"]);
-const right = attention.shift({ actionId: "act.1", direction: "right", reason: "next two" });
-assert.equal(right.changed, true);
-assert.equal(right.blocked, false);
-assert.deepEqual(right.snapshot.focus.map((entry) => entry.target.id), ["b", "c"]);
-attention.shift({ actionId: "act.2", direction: "right", reason: "next two" });
-const edge = attention.shift({ actionId: "act.3", direction: "right", reason: "beyond edge" });
-assert.equal(edge.changed, false);
-assert.equal(edge.blocked, true);
-assert.match(edge.reason, /boundary/);
-attention.shift({ actionId: "act.4", direction: "left", reason: "back" });
-assert.deepEqual(attention.focus().map((entry) => entry.target.id), ["b", "c"]);
-
-attention.observe({ kind: "attraction", from: { kind: "human", id: "user.1" }, target: { kind: "evidence", id: "d" }, strength: 0.4 });
-attention.observe({ kind: "distraction", from: { kind: "event", id: "alert.1" }, target: { kind: "evidence", id: "d" }, competesWith: { kind: "evidence", id: "b" }, strength: 0.3 });
-const snapshot = attention.snapshot();
-assert.equal(snapshot.forces.length, 2);
-assert.equal(snapshot.focus.length, 2);
-assert.equal(snapshot.ignored.length, 2);
-
-const action = toShiftAction({ direction: "right", steps: 1, reason: "test" });
-assert.equal(action.intent, "attention.shift");
-assert.equal(action.risk, "none");
-assert.equal(action.successCriteria?.includes("a Receipt is recorded"), true);
-
-attention.close();
-assert.throws(() => attention.shift({ actionId: "act.x", direction: "left", reason: "closed" }), /closed/);
-
-console.log(`focus=${snapshot.focus.map((entry) => entry.target.id).join(",")} ignored=${snapshot.ignored.map((entry) => entry.target.id).join(",")} forces=${snapshot.forces.length}`);
-console.log("\x1b[32m✓\x1b[0m Attention is one state object; shift is an Action; forces do not reorder the window");
-console.log("\n1 passed, 0 failed");

package/tools/attention-resource-check.ts

@@ -1,169 +0,0 @@
-#!/usr/bin/env node
-/**
- * Attention resource checks: process capacity -> thread allocation.
- *
- * The model is deliberately pure. It answers three questions:
- * 1. how much foreground can this agent run before the reserve is touched?
- * 2. when must the agent go offline/rest?
- * 3. does the floor belong to safety and admitted tasks, not to every task?
- */
-import assert from "node:assert/strict";
-
-import type { CognitiveState } from "../src/attention/cognition.ts";
-import {
-    DefaultAttentionPolicy,
-    applyRest,
-    attentionHealth,
-    planAttention,
-    processAttention,
-    qualityAdjustedThroughput,
-    recoveryDebtOf,
-    shouldRest,
-} from "../src/attention/resource.ts";
-import type { ThreadAttentionCandidate } from "../src/attention/resource.ts";
-
-const At = "2026-10-24T00:00:00.000Z";
-
-let passed = 0;
-let failed = 0;
-
-const test = (name: string, fn: () => void): void => {
-    try {
-        fn();
-        passed += 1;
-        console.log(`\x1b[32m\u2713\x1b[0m ${name}`);
-    } catch (error) {
-        failed += 1;
-        const message = error instanceof Error ? error.message : `${error}`;
-        console.error(`\x1b[31m\u2717\x1b[0m ${name}\n      ${message}`);
-    }
-};
-
-const state = (overrides: Partial<CognitiveState> = {}): CognitiveState => {
-    const base: CognitiveState = {
-        load: 0.2,
-        vigilance: 0.9,
-        arousal: 0.1,
-        mastery: 0.7,
-        accountability: 0.5,
-        cyclesSinceRest: 0,
-        capacityEff: 4,
-        pLapse: 0.1,
-        source: "default",
-        samples: 0,
-    };
-    return { ...base, ...overrides };
-};
-
-const candidate = (
-    tid: number,
-    priority: number,
-    preferredSlots: number,
-    foreground = true,
-    extras: Partial<ThreadAttentionCandidate> = {},
-): ThreadAttentionCandidate => ({
-    tid,
-    pid: 1,
-    priority,
-    preferredSlots,
-    foreground,
-    ...extras,
-});
-
-test("process attention keeps a foreground cap and a safety reserve", () => {
-    const process = processAttention(1, state());
-    assert.equal(process.effectiveSlots, 4);
-    assert.equal(process.foregroundCap, 3);
-    assert.equal(process.reserveSlots, 1);
-    assert.equal(process.safetySlots, 1);
-    assert.equal(process.offline, false);
-    assert.equal(process.foregroundCap + process.reserveSlots, process.effectiveSlots);
-});
-
-test("effective capacity shrinks with load, and rest is triggered by policy", () => {
-    const loaded = state({ load: 0.95, capacityEff: 3, vigilance: 0.3, pLapse: 0.7, cyclesSinceRest: 2 });
-    const process = processAttention(1, loaded);
-    assert.equal(process.effectiveSlots, 3);
-    assert.equal(process.foregroundCap, 2);
-    assert.equal(process.offline, true);
-    assert.equal(shouldRest(loaded), true);
-    assert.equal(recoveryDebtOf(loaded) > 0.5, true);
-
-    const rested = applyRest(loaded);
-    assert.equal(rested.cyclesSinceRest, 0);
-    assert.equal(rested.vigilance > loaded.vigilance, true);
-    assert.equal(rested.load < loaded.load, true);
-});
-
-test("offline plans admit no foreground and explain every deferral", () => {
-    const process = processAttention(1, state({ vigilance: 0.2, cyclesSinceRest: 9 }));
-    const plan = planAttention(process, [candidate(1, 9, 2), candidate(2, 5, 1)]);
-    assert.equal(plan.rest, true);
-    assert.equal(plan.foreground, (void 0));
-    assert.equal(plan.deferred.length, 2);
-    assert.equal(
-        plan.deferred.every((entry) => entry.reason === "offline"),
-        true,
-    );
-    assert.equal(plan.utilization, 0);
-});
-
-test("one foreground gets a slice; background uses only the reserve", () => {
-    const process = processAttention(1, state());
-    const plan = planAttention(process, [candidate(1, 9, 2), candidate(2, 8, 2), candidate(3, 5, 1, false), candidate(4, 4, 2, false)]);
-    assert.equal(plan.foreground?.tid, 1);
-    assert.equal(plan.foreground?.slots, 2);
-    assert.equal(plan.background.length, 1);
-    assert.equal(plan.background[0]?.tid, 3);
-    assert.equal(plan.background[0]?.slots, 1);
-    assert.equal(
-        plan.deferred.some((entry) => entry.tid === 2 && entry.reason === "low-priority"),
-        true,
-    );
-    assert.equal(
-        plan.deferred.some((entry) => entry.tid === 4 && entry.reason === "budget"),
-        true,
-    );
-    assert.equal(plan.utilization, 3 / 4);
-    assert.equal(plan.pressure > 0, true);
-    assert.deepEqual(attentionHealth(plan), { utilization: 0.75, pressure: plan.pressure, headroom: 0.25, rest: false });
-});
-
-test("floors apply to safety and admitted tasks, never to deferred tasks", () => {
-    const process = processAttention(1, state());
-    const plan = planAttention(process, [candidate(1, 9, 0, true, { minSlots: 1 }), candidate(2, 8, 2, true), candidate(3, 7, 1, false)]);
-    assert.equal(plan.foreground?.slots, 1);
-    assert.equal(plan.background[0]?.slots, 1);
-    assert.equal(
-        plan.deferred.some((entry) => entry.tid === 2),
-        true,
-    );
-    assert.equal(plan.process.safetySlots, 1);
-});
-
-test("switch cost raises pressure without silently consuming capacity", () => {
-    const process = processAttention(1, state({ dominantRole: "goal" }));
-    const plan = planAttention(process, [candidate(1, 9, 2, true, { role: "engineer", switchCost: 2 })]);
-    assert.equal(plan.foreground?.switchCost, 2);
-    assert.equal(plan.utilization, 2 / 4);
-    assert.equal(plan.pressure >= 0.5, true);
-});
-
-test("quality-adjusted throughput punishes busy-but-wrong agents", () => {
-    const busyWrong = qualityAdjustedThroughput({ successes: 10, attempts: 20, errors: 4, rework: 3, attentionSlots: 4 });
-    const slowerClean = qualityAdjustedThroughput({ successes: 8, attempts: 10, errors: 1, rework: 0, attentionSlots: 4 });
-    assert.equal(slowerClean > busyWrong, true);
-});
-
-test("a policy can be tuned without changing the model", () => {
-    const conservative = { ...DefaultAttentionPolicy, maxForegroundUtil: 0.5, reserveRatio: 0.5 };
-    const process = processAttention(1, state(), conservative);
-    assert.equal(process.foregroundCap, 2);
-    assert.equal(process.reserveSlots, 2);
-    assert.equal(process.safetySlots, 1);
-});
-
-console.log(`\n${passed} passed, ${failed} failed`);
-if (failed > 0) {
-    process.exitCode = 1;
-}