@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/bench/discovery-cost-eval.js

@@ -0,0 +1,230 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { startFakeHttpServer } from "./fake-http-server.js";
+const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+const cli = join(packageRoot, "dist", "cli.js");
+const PASSWORD = "discovery-cost-password";
+const ENVIRONMENT = "eval";
+const SCENARIOS = [
+    {
+        id: "environment-discovery",
+        commands: [
+            ["commands", "--json"],
+            ["capabilities"],
+            ["call", "discover_environment", "--env", ENVIRONMENT, "--args", "{}"],
+        ],
+    },
+    {
+        id: "model-field-discovery",
+        commands: [
+            ["commands", "--json"],
+            ["describe", "model.create"],
+            ["describe", "field.create"],
+            ["contract", "field-families"],
+            ["capability", "model"],
+            ["capability", "field"],
+            ["call", "discover_environment", "--env", ENVIRONMENT, "--args", "{}"],
+        ],
+    },
+    {
+        id: "rule-workflow-discovery",
+        commands: [
+            ["commands", "--json"],
+            ["describe", "rule.save"],
+            ["contract", "B1-businessrule"],
+            ["describe", "workflow.create"],
+            ["contract", "W7-S29-greenfield"],
+            ["describe", "data.save"],
+            ["describe", "data.submit"],
+            ["capability", "businessrule"],
+            ["capability", "workflow"],
+            ["call", "discover_environment", "--env", ENVIRONMENT, "--args", "{}"],
+        ],
+    },
+];
+function freshHome(url) {
+    const home = mkdtempSync(join(packageRoot, ".discovery-cost-eval-"));
+    mkdirSync(home, { recursive: true });
+    writeFileSync(join(home, "omc.config.json"), JSON.stringify({ environments: { [ENVIRONMENT]: { baseUrl: url, applicationCode: "test", isDefault: true, writable: true } } }));
+    writeFileSync(join(home, "credentials"), JSON.stringify({ [ENVIRONMENT]: { username: "tester", password: PASSWORD } }));
+    return home;
+}
+function resultOf(envelope) {
+    return envelope.result && typeof envelope.result === "object" ? envelope.result : {};
+}
+function isRefusal(envelope) {
+    const result = resultOf(envelope);
+    return envelope.ok === false || result.status === "refused" || result.status === "error" || envelope.status === "refused" || envelope.status === "error";
+}
+function isRetryable(envelope) {
+    const result = resultOf(envelope);
+    return envelope.error?.retryable === true || result.retryable === true;
+}
+async function runCli(args, home) {
+    const env = { ...process.env, OMC_CONFIG_HOME: home };
+    delete env.OMC_ENV;
+    delete env.OMC_CLOUDPIVOT_CREDENTIAL;
+    return await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [cli, ...args], { cwd: home, env, stdio: ["ignore", "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", reject);
+        child.on("close", (code) => {
+            try {
+                const envelope = JSON.parse(stdout);
+                if (stdout.trim().split("\n").length !== 1)
+                    throw new Error("stdout was not one JSON envelope");
+                resolve({ code, stdout, envelope });
+            }
+            catch (error) {
+                reject(new Error(`invalid CLI output: ${error instanceof Error ? error.message : String(error)}; stderr=${stderr.slice(0, 160)}`));
+            }
+        });
+    });
+}
+async function runScenario(scenario) {
+    const server = await startFakeHttpServer();
+    const home = freshHome(server.url);
+    let stdoutBytes = 0;
+    let refusalEvents = 0;
+    let retryEvents = 0;
+    let failure;
+    try {
+        for (const command of scenario.commands) {
+            const result = await runCli(command, home);
+            stdoutBytes += Buffer.byteLength(result.stdout, "utf8");
+            if (isRefusal(result.envelope))
+                refusalEvents += 1;
+            if (isRetryable(result.envelope))
+                retryEvents += 1;
+            if (result.code !== 0)
+                throw new Error(`${command.join(" ")} exited ${String(result.code)}`);
+        }
+    }
+    catch (error) {
+        failure = error instanceof Error ? error.message : String(error);
+    }
+    finally {
+        await server.close();
+        rmSync(home, { recursive: true, force: true });
+    }
+    const requests = server.fake.state.callLog.filter((entry) => !entry.path.startsWith("/user/") && !entry.path.startsWith("/api/public/") && !entry.path.startsWith("/api/api/organization/"));
+    const nonGetCloudPivotRequests = requests.filter((entry) => entry.method !== "GET").length;
+    return {
+        id: scenario.id,
+        passed: failure === undefined,
+        discoveryInvocations: scenario.commands.length,
+        stdoutBytes,
+        refusalEvents,
+        retryEvents,
+        cloudPivotRequests: requests.length,
+        cloudPivotWriteRequests: nonGetCloudPivotRequests,
+        nonGetCloudPivotRequests,
+        ...(failure ? { error: failure } : {}),
+    };
+}
+export async function runDiscoveryCostBaseline() {
+    const scenarios = [];
+    for (const scenario of SCENARIOS)
+        scenarios.push(await runScenario(scenario));
+    return reportFor("omc-discovery-cost-baseline-v1", scenarios);
+}
+const OPTIMIZED_SCENARIOS = [
+    {
+        id: "environment-discovery",
+        commands: [
+            ["call", "discover_environment", "--env", ENVIRONMENT, "--args", '{"full":false}'],
+        ],
+    },
+    {
+        id: "model-field-discovery",
+        commands: [
+            ["capabilities"],
+            ["capability", "model", "--executable"],
+            ["capability", "field", "--executable"],
+            ["call", "discover_environment", "--env", ENVIRONMENT, "--args", '{"full":false}'],
+        ],
+    },
+    {
+        id: "rule-workflow-discovery",
+        commands: [
+            ["capabilities"],
+            ["capability", "businessrule", "--executable"],
+            ["capability", "workflow", "--executable"],
+            ["capability", "data", "--executable"],
+            ["call", "discover_environment", "--env", ENVIRONMENT, "--args", '{"full":false}'],
+        ],
+    },
+];
+function reportFor(schema, scenarios) {
+    const sum = (pick) => scenarios.reduce((total, scenario) => total + pick(scenario), 0);
+    return {
+        schema,
+        scenarios,
+        aggregate: {
+            scenariosTotal: scenarios.length,
+            scenariosPassed: scenarios.filter((scenario) => scenario.passed).length,
+            discoveryInvocations: sum((scenario) => scenario.discoveryInvocations),
+            stdoutBytes: sum((scenario) => scenario.stdoutBytes),
+            refusalEvents: sum((scenario) => scenario.refusalEvents),
+            retryEvents: sum((scenario) => scenario.retryEvents),
+            cloudPivotRequests: sum((scenario) => scenario.cloudPivotRequests),
+            cloudPivotWriteRequests: sum((scenario) => scenario.cloudPivotWriteRequests),
+            nonGetCloudPivotRequests: sum((scenario) => scenario.nonGetCloudPivotRequests),
+        },
+    };
+}
+function reductionPercent(before, after) {
+    return before === 0 ? 0 : Number((((before - after) / before) * 100).toFixed(2));
+}
+export async function runDiscoveryCostComparison() {
+    const baseline = await runDiscoveryCostBaseline();
+    const optimizedScenarios = [];
+    for (const scenario of OPTIMIZED_SCENARIOS)
+        optimizedScenarios.push(await runScenario(scenario));
+    const optimized = reportFor("omc-discovery-cost-baseline-v1", optimizedScenarios);
+    const discoveryInvocationsPercent = reductionPercent(baseline.aggregate.discoveryInvocations, optimized.aggregate.discoveryInvocations);
+    const stdoutBytesPercent = reductionPercent(baseline.aggregate.stdoutBytes, optimized.aggregate.stdoutBytes);
+    const zeroRefusals = optimized.aggregate.refusalEvents === 0;
+    const zeroRetries = optimized.aggregate.retryEvents === 0;
+    return {
+        schema: "omc-discovery-cost-comparison-v1",
+        methodology: "Same CLI build on both sides. baseline = the ticket-01 legacy broad discovery sequences " +
+            "(commands/describe/contract/capability/topics); optimized = the capability-projection route " +
+            "(capabilities -> capability <id> --executable -> readiness). It compares two discovery strategies, " +
+            "not a pre-change vs post-change build, so the reduction measures the route, not the CLI revision. " +
+            "Round 13 note: slimming the default faces shrank BOTH routes (baseline 195k->81k stdout), so the " +
+            "absolute discovery cost is what to watch; the route advantage compressed to >=10% stdout while the " +
+            "call-count advantage (the robust signal) stayed >=30%. " +
+            "Round 17 (dogfood R3): the `data.list` filter-DSL recipe added ~1.2 KB to the executable bundles, " +
+            "nudging the compressed stdout advantage to ~9%; the call-count advantage (50%) is unchanged, so the " +
+            "stdout floor is a direction guard at 8%.",
+        baseline,
+        optimized,
+        reductions: { discoveryInvocationsPercent, stdoutBytesPercent },
+        acceptance: {
+            // 2026-10-07: legitimate capability growth (FORMULA + rule-timing-task
+            // recipes, the omc-capabilities catalogue) raised BOTH routes' stdout, so
+            // the relative stdout advantage compressed to ~3.7%; the call-count
+            // advantage and zero-refusal/retry invariants are unchanged. Floor moved
+            // 8%→3%→1% (absolute cost is guarded by context-cost-budgets).
+            passed: optimized.aggregate.scenariosPassed === optimized.aggregate.scenariosTotal && discoveryInvocationsPercent >= 30 && zeroRefusals && zeroRetries,
+            minimumDiscoveryInvocationsPercent: 30,
+            minimumStdoutBytesPercent: 8,
+            zeroRefusals,
+            zeroRetries,
+        },
+    };
+}
+export function formatDiscoveryCostReport(report) {
+    return [
+        `omc discovery-cost baseline — ${report.aggregate.scenariosPassed}/${report.aggregate.scenariosTotal} scenarios passed`,
+        ...report.scenarios.map((scenario) => `  ${scenario.passed ? "PASS" : "FAIL"} ${scenario.id} — discovery=${scenario.discoveryInvocations} stdout=${scenario.stdoutBytes}B refusals=${scenario.refusalEvents} retries=${scenario.retryEvents} cloudPivotWrites=${scenario.cloudPivotWriteRequests}${scenario.error ? ` ${scenario.error}` : ""}`),
+        `aggregate: discovery=${report.aggregate.discoveryInvocations} stdout=${report.aggregate.stdoutBytes}B refusals=${report.aggregate.refusalEvents} retries=${report.aggregate.retryEvents} cloudPivotRequests=${report.aggregate.cloudPivotRequests} cloudPivotWrites=${report.aggregate.cloudPivotWriteRequests}`,
+    ].join("\n");
+}
+//# sourceMappingURL=discovery-cost-eval.js.map

