@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/approval-token.js

@@ -0,0 +1,102 @@
+import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+export class ApprovalTokenRejectedError extends Error {
+    reason;
+    constructor(reason) {
+        super(`approval token rejected: ${reason}`);
+        this.reason = reason;
+    }
+}
+function canonical(value) {
+    return JSON.stringify(sort(value));
+}
+function sort(value) {
+    if (Array.isArray(value))
+        return value.map(sort);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => [k, sort(v)]));
+    return value;
+}
+export function packageFingerprint(plan) {
+    return createHash("sha256")
+        .update(canonical({
+        environment: plan.environment,
+        environmentFingerprint: plan.environmentFingerprint,
+        actions: plan.actions.map((a) => ({ tool: a.tool, args: sort(a.args) })),
+    }))
+        .digest("hex");
+}
+export class ApprovalTokenService {
+    key;
+    ttlMs;
+    now;
+    used = new Set();
+    constructor(options) {
+        const key = Buffer.from(options.key, "base64");
+        if (key.length !== 32)
+            throw new Error("approval token key must be exactly 32 bytes (base64).");
+        this.key = key;
+        this.ttlMs = options.ttlMs ?? 10 * 60 * 1000;
+        this.now = options.now ?? Date.now;
+    }
+    requestApproval(plan) {
+        const approvalId = randomUUID();
+        const fingerprint = packageFingerprint(plan);
+        const issuedAt = this.now();
+        const expiresAt = issuedAt + this.ttlMs;
+        const payload = canonical({
+            v: 1,
+            approvalId,
+            packageFingerprint: fingerprint,
+            issuedAt,
+            expiresAt,
+        });
+        const sig = createHmac("sha256", this.key).update(payload).digest("base64url");
+        const token = Buffer.from(payload, "utf8").toString("base64url") + "." + sig;
+        return {
+            token,
+            approvalId,
+            packageFingerprint: fingerprint,
+            expiresAt: new Date(expiresAt).toISOString(),
+            ttlSeconds: Math.round(this.ttlMs / 1000),
+            singleUse: true,
+        };
+    }
+    verify(plan, token) {
+        const parts = token.split(".");
+        if (parts.length !== 2 || !parts[0] || !parts[1])
+            throw new ApprovalTokenRejectedError("token-malformed");
+        let payload;
+        try {
+            payload = Buffer.from(parts[0], "base64url").toString("utf8");
+        }
+        catch {
+            throw new ApprovalTokenRejectedError("token-malformed");
+        }
+        let decoded;
+        try {
+            decoded = JSON.parse(payload);
+        }
+        catch {
+            throw new ApprovalTokenRejectedError("token-malformed");
+        }
+        const expectedSig = createHmac("sha256", this.key).update(payload).digest("base64url");
+        if (!timingSafeEqualB64(parts[1], expectedSig))
+            throw new ApprovalTokenRejectedError("token-signature-invalid");
+        if (this.used.has(String(decoded.approvalId)))
+            throw new ApprovalTokenRejectedError("token-already-used");
+        if (Number(decoded.expiresAt) <= this.now())
+            throw new ApprovalTokenRejectedError("token-expired");
+        if (decoded.packageFingerprint !== packageFingerprint(plan))
+            throw new ApprovalTokenRejectedError("package-fingerprint-mismatch");
+        this.used.add(String(decoded.approvalId));
+        return { approvalId: String(decoded.approvalId) };
+    }
+}
+function timingSafeEqualB64(a, b) {
+    const ba = Buffer.from(a);
+    const bb = Buffer.from(b);
+    return ba.length === bb.length && timingSafeEqual(ba, bb);
+}
+//# sourceMappingURL=approval-token.js.map

