@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/goal-routes.js

@@ -0,0 +1,468 @@
+import { boundaryOf, capabilityRouteIndex, CAPABILITY_CUES, DISCOVERY_AUTHORITY } from "./capability-overview.js";
+import { listSkills, readSkillSection } from "./skills.js";
+/**
+ * Mode cues. `next` used to answer every goal with the BUILD ladder, so
+ * "只读查看 X 的字段定义" was routed to field.create/form etc. (write:true) and
+ * a natural whole-app ask ("做一个 CRM 客户管理系统") matched no capability cue
+ * and fell through to `confident:false`. The mode is decided FIRST from verbs,
+ * then the capability ladder is shaped for it.
+ *
+ * Markers "能/可以/怎么" make scout win before a build verb ("怎么写在线 JS"
+ * asks whether/how, it does not by itself authorize a write).
+ */
+const SCOUT_CUES = ["能不能", "能不能够", "能否", "是否支持", "支持吗", "支持不支持", "可不可以", "有没有办法", "有没有可能", "怎么实现", "如何实现", "怎么写", "怎么配置"];
+const MODIFY_CUES = ["修改", "调整", "更新", "重命名", "改名", "编辑", "删除", "去掉", "移除", "改为", "改成"];
+const READ_CUES = ["查看", "读回", "盘点", "现状", "列出", "有哪些", "有没有", "检查", "审计", "导出", "只读", "看看", "看下", "查一下", "查询一下", "查一查", "梳理", "清点", "给我一份", "哪些", "是什么", "是否", "是否正确", "现有", "已有"];
+const BUILD_CUES = ["新建", "创建", "搭建", "从零", "从无到有", "做", "建", "加", "实现", "生成", "新增", "保存", "启用", "录入", "添加"];
+/** Whole-application asks — a single-model atom is the wrong shape for these. */
+const WHOLE_APP_CUES = ["应用", "系统", "整套", "从零", "从无到有", "端到端", "一条龙", "一整套", "业务应用", "平台"];
+function looksWholePackage(goal, capabilityCount) {
+    if (capabilityCount >= 4)
+        return true;
+    return WHOLE_APP_CUES.some((cue) => goal.includes(cue));
+}
+function detectMode(goal) {
+    if (SCOUT_CUES.some((cue) => goal.includes(cue)))
+        return "scout";
+    const modify = MODIFY_CUES.some((cue) => goal.includes(cue));
+    const build = BUILD_CUES.some((cue) => goal.includes(cue));
+    if (modify)
+        return "modify";
+    if (build)
+        return "build";
+    if (READ_CUES.some((cue) => goal.includes(cue)))
+        return "read";
+    // No verb: keep the historical build ladder (it is the safe default shape).
+    return "build";
+}
+/** The read tools of a lane (kind:read), for read/query mode. */
+function readToolsInLane(registry, lane) {
+    return registry.filter((tool) => tool.lane === lane && tool.kind === "read").map((tool) => tool.name);
+}
+/** The declarative (intent) path a whole-application build should prefer. */
+function intentGuidance() {
+    return {
+        path: "declarative",
+        why: "整包需求：用一份声明式意图文件描述 models/fields/form/listview/rules/workflow/onlinejs/services，由编译器合成平台原生结构并按依赖顺序执行；比逐能力拼装更省上下文、更不易漂移。",
+        commands: [
+            "omc intent schema [--example <id>]：离线看 intent YAML 的键位/操作符/可运行示例（写 intent 前先看，省去猜键名与试错）",
+            "omc intent plan <file> --env <env>：离线先校验（形体错在接触环境前返回，故 validate 可选）；大 plan 自动外置，回 planExternalized:true + planFile，直接 `omc intent apply <planFile>`；小 plan 才内联在 result.plan",
+            "omc intent apply <planFile|plan.json>（默认最终读回等价校验；--no-verify 关闭）",
+            "omc intent readback <file> --env <env>；validate [--show-intent]（默认只回 digest）",
+        ],
+        coverageNote: "intent 只覆盖部分能力（capabilities 的 intent: partial）；未覆盖的能力（应用/字典/业务集成/运行数据等）仍用下面的阶梯或 omc call 补齐。",
+    };
+}
+function firstSentence(text) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    const stop = collapsed.search(/[。.;；!！?？]/);
+    return stop >= 0 ? collapsed.slice(0, stop + 1) : collapsed;
+}
+/** CJK bigrams — used only to rank a capability's recipes, never to route. */
+function bigrams(text) {
+    const run = text.toLowerCase().match(/[\u4e00-\u9fff]+/g)?.join("") ?? "";
+    const grams = new Set();
+    for (let index = 0; index < run.length - 1; index += 1)
+        grams.add(run.slice(index, index + 2));
+    return grams;
+}
+function overlap(left, right) {
+    const a = bigrams(left);
+    const b = bigrams(right);
+    let count = 0;
+    for (const gram of a)
+        if (b.has(gram))
+            count += 1;
+    return count;
+}
+/** Capability scores from the authored cues, plus title/alias matches. */
+function capabilityScores(registry, goal) {
+    const lower = goal.toLowerCase();
+    const scores = new Map();
+    for (const route of capabilityRouteIndex(registry).routes) {
+        let score = 0;
+        for (const cue of CAPABILITY_CUES[route.id] ?? [])
+            if (lower.includes(cue.toLowerCase()))
+                score += cue.length;
+        for (const alias of route.aliases)
+            if (lower.includes(alias.toLowerCase()))
+                score += alias.length;
+        if (lower.includes(route.id.toLowerCase()))
+            score += route.id.length;
+        if (score > 0)
+            scores.set(route.id, score);
+    }
+    return scores;
+}
+function bestRecipe(registry, capabilityId, lane, goal, minScore = 3) {
+    let best;
+    for (const tool of registry) {
+        if (tool.lane !== lane)
+            continue;
+        for (const recipe of tool.executionMetadata?.recipes ?? []) {
+            const score = overlap(goal, `${recipe.title} ${recipe.id}`);
+            if (score >= minScore && (best === undefined || score > best.score))
+                best = { tool: tool.name, recipe: recipe.id, title: recipe.title, score };
+        }
+    }
+    return best;
+}
+/**
+ * The write tools a capability step will actually call, as a compact
+ * `{ toolName: [requiredArg] }` map. `omc next` inlines this so an agent stops
+ * paying a separate `commands --json --compact --lane <lane>` (1–5 KB) per
+ * capability just to learn the tool names and required args — bench19 spent 8
+ * such calls (31 KB) on a two-table task. Names + required keys are all the
+ * lane bundle's actionable payload; the arg *shapes* still come from the
+ * recipe/describe. The map form (not an array of `{tool,required}`) keeps the
+ * ladder inside its byte budget.
+ */
+function stepTools(registry, lane) {
+    const tools = {};
+    for (const tool of registry) {
+        if (tool.lane !== lane || tool.kind !== "write")
+            continue;
+        tools[tool.name] = Object.entries(tool.inputSchema)
+            .filter(([name, schema]) => name !== "environment" && name !== "capability" && name !== "confirmProduction" && name !== "requestId" && !schema.isOptional())
+            .map(([name]) => name);
+    }
+    return tools;
+}
+/**
+ * Round 13 — methodology by section, not by whole topic.
+ *
+ * `next` used to answer a build ask with `readTopics` — whole topic names such
+ * as `omc-business-configuration` (13.5 KB) and `omc-config-draft-review`
+ * (10.3 KB). An agent reads them once and pays every later turn; the eight
+ * mandatory topics are 54,674 B (~13.7k tokens) and alone exceed the 50k task
+ * budget. The section read surface already exists (`omc help <topic>
+ * --section`), and a targeted section is 400–3,400 B. This registry maps each
+ * capability to the sections it actually needs and the route returns one
+ * runnable `--section` command per pointer, so the cheap face is the default.
+ *
+ * Precision matters: a section title that does not resolve would push the
+ * agent back to the whole topic. `test/goal-sections.test.ts` asserts every
+ * authored section resolves.
+ */
+export const CAPABILITY_SECTIONS = Object.freeze({
+    environment: [
+        { topic: "omc-start-here", sections: ["最小路径（先读这段就能开始）"] },
+        { topic: "omc-write-hazards", sections: ["固定验收顺序"] },
+    ],
+    app: [
+        { topic: "omc-business-configuration", sections: ["标准顺序", "运行验收与清理"] },
+        { topic: "omc-write-hazards", sections: ["固定验收顺序"] },
+    ],
+    dictionary: [
+        { topic: "omc-business-configuration", sections: ["模型与字段"] },
+        { topic: "omc-tool-selection", sections: ["High layer — orchestrated CLI calls"] },
+    ],
+    model: [
+        { topic: "omc-config-draft-review", sections: ["3. Draft template", "8. Canonical configuration order（规范配置顺序）"] },
+        { topic: "omc-business-configuration", sections: ["标准顺序", "模型与字段"] },
+        { topic: "omc-write-hazards", sections: ["模型字段与关联"] },
+    ],
+    field: [
+        { topic: "omc-business-configuration", sections: ["模型与字段", "子表"] },
+        { topic: "omc-write-hazards", sections: ["模型字段与关联", "子表"] },
+    ],
+    form: [
+        { topic: "omc-business-configuration", sections: ["表单与视图"] },
+        { topic: "omc-write-hazards", sections: ["表单与 Sheet201"] },
+    ],
+    listview: [
+        { topic: "omc-business-configuration", sections: ["表单与视图"] },
+        { topic: "omc-write-hazards", sections: ["视图"] },
+    ],
+    datarule: [
+        { topic: "omc-business-configuration", sections: ["业务规则", "条件式（必填/只读/显示）怎么写"] },
+        { topic: "omc-refusals", sections: ["3. Semantic preflight — the payload is malformed"] },
+    ],
+    businessrule: [
+        { topic: "omc-business-configuration", sections: ["业务规则", "规则图的触发条件（关键）"] },
+        { topic: "omc-refusals", sections: ["3. Semantic preflight — the payload is malformed"] },
+    ],
+    "rule-lifecycle": [
+        { topic: "omc-business-configuration", sections: ["业务规则"] },
+        { topic: "omc-refusals", sections: ["5. Dependency & async convergence"] },
+    ],
+    workflow: [
+        { topic: "omc-business-configuration", sections: ["流程字段权限"] },
+        { topic: "omc-refusals", sections: ["5. Dependency & async convergence"] },
+    ],
+    onlinejs: [
+        { topic: "omc-business-configuration", sections: ["按钮与在线 JS"] },
+        { topic: "omc-write-hazards", sections: ["在线 JS"] },
+    ],
+    bizservice: [
+        { topic: "omc-business-configuration", sections: ["业务集成"] },
+        { topic: "omc-write-hazards", sections: ["规则与业务集成"] },
+    ],
+    data: [
+        { topic: "omc-business-configuration", sections: ["运行验收与清理"] },
+        { topic: "omc-refusals", sections: ["4. Readback mismatch — the write landed but does not match", "6. Idempotency & replay"] },
+    ],
+});
+function sectionPointersFor(ids) {
+    const seen = new Set();
+    const pointers = [];
+    for (const id of ids)
+        for (const entry of CAPABILITY_SECTIONS[id] ?? []) {
+            for (const section of entry.sections) {
+                const key = `${entry.topic}\u0000${section}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                pointers.push({ topic: entry.topic, section });
+            }
+        }
+    return pointers;
+}
+/**
+ * Ready-to-run methodology reads, one per topic, that fetch ALL of that topic's
+ * relevant sections in a single call. Round 15: bench60-62 fetched each
+ * `readSections` entry separately (~18 round-trips); `--section` is repeatable
+ * and comma-separated, so grouping by topic collapses them to ~3 without adding
+ * any bytes (the outputs land in context either way — the saving is turns).
+ */
+function batchReadCommands(pointers) {
+    const byTopic = new Map();
+    for (const pointer of pointers)
+        byTopic.set(pointer.topic, [...(byTopic.get(pointer.topic) ?? []), pointer.section]);
+    return [...byTopic.entries()].map(([topic, sections]) => `omc help ${topic} ${sections.map((section) => `--section "${section}"`).join(" ")}`);
+}
+/** The route's methodology-read surface: pointers (+ per-section bytes) + ready-to-run batched commands + hint. */
+function routeReads(readSections) {
+    // Per-section UTF-8 bytes ride each pointer (one field, not a parallel array)
+    // so a caller can budget which sections to fetch — dogfood R1 found the
+    // batched readCommands could exceed a window with no way to see sizes.
+    const budgeted = readSections.map((pointer) => ({ ...pointer, bytes: sectionBytes(pointer) }));
+    return { readSections: budgeted, readCommands: batchReadCommands(readSections), readHint: READ_HINT };
+}
+/** UTF-8 byte length of one methodology section (best-effort; 0 when unreadable). */
+function sectionBytes(pointer) {
+    const resolved = readSkillSection(pointer.topic, pointer.section);
+    return resolved ? Buffer.byteLength(resolved.section, "utf8") : 0;
+}
+const READ_HINT = '按 readCommands 一次读完（每条命令用可重复的 `--section` 取该 topic 的所有相关节，等价于逐节 `omc help <topic> --section "<section>"` 但只花一次往返）；单节字节数见 readSectionBudget，按预算自选。除非确需全貌，不要 `omc help <topic>` 读整篇（5–14KB，读一次就留在后续每一轮）。';
+function orderedCapabilities(ids, index) {
+    const selected = new Set(ids);
+    const nodes = [...index.nodeById.values()];
+    const order = new Map(nodes.map((node, position) => [node.id, position]));
+    const visiting = new Set();
+    const visited = new Set();
+    const result = [];
+    const visit = (id) => {
+        if (!selected.has(id) || visited.has(id) || visiting.has(id))
+            return;
+        visiting.add(id);
+        for (const required of index.nodeById.get(id)?.requires ?? [])
+            visit(required);
+        visiting.delete(id);
+        visited.add(id);
+        result.push(id);
+    };
+    [...selected].sort((left, right) => (order.get(left) ?? Number.MAX_SAFE_INTEGER) - (order.get(right) ?? Number.MAX_SAFE_INTEGER)).forEach(visit);
+    return result;
+}
+/**
+ * A whole-application BUILD ask that names no capability ("做一个 CRM 系统")
+ * must not fall through as `confident:false` — that is the most natural way to
+ * ask for the declarative path. Route it to the declarative path as the PRIMARY
+ * route, with the atomic ladder demoted to a supplement.
+ *
+ * It used to return `route.ladder` AND `intent` as two co-equal paths, and the
+ * caller had to choose (bench40: agents wandered between them). The declarative
+ * path is the intended shape for a cross-object write, so it is now advertised
+ * via `route.primary:"intent"`, and the atomic tools move under
+ * `route.atomicSupplement` — what intent does not cover (delete/lifecycle/
+ * runtime/exact patches), not a second main path.
+ */
+const WHOLE_PACKAGE_CAPABILITIES = ["model", "field", "form", "listview", "datarule", "businessrule", "workflow", "onlinejs"];
+/** A whole-package ask (build OR modify) is a declarative-intent candidate. */
+function isWholePackageWrite(mode, goal, capabilityCount) {
+    return (mode === "build" || mode === "modify") && looksWholePackage(goal, capabilityCount);
+}
+function wholePackageRoute(registry, goal, index) {
+    const routeById = new Map(index.routes.map((route) => [route.id, route]));
+    const ordered = orderedCapabilities([...WHOLE_PACKAGE_CAPABILITIES], index).filter((id) => routeById.has(id));
+    // Round 16b (dogfood R1): the supplement used to repeat every capability's
+    // full tool map (model.create/delete/…, field.create/…), ~60% of a 2.8KB
+    // response the caller never used — intent already covers these. Keep it a
+    // POINTER (capability + lane + one command), not a second ladder.
+    const ladder = ordered.map((id) => {
+        const capability = routeById.get(id);
+        return { capability: id, lane: capability.lane, firstCommand: `omc commands --json --compact --lane ${capability.lane}` };
+    });
+    return {
+        status: "ok",
+        goal,
+        confident: true,
+        mode: "whole-package",
+        match: { kind: "whole-package", ref: ordered.join("→"), capabilities: ordered },
+        route: {
+            primary: "intent",
+            atomicSupplement: { note: "intent 已覆盖下列能力的创建；这些原子工具只用于 intent 未覆盖面（删除/生命周期/运行数据/精确 patch）：", ladder },
+            ...routeReads(sectionPointersFor(ordered)),
+            firstCommands: [DISCOVERY_AUTHORITY.readiness],
+            write: true,
+        },
+        write: true,
+        intent: intentGuidance(),
+    };
+}
+/** A configuration read-back ask that names no capability ("给我一份现状说明"). */
+const OVERVIEW_READ_CAPABILITIES = ["environment", "model", "field", "form", "listview", "datarule", "businessrule", "workflow", "data"];
+function readOverviewRoute(registry, goal, index) {
+    const routeById = new Map(index.routes.map((route) => [route.id, route]));
+    const ordered = orderedCapabilities([...OVERVIEW_READ_CAPABILITIES], index).filter((id) => routeById.has(id));
+    const ladder = ordered.map((id) => ({ capability: id, lane: routeById.get(id).lane, readTools: readToolsInLane(registry, routeById.get(id).lane), firstCommand: `omc capability ${id}` }));
+    return {
+        status: "ok",
+        goal,
+        confident: true,
+        mode: "read",
+        match: { kind: "read-overview", ref: ordered.join("→"), capabilities: ordered },
+        route: { ladder, ...routeReads(sectionPointersFor(["environment"])), firstCommands: [DISCOVERY_AUTHORITY.readiness], write: false, readback: true },
+        write: false,
+    };
+}
+export function goalRoute(registry, goal) {
+    const index = capabilityRouteIndex(registry);
+    const routeById = new Map(index.routes.map((route) => [route.id, route]));
+    const registryTools = new Map(registry.map((tool) => [tool.name, tool]));
+    const availableTopics = new Set(listSkills().map((topic) => topic.name));
+    const mode = detectMode(goal);
+    const readish = mode === "read" || mode === "scout";
+    // Boundary FIRST. An ask that names an out-of-coverage face (OCR, release/
+    // prod, inline coding, nested child, cross-model aggregation) must not be
+    // matched to a nearby capability and handed the write ladder — that is the
+    // "invent a capability for a blocked face" anti-pattern. Return a boundary
+    // result pointing at capability-scouting + the (read-only) coverage proof.
+    const boundary = boundaryOf(goal);
+    if (boundary) {
+        return {
+            status: "ok",
+            goal,
+            confident: true,
+            mode: "scout",
+            write: false,
+            match: { kind: "boundary", ref: boundary.id, status: boundary.status, cue: boundary.cue },
+            boundary: {
+                id: boundary.id,
+                status: boundary.status,
+                note: boundary.note,
+                verify: "omc capabilities / omc capability <id>（运行时清单才是权威边界；能力表只是阅读辅助）",
+                topics: ["omc-requirement-analysis", "omc-capability-scouting"].filter((topic) => availableTopics.has(topic)),
+            },
+            route: { write: false, readback: false, firstCommands: ["omc capabilities", "omc capability <id>", "omc help omc-capability-scouting"] },
+        };
+    }
+    const scores = [...capabilityScores(registry, goal).entries()].sort((left, right) => right[1] - left[1]);
+    const fallback = {
+        status: "ok",
+        goal,
+        confident: false,
+        route: null,
+        fallback: "omc-requirement-analysis",
+        topics: [...availableTopics],
+        write: false,
+        mode,
+    };
+    const best = scores[0];
+    if (best === undefined) {
+        if (isWholePackageWrite(mode, goal, 0))
+            return wholePackageRoute(registry, goal, index);
+        if (readish)
+            return readOverviewRoute(registry, goal, index);
+        return fallback;
+    }
+    const ladderIds = scores.filter((entry) => entry[1] >= 2).map((entry) => entry[0]);
+    if (ladderIds.length >= 2) {
+        const ordered = orderedCapabilities(ladderIds, index);
+        if (ordered.length !== ladderIds.length) {
+            return { ...fallback, fallback: "目标包含多个无法排序的能力，请拆成独立目标", match: { kind: "ambiguous-ladder", capabilities: ladderIds } };
+        }
+        // Each step inlines its capability's write tools + required arg names, so an
+        // agent can go `next` → `call` without the per-capability `commands --lane`
+        // inventory crawl (bench19: 8 such calls, 31 KB). The matched recipe (when
+        // one exists) gives the arg SHAPE in ~1–2 KB; the lane bundle remains the
+        // fallback for tools with no recipe. In read/scout mode the steps list the
+        // READ tools instead — a read-back ask must not be answered with field.create.
+        const ladder = ordered.map((id) => {
+            const capability = routeById.get(id);
+            if (readish) {
+                return { capability: id, lane: capability.lane, readTools: readToolsInLane(registry, capability.lane), firstCommand: `omc capability ${id}` };
+            }
+            const recipe = bestRecipe(registry, id, capability.lane, goal);
+            return {
+                capability: id,
+                lane: capability.lane,
+                tools: stepTools(registry, capability.lane),
+                ...(recipe
+                    ? { recipe: { tool: recipe.tool, id: recipe.recipe, command: `omc describe ${recipe.tool} --example ${recipe.recipe}` } }
+                    : { firstCommand: `omc commands --json --compact --lane ${capability.lane}` }),
+            };
+        });
+        const readSections = sectionPointersFor(ordered);
+        const write = readish ? false : ordered.some((id) => routeById.get(id)?.tools.some((name) => registryTools.get(name)?.kind === "write"));
+        const whole = isWholePackageWrite(mode, goal, ordered.length);
+        // When intent is the primary path, the atomic ladder is only a POINTER to the
+        // capabilities (dogfood R1: repeating every tool map was ~60% unused bytes).
+        const atomicSupplement = { note: "intent 已覆盖这些能力的创建；原子工具只用于 intent 未覆盖面：", ladder: ladder.map((step) => ({ capability: step.capability, lane: step.lane, firstCommand: step.firstCommand ?? `omc commands --json --compact --lane ${step.lane}` })) };
+        return {
+            status: "ok",
+            goal,
+            confident: true,
+            mode: whole ? "whole-package" : mode,
+            match: { kind: readish ? "read-ladder" : "ladder", ref: ordered.join("→"), capabilities: ordered },
+            route: { ...(whole ? { primary: "intent", atomicSupplement } : { ladder }), ...routeReads(readSections), firstCommands: [DISCOVERY_AUTHORITY.readiness], write, ...(readish ? { readback: true } : {}) },
+            write,
+            ...(whole ? { intent: intentGuidance() } : {}),
+        };
+    }
+    // Single-capability mode: when several capabilities tie, a matching recipe
+    // breaks the tie; an unresolved tie falls back instead of guessing.
+    const capabilityId = best[0];
+    const route = routeById.get(capabilityId);
+    if (!route)
+        return fallback;
+    const write = readish ? false : route.tools.some((name) => registryTools.get(name)?.kind === "write");
+    const recipe = readish ? undefined : bestRecipe(registry, capabilityId, route.lane, goal);
+    const firstCommands = [DISCOVERY_AUTHORITY.readiness];
+    if (recipe)
+        firstCommands.push(`omc describe ${recipe.tool} --example ${recipe.recipe}`);
+    if (readish)
+        firstCommands.push(`omc capability ${capabilityId}`);
+    else if (route.tools.length > 1)
+        firstCommands.push(`omc commands --json --compact --lane ${route.lane}`);
+    else
+        firstCommands.push(`omc capability ${capabilityId}`);
+    const whole = isWholePackageWrite(mode, goal, 1);
+    return {
+        status: "ok",
+        goal,
+        confident: true,
+        mode: whole ? "whole-package" : mode,
+        match: {
+            kind: readish ? "read-capability" : recipe ? "recipe" : "capability",
+            ref: recipe ? recipe.recipe : capabilityId,
+            title: firstSentence(recipe ? recipe.title : route.title),
+            capability: capabilityId,
+            ...(recipe ? { tool: recipe.tool, recipe: recipe.recipe } : {}),
+        },
+        route: {
+            capability: capabilityId,
+            lane: route.lane,
+            ...(whole ? { primary: "intent" } : {}),
+            ...(readish ? { readTools: readToolsInLane(registry, route.lane) } : { tools: route.tools }),
+            ...routeReads(sectionPointersFor([capabilityId])),
+            firstCommands,
+            write,
+            ...(readish ? { readback: true } : {}),
+        },
+        write,
+        ...(whole ? { intent: intentGuidance() } : {}),
+    };
+}
+//# sourceMappingURL=goal-routes.js.map

package/dist/governed-execution.js

@@ -0,0 +1,87 @@
+import { assertWithinCoverage, versionFamilyNotice } from "./coverage.js";
+import { planFingerprint } from "./plan.js";
+import { environmentNotice, environmentWritable, requiresProductionConfirmation } from "./environment-policy.js";
+import { refusalFromCoverage } from "./support.js";
+const settled = (result) => ({ kind: "settled", result });
+/** Run the shared gate sequence; settle with a refusal or open an admission. */
+export async function admitGovernedWrite(ctx, request) {
+    const claims = Array.isArray(request.coverage) ? request.coverage : [request.coverage];
+    try {
+        for (const claim of claims)
+            assertWithinCoverage(ctx.manifest, claim.lane, claim.scope);
+    }
+    catch (error) {
+        return settled(refusalFromCoverage(error));
+    }
+    const resolved = ctx.sessions.config().resolveEnvironment(request.environment);
+    if (!environmentWritable(resolved.profile))
+        return settled({
+            status: "refused",
+            blocker: "environment-write-disabled",
+            environment: resolved.name,
+            production: resolved.profile.production === true,
+            message: `${environmentNotice(resolved.profile)} 请在 omc setup 中开启“允许写入此环境”。`,
+        });
+    let session;
+    try {
+        session = await ctx.sessions.session(request.environment);
+    }
+    catch (error) {
+        return settled({
+            status: "uncertain",
+            frozen: true,
+            reason: "wire-transport:session",
+            detail: error instanceof Error ? error.message : String(error),
+            message: "写入前会话/登录传输失败，结果未写入且已冻结；恢复后先重新发现再重试。",
+        });
+    }
+    const version = session.detectedVersion();
+    if (!version)
+        return settled({
+            status: "refused",
+            blocker: "version-family-evidence-missing",
+            message: "writes fail closed when the CloudPivot version family cannot be established",
+        });
+    // Version family is advisory now: OMC is built on 8.6, but a deployment on a
+    // different version (or product line, e.g. AI-Platform) is accepted in
+    // compatibility mode. Missing evidence still fails closed above.
+    const versionNotice = versionFamilyNotice(ctx.manifest, version);
+    // Bind the plan to THIS environment (fingerprint + notice) so the preview and
+    // every downstream artifact agree.
+    const plan = {
+        ...(await request.plan(session)),
+        environment: session.environmentName,
+        environmentFingerprint: session.environmentFingerprint(),
+        environmentNotice: environmentNotice(resolved.profile),
+        ...(versionNotice ? { versionNotice } : {}),
+    };
+    if (request.dryRun === true)
+        return settled((await request.dryRunResult?.(plan, session)) ?? { status: "dry-run", wouldChange: true, plan, planFingerprint: planFingerprint(plan) });
+    const replayed = request.replay?.(plan, session);
+    if (replayed !== undefined)
+        return settled(replayed);
+    // Production is a risk label, not a gate: the write is permitted, but only
+    // with an explicit per-write acknowledgement that lands in the audit trail.
+    // Missing confirmation refuses with zero wire.
+    const productionConfirmed = requiresProductionConfirmation(resolved.profile);
+    if (productionConfirmed && request.confirmProduction !== true)
+        return settled({
+            status: "refused",
+            blocker: "production-confirmation-required",
+            environment: resolved.name,
+            production: true,
+            plan,
+            message: "当前是生产环境：每次写入必须显式携带 confirmProduction:true；这是高危确认，会记入审计工件。",
+        });
+    return {
+        kind: "admitted",
+        admission: {
+            session,
+            environmentName: session.environmentName,
+            profile: resolved.profile,
+            plan,
+            ...(productionConfirmed ? { productionConfirmed: true } : {}),
+        },
+    };
+}
+//# sourceMappingURL=governed-execution.js.map