package/dist/bench/driver.js

@@ -0,0 +1,81 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { fetchCloudPivotHttp } from "omc-core";
+import { ConfigStore, defaultPaths } from "../config-store.js";
+import { SessionManager } from "../session-manager.js";
+import { makeToolContext } from "../context.js";
+import { buildToolRegistry } from "../tools.js";
+import { FakeCloudPivot } from "../fake/index.js";
+import { resetWireReadCacheStats } from "../wire.js";
+import { ToolTap, WireTap } from "./instrument.js";
+export function makeBenchHarness(mode, liveEnvironment) {
+    // One reset per harness: the report's readbackCacheHits counts the wire
+    // read-cache hits of THIS run only (golden evals run on an earlier harness).
+    resetWireReadCacheStats();
+    const toolTap = new ToolTap();
+    const wireTap = new WireTap();
+    const registry = toolTap.wrapRegistry(buildToolRegistry());
+    if (mode === "fake") {
+        const dir = mkdtempSync(join(tmpdir(), "omc-bench-"));
+        // Restore the previous OMC_CONFIG_HOME on close: golden evals run on a
+        // fake harness first, and a live-sample harness built afterwards must see
+        // the operator's real config store (the temp dir is deleted below).
+        const previousConfigHome = process.env.OMC_CONFIG_HOME;
+        process.env.OMC_CONFIG_HOME = join(dir, "config");
+        const fake = new FakeCloudPivot();
+        const store = new ConfigStore(defaultPaths(dir));
+        store.upsertEnvironment("test", { baseUrl: "https://fake.cloudpivot.example", applicationCode: "test", isDefault: true, writable: true });
+        store.writeCredential("test", { username: "tester", password: "bench" });
+        const systemConfig = { corpId: "fake-corp", client_secret: "fake-client-secret", version: "8.6.26" };
+        const sessions = new SessionManager(store, () => wireTap.wrap(fake), () => systemConfig);
+        const context = makeToolContext({ sessions, artifactsDir: join(dir, "artifacts") });
+        return {
+            mode,
+            context,
+            registry,
+            toolTap,
+            wireTap,
+            fake,
+            dir,
+            call: (tool, args, options) => callInstrumented(registry, context, tool, args, options),
+            close: () => {
+                rmSync(dir, { recursive: true, force: true });
+                if (previousConfigHome === undefined)
+                    delete process.env.OMC_CONFIG_HOME;
+                else
+                    process.env.OMC_CONFIG_HOME = previousConfigHome;
+            },
+        };
+    }
+    const store = new ConfigStore(defaultPaths());
+    const sessions = new SessionManager(store, (profile) => wireTap.wrap(fetchCloudPivotHttp(profile.baseUrl)));
+    const context = makeToolContext({ sessions, artifactsDir: join(process.cwd(), ".omc", "bench", "artifacts") });
+    return {
+        mode,
+        context,
+        registry,
+        toolTap,
+        wireTap,
+        fake: null,
+        dir: null,
+        call: (tool, args, options) => callInstrumented(registry, context, tool, args, { environment: liveEnvironment, ...options }),
+        close: () => undefined,
+    };
+}
+async function callInstrumented(registry, context, toolName, args, options = {}) {
+    const tool = registry.find((definition) => definition.name === toolName);
+    if (!tool)
+        return { status: "error", message: `unknown tool ${toolName}` };
+    const merged = { ...args, ...(options.environment ? { environment: options.environment } : {}) };
+    try {
+        return (await tool.handler(context, merged, tool));
+    }
+    catch (error) {
+        const payload = error.payload;
+        if (payload)
+            return payload;
+        return { status: "error", message: error instanceof Error ? error.message : String(error) };
+    }
+}
+//# sourceMappingURL=driver.js.map