package/dist/args.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+/**
+ * The tool-input vocabulary shared by every governed tool: the governance
+ * arguments and the write-protocol one-liner. Kept apart from the read/write/
+ * package pipelines because it is the axis they all depend on (16 lanes import
+ * `environmentArg`), not a pipeline concern itself.
+ */
+export const environmentArg = z.string().optional().describe("named environment (defaults to OMC_ENV / .omc-env / default)");
+export const capabilityArg = z
+    .string()
+    .optional()
+    .describe('覆盖清单 lane claim：取 lane id（如 "W1-list-view"、"model-management"），不是能力昵称（"listview" 会被拒并提示最接近的 lane id）；一般省略——省略即自动按工具所属 lane 校验');
+export const confirmProductionArg = z
+    .boolean()
+    .optional()
+    .describe("production 环境的写操作必须显式携带 true（高危确认，记入审计工件）；非生产环境忽略");
+/**
+ * Appended to every write-tool description (low-level via writeTool, high-level
+ * at their registration). Whether a write runs is decided by the environment's
+ * `writable` permission; a production environment additionally requires the
+ * per-write `confirmProduction`. The human gate stays the conversational draft
+ * review (omc-config-draft-review).
+ */
+export const WRITE_PROTOCOL = "写入由环境 writable 决定（只读环境拒写）；生产环境的写必须带 confirmProduction:true（高危确认，记入审计）；写前仍走对话层草稿确认（omc-config-draft-review）。";
+//# sourceMappingURL=args.js.map

package/dist/artifacts.js

@@ -0,0 +1,119 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+export const CLI_DEFAULT_OUTPUT_BYTES = 64 * 1024;
+export const CLI_MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
+function artifactPath(root, artifactId) {
+    if (!/^[a-f0-9-]{36}$/.test(artifactId))
+        throw new Error("invalid artifact id");
+    return join(resolve(root), `${artifactId}.artifact`);
+}
+function ensureRoot(root) {
+    const resolved = resolve(root);
+    mkdirSync(resolved, { recursive: true, mode: 0o700 });
+    return resolved;
+}
+export function createArtifact(root, content) {
+    const resolvedRoot = ensureRoot(root);
+    const artifactId = randomUUID();
+    const path = artifactPath(resolvedRoot, artifactId);
+    const bytes = typeof content === "string" ? Buffer.from(content, "utf8") : content;
+    const sha256 = createHash("sha256").update(bytes).digest("hex");
+    writeFileSync(path, bytes, { mode: 0o600, flag: "wx" });
+    chmodSync(path, 0o600);
+    writeFileSync(`${path}.sha256`, `${sha256}\n`, { mode: 0o600, flag: "wx" });
+    chmodSync(`${path}.sha256`, 0o600);
+    return { artifactId, sha256, path };
+}
+export function readArtifact(root, artifactId) {
+    const path = artifactPath(root, artifactId);
+    const metaPath = `${path}.sha256`;
+    if (!existsSync(path) || !existsSync(metaPath))
+        throw new Error("artifact not found");
+    if (lstatSync(path).isSymbolicLink() || lstatSync(metaPath).isSymbolicLink())
+        throw new Error("artifact is a symbolic link");
+    const content = readFileSync(path);
+    const actual = createHash("sha256").update(content).digest("hex");
+    const expected = readFileSync(metaPath, "utf8").trim();
+    if (!/^[a-f0-9]{64}$/.test(expected) || actual !== expected)
+        throw new Error("artifact sha256 verification failed");
+    return { content, sha256: actual };
+}
+export function isWithinRoot(root, candidate) {
+    const resolvedRoot = resolve(root);
+    const resolvedCandidate = resolve(candidate);
+    const relativePath = relative(resolvedRoot, resolvedCandidate);
+    // `relative` can return an ABSOLUTE path when the two paths share no common
+    // root — on Windows that is a different drive letter (D:\x vs C:\y) or a UNC
+    // path; on POSIX it always relativizes. Such a result must be treated as
+    // OUTSIDE, otherwise the containment check passes for a foreign path and the
+    // caller's walk-up loop below can never reach `root` (see assertSafeInputPath).
+    if (isAbsolute(relativePath))
+        return false;
+    return relativePath !== "" && relativePath !== ".." && !relativePath.startsWith("..") && !relativePath.startsWith("/") && !relativePath.startsWith("\\");
+}
+/**
+ * Resolve a WRITE target inside the configuration root (mirrors
+ * assertSafeInputPath's containment rule, but the file need not exist yet).
+ * `omc intent plan --plan-out` uses it so the written plan is readable by
+ * `omc intent apply`, which enforces the same root.
+ */
+export function assertSafeOutputPath(root, candidate, label) {
+    const normalized = resolve(root, candidate);
+    if (!isWithinRoot(root, normalized))
+        throw new Error(`${label} must be inside the configuration root`);
+    const parent = resolve(normalized, "..");
+    if (!existsSync(parent))
+        throw new Error(`${label} parent directory does not exist`);
+    if (lstatSync(parent).isSymbolicLink())
+        throw new Error(`${label} cannot be inside a symbolic link`);
+    if (existsSync(normalized)) {
+        if (lstatSync(normalized).isSymbolicLink())
+            throw new Error(`${label} cannot be a symbolic link`);
+        if (!lstatSync(normalized).isFile())
+            throw new Error(`${label} must be a regular file`);
+    }
+    return normalized;
+}
+export function assertSafeInputPath(root, candidate, label) {
+    const resolvedRoot = resolve(root);
+    const normalized = resolve(root, candidate);
+    if (!isWithinRoot(root, normalized))
+        throw new Error(`${label} must be inside the configuration root`);
+    let current = normalized;
+    while (current !== resolvedRoot) {
+        try {
+            if (lstatSync(current).isSymbolicLink())
+                throw new Error(`${label} cannot be a symbolic link`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === `${label} cannot be a symbolic link`)
+                throw error;
+            throw new Error(`${label} does not exist`);
+        }
+        const parent = resolve(current, "..");
+        // Terminating guard: `resolve(x, "..")` stops at the filesystem/drive root.
+        // If we reach it without hitting `resolvedRoot`, the candidate is not a
+        // descendant even though the containment check above said otherwise — refuse
+        // instead of looping forever (the Windows cross-drive hang, B1).
+        if (parent === current)
+            throw new Error(`${label} must be inside the configuration root`);
+        current = parent;
+    }
+    try {
+        const stat = lstatSync(normalized);
+        if (stat.isSymbolicLink())
+            throw new Error(`${label} cannot be a symbolic link`);
+        // A directory / FIFO / device would make the caller's readSync block (or
+        // misbehave); require a regular file so a bad path fails fast, never hangs.
+        if (!stat.isFile())
+            throw new Error(`${label} must be a regular file`);
+    }
+    catch (error) {
+        if (error instanceof Error && (error.message === `${label} cannot be a symbolic link` || error.message === `${label} must be a regular file`))
+            throw error;
+        throw new Error(`${label} does not exist`);
+    }
+    return normalized;
+}
+//# sourceMappingURL=artifacts.js.map