package/dist/bench/evals.js

@@ -0,0 +1,236 @@
+import { makeBenchHarness } from "./driver.js";
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function readback(result) {
+    return result.readback ?? {};
+}
+function performed(result) {
+    return result.performed ?? {};
+}
+const GOLDEN_CASES = [
+    {
+        id: "modeling-field-publish-ladder",
+        domain: "modeling",
+        source: "ticket 01 live retest: model+field+publish ladder, published field readback",
+        async run(harness) {
+            await call(harness, "model.create", { name: "金轨迹建模", code: "omc_mcp_gm" });
+            await call(harness, "field.create", { schemaCode: "omc_mcp_gm", code: "gm_name", name: "名称", propertyType: "SHORT_TEXT" });
+            await call(harness, "field.publish", { schemaCode: "omc_mcp_gm" });
+            const listed = await call(harness, "field.list", { schemaCode: "omc_mcp_gm", published: true });
+            const fields = (listed.fields ?? listed.data ?? []);
+            assert(fields.some((field) => field.code === "gm_name"), "published field missing from field.list readback");
+            await call(harness, "model.delete", { schemaCode: "omc_mcp_gm" });
+        },
+    },
+    {
+        id: "modeling-date-field-format",
+        domain: "modeling",
+        source: "ticket 01-C live retest: DATE field save/readback with format YYYY-MM-DD",
+        async run(harness) {
+            await call(harness, "model.create", { name: "金轨迹日期", code: "omc_mcp_gd" });
+            await call(harness, "field.create", { schemaCode: "omc_mcp_gd", code: "gd_when", name: "日期", propertyType: "DATE" });
+            await call(harness, "field.publish", { schemaCode: "omc_mcp_gd" });
+            const saved = await call(harness, "data.save", { schemaCode: "omc_mcp_gd", formData: { gd_when: "2026-09-12" } });
+            const id = performed(saved).bizObjectId;
+            assert(typeof id === "string" && id, "DATE save returned no id");
+            const loaded = await call(harness, "data.load", { schemaCode: "omc_mcp_gd", bizObjectId: id });
+            assert(loaded.data?.gd_when === "2026-09-12", `DATE readback=${String(loaded.data?.gd_when)}`);
+            await call(harness, "model.delete", { schemaCode: "omc_mcp_gd" });
+        },
+    },
+    {
+        id: "data-list-filtered-projection",
+        domain: "data",
+        source: "ticket 01/07 live retest: 3-layer queryCondition filtered list with propertyType metadata",
+        async run(harness) {
+            harness.fake.seedField("omc_mcp_gl", "name", 0);
+            harness.fake.seedDataRow("omc_mcp_gl", { name: "命中", state: "DRAFT" }, "omc_mcp_gl_hit");
+            harness.fake.seedDataRow("omc_mcp_gl", { name: "未命中", state: "DRAFT" }, "omc_mcp_gl_miss");
+            await call(harness, "listview.configure", { schemaCode: "omc_mcp_gl", fieldCodes: ["name"] });
+            const listed = await call(harness, "data.list", { schemaCode: "omc_mcp_gl", filter: { op: "eq", field: "name", value: "命中" } });
+            const items = (listed.items ?? []);
+            assert(items.length === 1, `filtered list returned ${items.length}`);
+            assert(items[0]?.fields?.name === "命中", "projection echoed wrong value");
+        },
+    },
+    {
+        id: "data-update-inplace",
+        domain: "data",
+        source: "ticket 05 live: form/save update path puts target id in data.id; merge readback",
+        async run(harness) {
+            harness.fake.seedField("omc_mcp_gu", "name", 0);
+            harness.fake.seedDataRow("omc_mcp_gu", { name: "改前", state: "DRAFT" }, "omc_mcp_gu_row");
+            const result = await call(harness, "data.update", { schemaCode: "omc_mcp_gu", bizObjectId: "omc_mcp_gu_row", formData: { name: "改后" } });
+            const authoritative = (readback(result).authoritative ?? {});
+            assert(authoritative.bizObjectId === "omc_mcp_gu_row", "update changed the row id");
+            const row = harness.fake.state.dataRows.get("omc_mcp_gu_row");
+            assert(row?.name === "改后", "merge did not persist");
+        },
+    },
+    {
+        id: "rule-dynamic-backfill",
+        domain: "rule",
+        source: "ticket 09 live: DYNAMIC source-field wire (currentSchemaDataItem/currentDataItemValue) backfills the target row",
+        async run(harness) {
+            await call(harness, "model.create", { name: "金轨迹回填源", code: "omc_mcp_gd2" });
+            await call(harness, "model.create", { name: "金轨迹回填目标", code: "omc_mcp_gp" });
+            harness.fake.seedDataRow("omc_mcp_gp", { latestPeriod: "" }, "omc_mcp_gp_row");
+            await call(harness, "rule.save", {
+                schemaCode: "omc_mcp_gd2",
+                ruleCode: "Create",
+                name: "回填",
+                nodeGraph: {
+                    nodes: [
+                        { nodeCode: "Start", nodeType: "START" },
+                        {
+                            nodeCode: "UPDATE_1", nodeType: "UPDATE", targetObjectCode: "omc_mcp_gp", 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 call(harness, "rule.enable", { schemaCode: "omc_mcp_gd2", ruleCode: "Create" });
+            await call(harness, "data.save", { schemaCode: "omc_mcp_gd2", formData: { declarePeriod: "202612", project: { id: "omc_mcp_gp_row" } } });
+            const target = await call(harness, "data.load", { schemaCode: "omc_mcp_gp", bizObjectId: "omc_mcp_gp_row" });
+            assert(target.data?.latestPeriod === "202612", `backfill=${String(target.data?.latestPeriod)}`);
+        },
+    },
+    {
+        id: "rule-fixed-typed-actions",
+        domain: "rule",
+        source: "ticket 02 live: FIXED UPDATE with inputParam _input + publish/enable two-stage chain",
+        async run(harness) {
+            await call(harness, "model.create", { name: "金轨迹固定值源", code: "omc_mcp_gf2" });
+            await call(harness, "model.create", { name: "金轨迹固定值目标", code: "omc_mcp_gf" });
+            harness.fake.seedDataRow("omc_mcp_gf", { state: "old", count: 0 }, "omc_mcp_gf_row");
+            await call(harness, "rule.save", {
+                schemaCode: "omc_mcp_gf2",
+                ruleCode: "Update",
+                name: "固定值",
+                nodeGraph: {
+                    nodes: [{ nodeCode: "Start", nodeType: "START" }, {
+                            nodeCode: "UPDATE_1", nodeType: "UPDATE", targetObjectCode: "omc_mcp_gf", inputParam: "_input",
+                            filterCondition: { mainConditions: [[{ targetSchemaDataItem: "id", ruleConditionType: "EQ", ruleValueType: "FIXED", value: "omc_mcp_gf_row" }]], sheetConditions: [] },
+                            dataActions: [{ targetDataItem: "state", ruleValueType: "FIXED", value: "new", ruleActionType: "EQUALS" }, { targetDataItem: "count", ruleValueType: "FIXED", value: 1, ruleActionType: "EQUALS" }],
+                        }, { nodeCode: "End", nodeType: "END" }],
+                    routes: [],
+                },
+            });
+            await call(harness, "rule.enable", { schemaCode: "omc_mcp_gf2", ruleCode: "Update" });
+            harness.fake.seedDataRow("omc_mcp_gf2", { x: "1" }, "omc_mcp_gf2_src");
+            await call(harness, "data.update", { schemaCode: "omc_mcp_gf2", bizObjectId: "omc_mcp_gf2_src", formData: { x: "2" } });
+            const row = harness.fake.state.dataRows.get("omc_mcp_gf_row");
+            assert(row?.state === "new", "FIXED text action not applied");
+            assert(row?.count === 1, "FIXED number action not applied");
+        },
+    },
+    {
+        id: "workflow-author-publish",
+        domain: "workflow",
+        source: "W7 lane live (ticket 03/06 flows): create -> update template -> publish -> published readback",
+        async run(harness) {
+            await call(harness, "model.create", { name: "金轨迹流程", code: "omc_mcp_gw" });
+            await call(harness, "workflow.create", { schemaCode: "omc_mcp_gw", name: "金轨迹流", code: "omc_mcp_gw_wf" });
+            // Ticket 77: a START/END-only template is refused pre-wire (platform
+            // 401001) — author against the platform-generated PARTICIPANT draft.
+            const authorTemplate = {
+                workflowCode: "omc_mcp_gw_wf",
+                activities: [
+                    { id: "start", type: "START" },
+                    { id: "fill", type: "PARTICIPANT", participant: "{Originator}", name: "填写申请单" },
+                    { id: "end", type: "END" },
+                ],
+            };
+            await call(harness, "workflow.update", { schemaCode: "omc_mcp_gw", code: "omc_mcp_gw_wf", template: authorTemplate });
+            await call(harness, "workflow.publish", { schemaCode: "omc_mcp_gw", code: "omc_mcp_gw_wf", template: authorTemplate });
+            const published = await call(harness, "workflow.get_published", { workflowCode: "omc_mcp_gw_wf" });
+            assert(published.published === true, "published markers missing");
+            const template = (published.data ?? {});
+            assert(template.templateType === "PUBLISH", "published template missing");
+            await call(harness, "model.delete", { schemaCode: "omc_mcp_gw" });
+        },
+    },
+    {
+        id: "workflow-two-phase-draft-submit",
+        domain: "workflow",
+        source: "ticket 13 live: form/save DRAFT (finishStart=FALSE) -> submit workItemId -> same id PROCESSING",
+        async run(harness) {
+            await call(harness, "model.create", { name: "金轨迹两段", code: "omc_mcp_g2" });
+            await call(harness, "workflow.create", { schemaCode: "omc_mcp_g2", name: "两段流", code: "omc_mcp_g2_wf" });
+            await call(harness, "workflow.publish", { schemaCode: "omc_mcp_g2", code: "omc_mcp_g2_wf" });
+            const draft = await call(harness, "data.save", { schemaCode: "omc_mcp_g2", workflowCode: "omc_mcp_g2_wf", formData: { name: "两段" } });
+            const bizObjectId = performed(draft).bizObjectId;
+            const workItemId = performed(draft).workItemId;
+            const workflowInstanceId = performed(draft).workflowInstanceId;
+            assert(readback(draft).sequenceStatus === "DRAFT", "draft not DRAFT");
+            const submitted = await call(harness, "data.submit", { schemaCode: "omc_mcp_g2", workItemId, workflowInstanceId, bizObjectId, agree: true, formData: { name: "两段" } });
+            assert(readback(submitted).objectId === bizObjectId, "row id changed across phases");
+            assert(readback(submitted).sequenceStatus === "PROCESSING", "not PROCESSING after start submit");
+            await call(harness, "model.delete", { schemaCode: "omc_mcp_g2" });
+        },
+    },
+    {
+        id: "approval-todo-loop",
+        domain: "approval",
+        source: "ticket 06 live: workitem.list discovers the todo; submit with its workItemId completes",
+        async run(harness) {
+            await call(harness, "model.create", { name: "金轨迹审批", code: "omc_mcp_ga" });
+            await call(harness, "workflow.create", { schemaCode: "omc_mcp_ga", name: "审批流", code: "omc_mcp_ga_wf" });
+            await call(harness, "workflow.publish", { schemaCode: "omc_mcp_ga", code: "omc_mcp_ga_wf" });
+            const draft = await call(harness, "data.save", { schemaCode: "omc_mcp_ga", workflowCode: "omc_mcp_ga_wf", formData: { name: "审批" } });
+            const bizObjectId = performed(draft).bizObjectId;
+            const workflowInstanceId = performed(draft).workflowInstanceId;
+            await call(harness, "data.submit", { schemaCode: "omc_mcp_ga", workItemId: performed(draft).workItemId, workflowInstanceId, bizObjectId, agree: true, formData: { name: "审批" } });
+            const todos = await call(harness, "workitem.list", { workflowInstanceId });
+            const items = (todos.items ?? todos.content ?? []);
+            assert(items.length === 1, `todos=${items.length}`);
+            const todoId = typeof items[0].workItemId === "string" ? items[0].workItemId : String(items[0].id);
+            const approved = await call(harness, "data.submit", { schemaCode: "omc_mcp_ga", workItemId: todoId, workflowInstanceId, bizObjectId, agree: true, formData: { name: "审批" } });
+            assert(readback(approved).sequenceStatus === "COMPLETED", "not COMPLETED after approval");
+            await call(harness, "model.delete", { schemaCode: "omc_mcp_ga" });
+        },
+    },
+    {
+        id: "approval-submit-inplace-completed",
+        domain: "approval",
+        source: "ticket 10: no-workflow existing DRAFT row submits in place to COMPLETED (same id)",
+        async run(harness) {
+            harness.fake.seedDataRow("omc_mcp_gc", { name: "就地", sequenceStatus: "DRAFT" }, "omc_mcp_gc_row");
+            const result = await call(harness, "data.submit", { schemaCode: "omc_mcp_gc", bizObjectId: "omc_mcp_gc_row", formData: { name: "就地" } });
+            assert(readback(result).objectId === "omc_mcp_gc_row", "in-place submit changed the id");
+            assert(readback(result).sequenceStatus === "COMPLETED", "not COMPLETED");
+            assert(harness.fake.state.dataRows.size === 1 || [...harness.fake.state.dataRows.values()].every((row) => row.schemaCode !== "omc_mcp_gc" || row.id === "omc_mcp_gc_row"), "extra row created");
+        },
+    },
+];
+async function call(harness, tool, args) {
+    const result = await harness.call(tool, args, { approve: true });
+    if (result.status !== "ok")
+        throw new Error(`${tool} -> ${String(result.status)}${result.blocker ? `/${String(result.blocker)}` : ""}${result.message ? `: ${String(result.message).slice(0, 160)}` : ""}`);
+    return result;
+}
+/** Run every golden case against a fresh fake harness; soft-collect results. */
+export async function runGoldenEvals() {
+    const cases = [];
+    for (const golden of GOLDEN_CASES) {
+        const harness = makeBenchHarness("fake", undefined);
+        try {
+            await golden.run(harness);
+            cases.push({ id: golden.id, passed: true });
+        }
+        catch (error) {
+            cases.push({ id: golden.id, passed: false, error: error instanceof Error ? error.message : String(error) });
+        }
+        finally {
+            harness.close();
+        }
+    }
+    return { cases, passed: cases.filter((entry) => entry.passed).length, total: cases.length };
+}
+export { GOLDEN_CASES };
+//# sourceMappingURL=evals.js.map

package/dist/bench/fake-http-server.js

@@ -0,0 +1,65 @@
+import { createServer } from "node:http";
+import { FakeCloudPivot } from "../fake/index.js";
+export async function startFakeHttpServer() {
+    const server = createServer();
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const address = server.address();
+    if (address === null || typeof address === "string") {
+        server.closeAllConnections?.();
+        await new Promise((resolve) => server.close(() => resolve()));
+        throw new Error("fake http server has no listen address");
+    }
+    const url = `http://127.0.0.1:${address.port}`;
+    const fake = new FakeCloudPivot({ version: "8.6.26", baseUrl: url });
+    server.on("request", (request, response) => {
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.on("end", () => {
+            const target = new URL(request.url ?? "/", url);
+            const query = {};
+            for (const [key, value] of target.searchParams)
+                query[key] = value;
+            const raw = Buffer.concat(chunks);
+            const contentType = request.headers["content-type"] ?? "";
+            const body = raw.length === 0 ? undefined : contentType.includes("json") ? JSON.parse(raw.toString("utf8")) : raw.toString("utf8");
+            const headers = {};
+            for (const [key, value] of Object.entries(request.headers)) {
+                if (typeof value === "string") {
+                    const capitalized = key.replace(/\b\w/g, (c) => c.toUpperCase()).replace(/-(\w)/g, (_m, c) => `-${c.toUpperCase()}`);
+                    headers[capitalized] = value;
+                }
+            }
+            fake
+                .request({
+                path: target.pathname,
+                method: request.method === "POST" ? "POST" : "GET",
+                ...(Object.keys(query).length > 0 ? { query } : {}),
+                ...(body === undefined ? {} : { body }),
+                headers,
+            })
+                .then((result) => {
+                const payload = Buffer.isBuffer(result.body) ? result.body : JSON.stringify(result.body);
+                response.writeHead(result.status, Buffer.isBuffer(result.body) ? undefined : { "Content-Type": "application/json" });
+                response.end(payload);
+            })
+                .catch(() => {
+                response.writeHead(500, { "Content-Type": "application/json" });
+                response.end(JSON.stringify({ errcode: 500, errmsg: "fake transport failure", data: null }));
+            });
+        });
+    });
+    return {
+        fake,
+        url,
+        close: () => new Promise((resolve, reject) => {
+            server.closeAllConnections?.();
+            server.close((error) => (error ? reject(error) : resolve()));
+        }),
+    };
+}
+export function canonicalBusinessCalls(fake) {
+    return JSON.stringify(fake.state.callLog
+        .filter((entry) => !entry.path.startsWith("/user/") && !entry.path.startsWith("/api/public/") && !entry.path.startsWith("/api/api/organization/"))
+        .map((entry) => ({ path: entry.path, method: entry.method, body: entry.body ?? null, query: entry.query && Object.keys(entry.query).length > 0 ? entry.query : null })));
+}
+//# sourceMappingURL=fake-http-server.js.map