package/dist/bench/call-face-eval.js

@@ -0,0 +1,256 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { startFakeHttpServer } from "./fake-http-server.js";
+/**
+ * Call-face eval (Spec 100 acceptance / Spec 107 baseline): a scripted
+ * reference agent completes real tasks using ONLY the omc CLI face
+ * (commands/describe/contract discovery + `omc call` with the two-step
+ * approval), one subprocess per invocation, against an HTTP-served fake.
+ * Metrics: task success, CLI invocations, error exits, envelope bytes
+ * (token proxy = bytes/4), approval rounds, business wire calls.
+ */
+const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+const cli = join(packageRoot, "dist", "cli.js");
+function ok(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function makeAgent(home, metric) {
+    const env = { ...process.env, OMC_CONFIG_HOME: home };
+    const base = {
+        env: env,
+        async run(args) {
+            metric.cliInvocations += 1;
+            const kind = args[0] === "call" ? "callInvocations" : "discoveryInvocations";
+            metric[kind] += 1;
+            const argsJson = args.find((token) => token.startsWith("{"));
+            metric.requestBytes += argsJson ? Buffer.byteLength(argsJson) : args.join(" ").length;
+            return await new Promise((resolveRun, rejectRun) => {
+                const child = spawn(process.execPath, [cli, ...args], { cwd: home, env, stdio: ["pipe", "pipe", "pipe"] });
+                let stdout = "";
+                let stderr = "";
+                child.stdout.on("data", (chunk) => (stdout += chunk.toString("utf8")));
+                child.stderr.on("data", (chunk) => (stderr += chunk.toString("utf8")));
+                child.on("error", rejectRun);
+                child.on("close", (code) => {
+                    metric.responseBytes += Buffer.byteLength(stdout);
+                    let envelope;
+                    try {
+                        envelope = JSON.parse(stdout);
+                    }
+                    catch (error) {
+                        rejectRun(new Error(`stdout is not a single JSON envelope (${String(code)}): ${stdout.slice(0, 200)}\nstderr=${stderr.slice(0, 200)} ${error.message}`));
+                        return;
+                    }
+                    if (code === 13)
+                        metric.expectedApprovalExits += 1;
+                    else if (code !== 0)
+                        metric.errorExits += 1;
+                    resolveRun({ code, envelope });
+                });
+            });
+        },
+        async write(args, options = {}) {
+            const tool = args.__tool;
+            const payload = { ...args };
+            delete payload.__tool;
+            const argsFlag = JSON.stringify(payload);
+            const callArgs = ["call", tool, "--env", "eval", "--args", argsFlag, ...(options.requestId ? ["--request-id", options.requestId] : [])];
+            const executed = await base.run(callArgs);
+            ok(executed.envelope.result?.status === "ok", `execute phase (${tool}): ${JSON.stringify(executed.envelope).slice(0, 260)}`);
+            return executed.envelope.result;
+        },
+        async read(tool, args) {
+            const result = await base.run(["call", tool, "--env", "eval", "--args", JSON.stringify(args)]);
+            ok(result.envelope.ok === true, `read ${tool}: ${JSON.stringify(result.envelope).slice(0, 220)}`);
+            return result.envelope.result;
+        },
+        async discovery(kind, value, flags = []) {
+            const args = value === undefined ? [kind, ...(kind === "commands" ? ["--json"] : []), ...flags] : [kind, value, ...flags];
+            const result = await base.run(args);
+            ok(result.envelope.ok === true, `discovery ${kind}: ${JSON.stringify(result.envelope).slice(0, 220)}`);
+            return result.envelope.result;
+        },
+        counts: () => metric,
+    };
+    return base;
+}
+function freshHome(url) {
+    const home = mkdtempSync(join(packageRoot, ".call-face-eval-"));
+    mkdirSync(home, { recursive: true });
+    writeFileSync(join(home, "omc.config.json"), JSON.stringify({ environments: { eval: { baseUrl: url, applicationCode: "test", isDefault: true, writable: true } } }));
+    writeFileSync(join(home, "credentials"), JSON.stringify({ eval: { username: "tester", password: "eval-face-password" } }));
+    return home;
+}
+export const CALL_FACE_TASKS = [
+    {
+        id: "usable-model-ladder",
+        description: "model + 3 fields + field publish + form draft/publish + verified readback (Spec 107 first slice, via call face)",
+        async run(agent) {
+            const inventory = await agent.discovery("commands");
+            ok(Array.isArray(inventory.tools) && inventory.tools.some((tool) => tool.name === "model.create"), "commands inventory missing model.create");
+            const described = await agent.discovery("describe", "field.create", ["--full"]);
+            ok(described.inputSchema?.properties !== undefined, "describe field.create --full lacks schema");
+            const contract = await agent.discovery("contract", "field-families", ["--full"]);
+            ok(contract.contract?.wire !== undefined, "contract field-families --full lacks wire");
+            await agent.write({ __tool: "model.create", name: "评测建模", code: "eval_m1" });
+            await agent.write({ __tool: "field.create", schemaCode: "eval_m1", code: "f_title", name: "标题", propertyType: "SHORT_TEXT" });
+            await agent.write({ __tool: "field.create", schemaCode: "eval_m1", code: "f_amount", name: "金额", propertyType: "NUMERICAL", options: { scale: 3 } });
+            await agent.write({ __tool: "field.create", schemaCode: "eval_m1", code: "f_when", name: "日期", propertyType: "DATE" });
+            await agent.write({ __tool: "field.publish", schemaCode: "eval_m1" });
+            await agent.write({ __tool: "form.draft", schemaCode: "eval_m1", sheetCode: "eval_m1" });
+            await agent.write({ __tool: "form.publish", schemaCode: "eval_m1", sheetCode: "eval_m1" });
+            const fields = await agent.read("field.list", { schemaCode: "eval_m1", published: true });
+            const codes = (fields.fields ?? []).map((field) => field.code);
+            ok(["f_title", "f_amount", "f_when"].every((code) => codes.includes(code)), `published fields missing: ${JSON.stringify(codes)}`);
+            const form = await agent.read("form.get", { schemaCode: "eval_m1", sheetCode: "eval_m1" });
+            ok(form.published === true, "form not published after ladder");
+        },
+    },
+    {
+        id: "rule-backfill-ladder",
+        description: "two models + DYNAMIC backfill rule + enable + trigger row + verified target readback (live-verified ticket 09 shape)",
+        async run(agent, server) {
+            await agent.discovery("contract", "B1-businessrule");
+            await agent.write({ __tool: "model.create", name: "回填源", code: "eval_rs" });
+            await agent.write({ __tool: "model.create", name: "回填目标", code: "eval_rt" });
+            server.fake.seedDataRow("eval_rt", { latestPeriod: "" }, "eval_rt_row");
+            await agent.write({
+                __tool: "rule.save",
+                schemaCode: "eval_rs",
+                ruleCode: "Create",
+                name: "回填",
+                nodeGraph: {
+                    nodes: [
+                        { nodeCode: "Start", nodeType: "START" },
+                        {
+                            nodeCode: "UPDATE_1",
+                            nodeType: "UPDATE",
+                            targetObjectCode: "eval_rt",
+                            inputParam: "_input",
+                            filterCondition: { mainConditions: [[{ targetSchemaDataItem: "id", ruleConditionType: "EQ", ruleValueType: "DYNAMIC", currentSchemaDataItem: "project" }]], sheetConditions: [] },
+                            dataActions: [{ targetDataItem: "latestPeriod", ruleValueType: "DYNAMIC", value: "", ruleActionType: "EQUALS", currentDataItemValue: "declarePeriod" }],
+                        },
+                        { nodeCode: "End", nodeType: "END" },
+                    ],
+                    routes: [{ preNode: "Start", postNode: "UPDATE_1" }, { preNode: "UPDATE_1", postNode: "End" }],
+                },
+            });
+            await agent.write({ __tool: "rule.enable", schemaCode: "eval_rs", ruleCode: "Create" });
+            await agent.write({ __tool: "data.save", schemaCode: "eval_rs", formData: { declarePeriod: "202612", project: { id: "eval_rt_row" } } });
+            const target = await agent.read("data.load", { schemaCode: "eval_rt", bizObjectId: "eval_rt_row" });
+            ok(target.data?.latestPeriod === "202612", `backfill=${String(target.data?.latestPeriod)}`);
+        },
+    },
+    {
+        id: "input-error-recovery",
+        description: "agent hits invalid-input (exit 10), recovers; requestId replay returns already-completed without a second create wire",
+        async run(agent, server) {
+            const invalid = await agent.run(["call", "model.create", "--env", "eval", "--args", "{not json"]);
+            ok(invalid.code === 10 && invalid.envelope.error?.code === "invalid-input", `expected invalid-input exit 10, got ${String(invalid.code)}`);
+            await agent.write({ __tool: "model.create", name: "幂等模型", code: "eval_idem" }, { requestId: "eval-idem-1" });
+            const createWiresBefore = server.fake.bodiesFor("/api/api/app/bizmodels/create").length;
+            ok(createWiresBefore === 1, `expected exactly one create wire, got ${String(createWiresBefore)}`);
+            const replay = await agent.run(["call", "model.create", "--env", "eval", "--args", JSON.stringify({ name: "幂等模型", code: "eval_idem" }), "--request-id", "eval-idem-1"]);
+            ok(replay.code === 0 && replay.envelope.result?.status === "ok" && replay.envelope.result?.replay === "already-completed", `replay=${JSON.stringify(replay.envelope).slice(0, 260)}`);
+            ok(server.fake.bodiesFor("/api/api/app/bizmodels/create").length === 1, "replay must not send a second create wire");
+            const diverged = await agent.run(["call", "model.create", "--env", "eval", "--args", JSON.stringify({ name: "幂等模型2", code: "eval_idem2" }), "--request-id", "eval-idem-1"]);
+            ok(diverged.code === 0 && diverged.envelope.result?.status === "ok", "same requestId with diverged args must execute as a new request");
+            ok(server.fake.bodiesFor("/api/api/app/bizmodels/create").length === 2, "diverged args must not replay the first request");
+        },
+    },
+    {
+        id: "read-exploration",
+        description: "discovery-driven read exploration: commands -> describe -> contract -> filtered data.list projection",
+        async run(agent, server) {
+            const inventory = await agent.discovery("commands");
+            const listTool = inventory.tools.find((tool) => tool.name === "data.list");
+            ok(listTool !== undefined, "data.list not discoverable");
+            await agent.discovery("describe", "data.list");
+            server.fake.seedField("eval_ro", "name", 0);
+            server.fake.seedDataRow("eval_ro", { name: "命中", state: "DRAFT" }, "eval_ro_hit");
+            server.fake.seedDataRow("eval_ro", { name: "未命中", state: "DRAFT" }, "eval_ro_miss");
+            await agent.write({ __tool: "listview.configure", schemaCode: "eval_ro", fieldCodes: ["name"] });
+            const listed = await agent.read("data.list", { schemaCode: "eval_ro", filter: { op: "eq", field: "name", value: "命中" } });
+            const items = (listed.items ?? []);
+            ok(items.length === 1 && items[0]?.fields?.name === "命中", `filtered projection wrong: ${JSON.stringify(items).slice(0, 160)}`);
+        },
+    },
+];
+export async function runCallFaceEvals(options = {}) {
+    const tasks = options.only ? CALL_FACE_TASKS.filter((task) => task.id === options.only) : CALL_FACE_TASKS;
+    if (tasks.length === 0)
+        throw new Error(`no call-face task matches ${options.only}`);
+    const results = [];
+    for (const task of tasks) {
+        const server = await startFakeHttpServer();
+        const home = freshHome(server.url);
+        const metric = { cliInvocations: 0, discoveryInvocations: 0, callInvocations: 0, approvalRounds: 0, errorExits: 0, expectedApprovalExits: 0, requestBytes: 0, responseBytes: 0 };
+        const startedAt = Date.now();
+        let businessWireCalls = 0;
+        let failure;
+        try {
+            const agent = await makeAgent(home, metric);
+            await task.run(agent, server);
+        }
+        catch (error) {
+            failure = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            businessWireCalls = server.fake.state.callLog.filter((entry) => !entry.path.startsWith("/user/") && !entry.path.startsWith("/api/public/") && !entry.path.startsWith("/api/api/organization/")).length;
+            await server.close();
+            rmSync(home, { recursive: true, force: true });
+        }
+        results.push({
+            id: task.id,
+            passed: failure === undefined,
+            ...(failure ? { error: failure } : {}),
+            cliInvocations: metric.cliInvocations,
+            discoveryInvocations: metric.discoveryInvocations,
+            callInvocations: metric.callInvocations,
+            approvalRounds: metric.approvalRounds,
+            errorExits: metric.errorExits,
+            expectedApprovalExits: metric.expectedApprovalExits,
+            requestBytes: metric.requestBytes,
+            responseBytes: metric.responseBytes,
+            estimatedTokens: Math.round((metric.requestBytes + metric.responseBytes) / 4),
+            businessWireCalls,
+            wallClockMs: Date.now() - startedAt,
+        });
+    }
+    const sum = (pick) => results.reduce((total, entry) => total + pick(entry), 0);
+    return {
+        schema: "omc-call-face-eval-v1",
+        face: "call",
+        generatedAt: new Date().toISOString(),
+        tasks: results,
+        aggregate: {
+            tasksTotal: results.length,
+            tasksPassed: results.filter((entry) => entry.passed).length,
+            successRate: results.length === 0 ? 0 : Math.round((results.filter((entry) => entry.passed).length / results.length) * 10000) / 10000,
+            cliInvocations: sum((entry) => entry.cliInvocations),
+            discoveryInvocations: sum((entry) => entry.discoveryInvocations),
+            callInvocations: sum((entry) => entry.callInvocations),
+            approvalRounds: sum((entry) => entry.approvalRounds),
+            errorExits: sum((entry) => entry.errorExits),
+            requestBytes: sum((entry) => entry.requestBytes),
+            responseBytes: sum((entry) => entry.responseBytes),
+            estimatedTokens: sum((entry) => entry.estimatedTokens),
+            businessWireCalls: sum((entry) => entry.businessWireCalls),
+        },
+    };
+}
+export function formatCallFaceReport(report) {
+    const lines = [
+        `omc call-face eval — ${report.aggregate.tasksPassed}/${report.aggregate.tasksTotal} tasks passed (successRate=${report.aggregate.successRate})`,
+        ...report.tasks.map((task) => `  ${task.passed ? "PASS" : "FAIL"} ${task.id} — cli=${task.cliInvocations} discovery=${task.discoveryInvocations} approvals=${task.approvalRounds} errExits=${task.errorExits} wires=${task.businessWireCalls} tokens≈${task.estimatedTokens} ${task.wallClockMs}ms${task.error ? `\n    ${task.error}` : ""}`),
+        `aggregate: cli=${report.aggregate.cliInvocations} discovery=${report.aggregate.discoveryInvocations} calls=${report.aggregate.callInvocations} approvals=${report.aggregate.approvalRounds} errExits=${report.aggregate.errorExits} wires=${report.aggregate.businessWireCalls} tokens≈${report.aggregate.estimatedTokens}`,
+    ];
+    return lines.join("\n");
+}
+export function callFaceCliPath() {
+    return resolve(cli);
+}
+//# sourceMappingURL=call-face-eval.js.map

package/dist/bench/context-attribution.js

@@ -0,0 +1,151 @@
+/**
+ * Context attribution (2026-09-26).
+ *
+ * `scripts/agent-context-report.mjs` measures a session's PEAK window pressure
+ * from the OpenCode session DB. This module answers the next question: what
+ * occupies that window? It is pure — no sqlite, no fs — so the report script and
+ * the test suite share ONE classifier instead of drifting apart.
+ *
+ * A session's distinct content splits into:
+ *   - tool-result:     what tools returned (the dominant share in real tasks)
+ *   - reasoning:       the model's thinking
+ *   - assistant-text:  the model's visible prose
+ *   - step / other:    framework bookkeeping (step-start/finish, patch, file)
+ *
+ * Tool results are further attributed: for `bash` parts the command is parsed
+ * for an OMC CLI invocation and its footprint grouped by
+ * `<subcommand> <target> [variant-flags]` — so the report can rank the faces
+ * (`describe --full`, bare `commands`, `capability --executable`, `help <topic>`)
+ * that actually fill the window, and a byte ceiling can be pinned to each.
+ *
+ * Byte counts, not tokens: the per-message token totals are authoritative for
+ * the window size, but the DB does not expose a token split per part, so the
+ * category/tool/command shares are proportions of distinct content bytes.
+ */
+const EMPTY_CATEGORIES = {
+    "tool-result": 0,
+    reasoning: 0,
+    "assistant-text": 0,
+    step: 0,
+    other: 0,
+};
+/** Variant flags that change a face's size; positional/env flags are noise. */
+const VARIANT_FLAGS = new Set(["--full", "--executable", "--json", "--compact", "--dry-run", "--all", "--schema-only"]);
+const SUBCOMMAND_TARGETS = new Set(["call", "describe", "contract", "capability", "help", "intent", "bench", "artifact"]);
+/**
+ * Match an OMC invocation: `node …/cli.js <rest>` or `omc <rest>`. Anchored to a
+ * command boundary (start of string, after `; & | (`, or after `npx`/`bunx`) so
+ * `... && node cli.js …` is found but `grep -rn omc .` is not.
+ */
+const OMC_INVOCATION = new RegExp("(?:^|[;&|(]\\s*|\\b(?:npx|bunx)(?:\\.exe)?\\s+)" +
+    "(?:[A-Za-z_][A-Za-z0-9_]*=\\S+\\s+)*" +
+    "(?:(?:node|bun|npx|bunx)(?:\\.exe)?\\s+)?" +
+    "(?:[^\\s]*[\\/\\\\])?(?:omc(?:-cli)?|cli\\.js)" +
+    "\\s+(.+)$");
+export function classifyPart(type) {
+    switch (type) {
+        case "tool":
+            return "tool-result";
+        case "reasoning":
+            return "reasoning";
+        case "text":
+            return "assistant-text";
+        case "step-start":
+        case "step-finish":
+            return "step";
+        default:
+            return "other";
+    }
+}
+export function parseOmcInvocation(command) {
+    const match = OMC_INVOCATION.exec(command.trim());
+    if (!match)
+        return undefined;
+    // Only the first command of a shell chain is a face; the rest is follow-up.
+    const segment = match[1].split(/\s*(?:&&|\|\||;|\|)\s*/)[0].trim();
+    const tokens = segment.split(/\s+/).filter(Boolean);
+    const subcommand = tokens[0] ?? "";
+    const flags = [];
+    for (const token of tokens.slice(1)) {
+        // Stop at the args payload: a JSON blob is data, not part of the face.
+        if (token === "--args" || token === "--args-file" || token === "-")
+            break;
+        const name = token.replace(/=.*$/, "");
+        if (token.startsWith("--") && VARIANT_FLAGS.has(name) && !flags.includes(name))
+            flags.push(name);
+    }
+    // `full:true` inside --args triggers the same oversized readback as --full.
+    if (!flags.includes("--full") && /["']?full["']?\s*:\s*true/.test(segment))
+        flags.push("--full");
+    const target = SUBCOMMAND_TARGETS.has(subcommand) ? tokens[1] ?? "" : "";
+    return { label: target ? `${subcommand} ${target}` : subcommand, flags };
+}
+export function attributeContext(parts) {
+    const categories = { ...EMPTY_CATEGORIES };
+    const tools = new Map();
+    const omc = new Map();
+    let totalBytes = 0;
+    for (const part of parts) {
+        const bytes = Number.isFinite(part.bytes) && part.bytes > 0 ? part.bytes : 0;
+        categories[classifyPart(part.type)] += bytes;
+        totalBytes += bytes;
+        if (part.type !== "tool")
+            continue;
+        const resultBytes = part.outputBytes ?? bytes;
+        const tool = part.tool ?? "unknown";
+        tools.set(tool, (tools.get(tool) ?? 0) + resultBytes);
+        if (tool === "bash" && part.toolCommand) {
+            const parsed = parseOmcInvocation(part.toolCommand);
+            if (parsed) {
+                const key = parsed.flags.length ? `${parsed.label} ${parsed.flags.join(" ")}` : parsed.label;
+                const entry = omc.get(key) ?? { label: parsed.label, flags: parsed.flags, calls: 0, bytes: 0 };
+                entry.calls += 1;
+                entry.bytes += resultBytes;
+                omc.set(key, entry);
+            }
+        }
+    }
+    return {
+        categories,
+        tools: [...tools.entries()].map(([tool, value]) => ({ tool, bytes: value })).sort((a, b) => b.bytes - a.bytes),
+        omcInvocations: [...omc.values()].map(({ label, flags, calls, bytes }) => ({ label, flags, calls, bytes })).sort((a, b) => b.bytes - a.bytes),
+        totalBytes,
+        estimatedTokens: Math.round(totalBytes / 4),
+    };
+}
+/** Combine per-session attributions into one (drives the baseline snapshot). */
+export function mergeAttributions(attributions) {
+    const categories = { ...EMPTY_CATEGORIES };
+    const tools = new Map();
+    const omc = new Map();
+    let totalBytes = 0;
+    for (const attribution of attributions) {
+        for (const key of Object.keys(categories))
+            categories[key] += attribution.categories[key];
+        totalBytes += attribution.totalBytes;
+        for (const entry of attribution.tools)
+            tools.set(entry.tool, (tools.get(entry.tool) ?? 0) + entry.bytes);
+        for (const entry of attribution.omcInvocations) {
+            const key = entry.flags.length ? `${entry.label} ${entry.flags.join(" ")}` : entry.label;
+            const existing = omc.get(key) ?? { label: entry.label, flags: [...entry.flags], calls: 0, bytes: 0 };
+            existing.calls += entry.calls;
+            existing.bytes += entry.bytes;
+            omc.set(key, existing);
+        }
+    }
+    return {
+        categories,
+        tools: [...tools.entries()].map(([tool, value]) => ({ tool, bytes: value })).sort((a, b) => b.bytes - a.bytes),
+        omcInvocations: [...omc.values()].map(({ label, flags, calls, bytes }) => ({ label, flags, calls, bytes })).sort((a, b) => b.bytes - a.bytes),
+        totalBytes,
+        estimatedTokens: Math.round(totalBytes / 4),
+    };
+}
+export function categoryShares(attribution) {
+    const total = attribution.totalBytes || 1;
+    const shares = {};
+    for (const key of Object.keys(attribution.categories))
+        shares[key] = Number(((attribution.categories[key] / total) * 100).toFixed(2));
+    return shares;
+}
+//# sourceMappingURL=context-attribution.js.map