@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/capability-overview.js

@@ -0,0 +1,492 @@
+import { loadCoverageManifest } from "./coverage.js";
+import { INTENT_CAPABILITIES } from "./intent/capabilities/index.js";
+import { LANES } from "./lanes/lane-ids.js";
+import { listSkills } from "./skills.js";
+export const DISCOVERY_AUTHORITY = Object.freeze({
+    authoritative: "package",
+    route: "omc help omc-start-here",
+    readiness: "omc call discover_environment --env <env> --args '{}'",
+    distributedMirror: "a cpdocs snapshot may mirror this package; its manifest commit and file hashes are the authority for that copy",
+    capabilityProjection: "omc capabilities",
+    executableBundle: "omc capability <id> --executable",
+});
+/**
+ * The 13 Configuration capabilities. Declaration order is presentation order.
+ * The four intent-covered surfaces omit `requires`/`operations` where the
+ * intent registry is authoritative.
+ */
+const SURFACES = [
+    {
+        id: "environment",
+        title: "环境治理",
+        lane: LANES.environment,
+        description: "环境发现、指纹与版本兼容性；写入前的环境真相。",
+        operations: ["discover", "fingerprint"],
+        requires: [],
+        intent: { level: "none", note: "治理面，不进 intent；用 omc setup / discover_environment。" },
+        notes: "只读；写入开关与生产授权在 omc setup。",
+    },
+    {
+        id: "app",
+        title: "应用",
+        lane: LANES.app,
+        description: "应用包（app）生命周期：列出、创建、更新（分组移动）、admin 删除。",
+        operations: ["create", "update", "delete"],
+        requires: [],
+        intent: { level: "none", note: "未覆盖；用 omc call app.*。" },
+        notes: "环境已带默认 applicationCode，建模不必先建应用。",
+    },
+    {
+        id: "dictionary",
+        title: "数据字典",
+        lane: LANES.dictionary,
+        description: "数据字典及字典记录：键值型/树型、启停、字段选项来源。",
+        operations: ["list", "get", "records", "save", "status", "type", "names", "parent", "classes", "usage"],
+        requires: [],
+        intent: { level: "none", note: "未覆盖 intent；用 omc call dictionary.* 与 field.* 的 optionsSet。" },
+        notes: "选择字段支持 custom、dictionary、businessModel 三种 optionsSet 来源；关联单选/多选支持 searchFormula 与 conditions JSON 筛选。",
+    },
+    {
+        id: "model",
+        title: "业务模型",
+        lane: LANES.model,
+        description: "模型生命周期：创建、改名、物理删除、存在性。",
+        operations: ["create", "update", "delete", "deleteMany", "setSummary"],
+        intent: { level: "partial", note: "create/update 与 delete（absent:true）已声明式；deleteMany/setSummary 未覆盖。" },
+    },
+    {
+        id: "field",
+        title: "字段（含子表、计算字段）",
+        lane: LANES.field,
+        description: "字段族全链：create→publish→表单绑定；CHILD_TABLE 子列；FORMULA 计算（子表求和回主表、子表列同行运算）。",
+        operations: ["create", "update", "publish", "delete"],
+        intent: { level: "partial", note: "create/update（含 CHILD_TABLE subFields、FORMULA 计算）、publish 与 delete（absent:true）已声明式。" },
+        notes: "子表列是 schemaCode=父字段 code 上的普通字段；field.update 不接受 subFields。子列支持标量族 + WORK_SHEET 关联列（需 relativeCode + options）。**计算类已覆盖（默认走计算规则，非 FORMULA 字段）**：子表求和、子表列同行运算用「普通字段 + 计算规则」（`describe datarule.create --example field-compute-rule|field-compute-subtable-sum|field-compute-child-column`）；计算由**门户前端**执行、API 不回填（写测试数据带预算值，正确性人工前台确认）。嵌套子表/MULT_WORK_SHEET/RELEVANCE_DATA 不覆盖。",
+    },
+    {
+        id: "form",
+        title: "默认表单",
+        lane: LANES.form,
+        description: "表单发布链：draft-first 布局、发布、publishedHtmlJson 绑定读回。",
+        operations: ["get", "draft", "publish"],
+        intent: { level: "partial", note: "draft/publish 已声明式；get 为读回面。" },
+    },
+    {
+        id: "listview",
+        title: "列表视图",
+        lane: LANES.listView,
+        description: "列表视图设计时表头与列生命周期。",
+        operations: ["create", "configure", "delete"],
+        intent: { level: "partial", note: "create/configure 与 delete（absent:true）已声明式。" },
+    },
+    {
+        id: "datarule",
+        title: "字段级控件规则",
+        lane: LANES.dataRule,
+        description: "字段级数据规则（bizdatarule）生命周期。",
+        operations: ["create", "update", "delete"],
+        requires: ["field"],
+        intent: { level: "partial", note: "声明式支持字段级规则 create/update 与 delete（absent:true）；规则类型 1..5 与 options 按平台校验器闭环。" },
+        notes: "目标字段必须已发布。",
+    },
+    {
+        id: "businessrule",
+        title: "业务规则（图形引擎，含定时任务）",
+        lane: LANES.businessrule,
+        description: "图形规则（nodeGraph）：触发规则上的动作/条件节点；含**定时任务 TIMING_TASK**（每天/周期）。",
+        operations: ["list", "get", "save"],
+        requires: ["field"],
+        intent: { level: "partial", note: "声明式支持数据事件规则与定时任务：紧凑 actions 或 nodeGraph 透传（BRANCH/BIZ_ACTION/定时图用透传）；写 route.save + rule.enable/disable。" },
+        notes: "数据事件只分发到平台预置 code 行（Create/Update/Delete）；自定义 ruleCode 需按钮/流程/定时/显式触发。**「每天定时执行」= 定时任务 TIMING_TASK（平台原生，非外部定时器、非在线 JS）**：`rule.save` 传含 SCHEDULER 节点 + `schedulerSetting`（`bizRuleType:2`）的 nodeGraph，见 `omc describe rule.save --example rule-timing-task`。保存≠可见，需 rule.enable；绑定 BizMethod 前先有已发布业务集成方法。",
+    },
+    {
+        id: "rule-lifecycle",
+        title: "规则生命周期",
+        lane: LANES.ruleLifecycle,
+        description: "业务规则的启用、停用、删除。",
+        operations: ["enable", "disable", "delete"],
+        requires: ["businessrule"],
+        intent: { level: "none", note: "未覆盖；用 omc call rule.enable / rule.disable / rule.delete。" },
+        notes: "enabled 是运行时真相；status 可能滞后（平台怪癖）。",
+    },
+    {
+        id: "workflow",
+        title: "流程模板",
+        lane: LANES.workflow,
+        description: "流程模板生命周期：get_draft/get_published、create、update、publish、bindRule、delete、workitem.list。",
+        operations: ["create", "update", "publish", "bindRule", "delete"],
+        requires: ["model"],
+        intent: { level: "partial", note: "声明式支持 workflow.create/update/publish 与 bindRules（事件处理器规则绑定，merge/ensure-present）；runtime workitem（提交/审批）仍走 escape hatch。" },
+        notes: "greenfield 首版；publish/bindRule 不得在 ValidateMessage[] 拒绝时报告成功。",
+    },
+    {
+        id: "onlinejs",
+        title: "表单在线 JS",
+        lane: LANES.onlineJs,
+        description: "表单在线 JS：compose 六元素骨架、draftHtmlJson customScript、发布与 SHA-256 读回。",
+        operations: ["compose"],
+        requires: ["form"],
+        intent: { level: "partial", note: "声明式支持 onlinejs.compose 的 source/replace/publish。" },
+        notes: "仅表单在线 JS（BizSheet 子能力）；后端的在线开发（/api/api/programming Java 源码）用二开扩展包，不在本 CLI 范围。",
+    },
+    {
+        id: "bizservice",
+        title: "业务集成",
+        lane: LANES.b2,
+        description: "业务服务与方法注册（RESTFUL/DATA_SQL/DATA_TABLE/SAP/KAFKA/SOAP）、导入导出、设计器测试。",
+        operations: ["register", "update", "delete", "export", "import", "check", "test"],
+        requires: [],
+        intent: { level: "partial", note: "声明式支持新建 service.register（可带一个 method）与既有 service/method 的 update（结构化 config、AES 加密、patch 语义）；删除、给既有服务加方法、分类/连接池/IE 仍走 escape hatch。" },
+        notes: "方法 configJson 走 AES-128-ECB；RESTFUL/DATA_SQL 绑定前须带适配器必需配置（否则是注册壳）。",
+    },
+    {
+        id: "report",
+        title: "报表",
+        lane: LANES.report,
+        description: "报表页 + BI 图表：报表树/元数据读取、报表页建改删、BI dashboard 配置、图表增改删、图表数据查询、数据集读取/关联。",
+        operations: ["tree", "get", "chartdata", "datasource", "create", "update", "delete", "configure"],
+        intent: { level: "partial", note: "顶层 reports[] 声明式 create/update + dashboard configure（global/attributes/charts diff，removeUnlistedCharts 删未声明图表）；delete 走 omc call report.delete，datasource.link/chartdata 走 omc call。" },
+        notes: "报表页走平台通道 /api/api/report/*，BI dashboard/图表/数据走 /dashboard/v1/*（无 errcode 信封；body 必带 config:{token,reportCode,appCode}，缺则写操作静默 no-op）。BI 外层 corpId 是真实查询键（错值→dashboard.not.exist，空→corpid.empty），默认 \"a\"，可用 corpId 覆盖。",
+    },
+    {
+        id: "data",
+        title: "运行数据",
+        lane: LANES.runtimeData,
+        description: "运行数据条目的列出、加载、保存、更新、删除、提交。",
+        operations: ["list", "load", "save", "update", "delete", "submit"],
+        requires: ["field"],
+        intent: { level: "none", note: "未覆盖；用 omc call data.*。" },
+    },
+];
+const COVERAGE_RANK = { executable: 4, partial: 3, "static-only": 2, blocked: 1, unsupported: 0 };
+const CAPABILITY_ALIASES = Object.freeze({
+    environment: ["environment-governance"],
+    app: ["apps", "app-management"],
+    dictionary: ["dictionaries", "dictionary-management"],
+    model: ["models", "model-management"],
+    field: ["fields", "field-families"],
+    form: ["forms", "form-publish-chain"],
+    listview: ["listviews", "list-view"],
+    datarule: ["data-rules", "G1-datarule"],
+    businessrule: ["business-rules", "B1-businessrule"],
+    "rule-lifecycle": ["rule-lifecycles", "S25-rule-lifecycle"],
+    workflow: ["workflows", "W7-S29-greenfield"],
+    onlinejs: ["online-js"],
+    bizservice: ["bizservices", "B2-registration"],
+    report: ["reports", "R1-report"],
+    data: ["runtime-data", "M2-runtime-data"],
+});
+/**
+ * Requirement cues per capability (round 3): the Chinese phrases a requirement
+ * is likely to use for this capability. Authored next to the capability id so
+ * `omc next` has one precise routing surface instead of matching against long
+ * prose. Mirrors the human-readable cue table in
+ * `skills/omc-requirement-vocabulary.md`; this registry is the runtime
+ * authority, the topic is documentation.
+ */
+export const CAPABILITY_CUES = Object.freeze({
+    environment: ["环境", "指纹", "版本", "连接", "登录", "就绪", "发现"],
+    app: ["应用", "门户", "分组"],
+    dictionary: ["字典", "选项来源", "选项", "键值", "树型"],
+    model: ["模型", "对象", "主数据", "物理删除", "汇总表", "统计表", "汇总对象", "月度汇总表", "汇总模型"],
+    field: ["字段", "属性", "子表", "明细", "下拉", "单选", "多选", "附件", "人员", "部门", "日期", "数值", "文本", "关联", "公式", "计算", "计算字段", "求和", "汇总", "合计", "回主表", "超链接", "地址", "表单层", "必填", "只读", "条件必填", "恒必填", "条件只读", "恒只读", "表单必填", "表单只读"],
+    form: ["表单", "页面", "布局", "控件", "只读", "显示"],
+    listview: ["列表", "视图", "查询列", "筛选", "表头", "甘特"],
+    datarule: ["字段级规则", "控件规则", "校验规则", "计算拼接", "显示规则", "规则", "type1", "type2", "type3"],
+    // NOTE: bare "自动" was a cue (round 10 bug: "自动识别"/"自动发邮件" matched
+    // businessrule and routed an UNSUPPORTED ask onto the write ladder). A business
+    // rule is named by 业务规则/触发器/规则图, not by "automatic".
+    businessrule: ["业务规则", "触发器", "规则图", "校验", "事件", "按钮", "定时任务", "定时触发", "定时器", "每天", "每日", "周期执行", "调度", "SCHEDULER", "TIMING_TASK"],
+    "rule-lifecycle": ["启用规则", "停用规则", "删除规则", "规则启停"],
+    workflow: ["流程", "工作流", "审批", "节点", "待办", "流转", "参与人", "审批人", "角色", "部门负责人", "审批角色"],
+    onlinejs: ["在线js", "脚本", "联动", "onload", "onvalidate"],
+    bizservice: ["集成", "接口", "服务", "回调", "对接", "外部系统", "datasql", "restful"],
+    report: ["报表", "图表", "看板", "bi", "dashboard"],
+    data: ["运行数据", "提交数据", "保存记录", "查记录"],
+});
+/**
+ * Boundary cues — authored alongside CAPABILITY_CUES (same runtime authority).
+ *
+ * `next` was pure positive keyword matching, so an ask that names an
+ * OUT-OF-COVERAGE face still matched a nearby capability and got the write
+ * ladder. Round 10 (sandbox): "OCR 单据说平台能不能自动识别" routed to
+ * `businessrule`/write:true — exactly the "invent a capability for a blocked
+ * face" anti-pattern. These cues mirror `omc-requirement-analysis`'s boundary
+ * table (and `omc-requirement-vocabulary.md`) and are checked FIRST: a boundary
+ * hit returns a scout/boundary route (write:false) that points at
+ * `omc-capability-scouting` + `capabilities`, never a build ladder.
+ *
+ * Keep cues SPECIFIC (multi-char, unambiguous): "发布" alone is a supported
+ * workflow action, so the release boundary is "上线"/"生产发布" etc.
+ */
+export const BOUNDARY_CUES = Object.freeze({
+    "ocr-e-signature": {
+        status: "unsupported",
+        cues: ["ocr", "电子签章", "电子签名", "电子签", "发票识别", "识别发票", "票据识别", "单据识别", "图像识别"],
+        note: "OCR / 电子签章不在平台配置覆盖内（boundary-unsupported、unsupported）；不要用业务规则/在线 JS 伪造",
+    },
+    "release-prod": {
+        status: "unsupported",
+        cues: ["上线", "生产发布", "生产环境", "发布环境", "环境发布", "应用发布", "发布上线", "正式发布"],
+        note: "应用发布 / 环境上线 / 生产发布不在 CLI 配置边界内（boundary-unsupported、unsupported）；CLI 只做配置，不做环境发布",
+    },
+    "inline-coding": {
+        status: "unsupported",
+        cues: ["在线开发", "在线编码", "内联代码", "内联编码", "execute_code", "online_develop", "java源码", "后端源码", "二开编码"],
+        note: "在线开发（/api/api/programming Java 源码）/ EXECUTE_CODE / ONLINE_DEVELOP 不在 CLI 内（boundary-unsupported、unsupported）；用二开扩展包",
+    },
+    "nested-child-table": {
+        status: "blocked",
+        cues: ["子表套子表", "嵌套子表", "多级子表"],
+        note: "嵌套子表（子表套子表）在 W6-S27 为 blocked；一级子表可用，嵌套不可",
+    },
+});
+/** The first boundary category whose cue appears in the goal, if any. */
+export function boundaryOf(goal) {
+    const lower = goal.toLowerCase();
+    for (const [id, entry] of Object.entries(BOUNDARY_CUES)) {
+        const cue = entry.cues.find((candidate) => lower.includes(candidate.toLowerCase()));
+        if (cue !== undefined)
+            return { id, status: entry.status, note: entry.note, cue };
+    }
+    return undefined;
+}
+const CAPABILITY_TOPICS = Object.freeze({
+    environment: ["omc-start-here", "omc-write-hazards"],
+    app: ["omc-business-configuration", "omc-write-hazards"],
+    dictionary: ["omc-business-configuration", "omc-tool-selection"],
+    model: ["omc-business-configuration", "omc-config-draft-review"],
+    field: ["omc-business-configuration", "omc-tool-selection"],
+    form: ["omc-business-configuration", "omc-config-draft-review"],
+    listview: ["omc-business-configuration", "omc-tool-selection"],
+    datarule: ["omc-business-configuration", "omc-refusals"],
+    businessrule: ["omc-business-configuration", "omc-refusals"],
+    "rule-lifecycle": ["omc-business-configuration", "omc-refusals"],
+    workflow: ["omc-business-configuration", "omc-refusals"],
+    onlinejs: ["omc-business-configuration", "omc-write-hazards"],
+    bizservice: ["omc-business-configuration", "omc-write-hazards"],
+    report: ["omc-business-configuration", "omc-write-hazards"],
+    data: ["omc-business-configuration", "omc-refusals"],
+});
+/** Strongest coverage status across the lane's manifest items. */
+function coverageOf(manifest, lane) {
+    const items = manifest.items.filter((item) => item.lane === lane);
+    if (items.length === 0)
+        return "unregistered";
+    return items.map((item) => item.status).sort((a, b) => COVERAGE_RANK[b] - COVERAGE_RANK[a])[0];
+}
+function toolsOf(registry, lane) {
+    return registry.filter((tool) => tool.lane === lane).map((tool) => tool.name);
+}
+/** The intent registry is authoritative for the capabilities it covers. */
+function intentCapability(id) {
+    return INTENT_CAPABILITIES.find((capability) => capability.id === id);
+}
+/** Build every Configuration capability node, derived from the live sources. */
+export function buildCapabilityOverview(registry) {
+    const manifest = loadCoverageManifest();
+    const nodes = SURFACES.map((surface) => {
+        const intentCapabilityOfSurface = intentCapability(surface.id);
+        // Two derived slices, one authored slice:
+        // - `requires` is the ordering truth and comes from the intent registry for
+        //   every capability the intent face carries.
+        // - `operations` is the capability's FULL lane operation set (declarative
+        //   subset + escape hatch), authored once here because the wire tools do
+        //   not expose an ordered operation list; `intent.level/note` describe which
+        //   subset is declarative. A test asserts the intent registry's operations
+        //   stay a subset, so the two cannot silently diverge.
+        const requires = surface.requires ?? intentCapabilityOfSurface?.requires ?? [];
+        const operations = surface.operations;
+        return {
+            id: surface.id,
+            nickname: surface.id,
+            title: surface.title,
+            lane: surface.lane,
+            aliases: CAPABILITY_ALIASES[surface.id] ?? [],
+            description: surface.description,
+            coverage: coverageOf(manifest, surface.lane),
+            tools: toolsOf(registry, surface.lane),
+            operations,
+            intent: surface.intent,
+            requires,
+            precedes: [],
+            ...(surface.notes ? { notes: surface.notes } : {}),
+        };
+    });
+    const byId = new Map(nodes.map((node) => [node.id, node]));
+    for (const node of nodes) {
+        for (const requirement of node.requires) {
+            if (!byId.has(requirement))
+                throw new Error(`capability overview: "${node.id}" requires unknown capability "${requirement}"`);
+        }
+    }
+    // Derive the inverse edges so the graph reads both ways.
+    const precedes = new Map(nodes.map((node) => [node.id, []]));
+    for (const node of nodes)
+        for (const requirement of node.requires)
+            precedes.get(requirement).push(node.id);
+    return nodes.map((node) => ({ ...node, precedes: precedes.get(node.id) }));
+}
+/** One full capability node by id. */
+export function capabilityDetail(registry, id) {
+    return buildCapabilityOverview(registry).find((node) => node.id === id);
+}
+export function resolveCapabilityId(id) {
+    if (SURFACES.some((surface) => surface.id === id))
+        return id;
+    return Object.entries(CAPABILITY_ALIASES).find(([, aliases]) => aliases.includes(id))?.[0];
+}
+function dependencyOrder(node, nodes) {
+    const byId = new Map(nodes.map((entry) => [entry.id, entry]));
+    const order = [];
+    const seen = new Set();
+    const visit = (id) => {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        for (const requirement of byId.get(id)?.requires ?? [])
+            visit(requirement);
+        order.push(id);
+    };
+    visit(node.id);
+    return order;
+}
+function routeForNode(node) {
+    const aliases = CAPABILITY_ALIASES[node.id] ?? [];
+    const relatedTopics = CAPABILITY_TOPICS[node.id] ?? [];
+    return {
+        nickname: node.nickname,
+        id: node.id,
+        title: node.title,
+        lane: node.lane,
+        aliases,
+        tools: node.tools,
+        commands: {
+            overview: DISCOVERY_AUTHORITY.capabilityProjection,
+            detail: `omc capability ${node.id}`,
+            executable: `omc capability ${node.id} --executable`,
+            contract: `omc contract ${node.lane}`,
+            readiness: DISCOVERY_AUTHORITY.readiness,
+        },
+        relatedTopics,
+        topicCommands: relatedTopics.map((topic) => `omc help ${topic}`),
+        nextCommands: [
+            DISCOVERY_AUTHORITY.readiness,
+            ...node.requires.map((requirement) => `omc capability ${requirement} --executable`),
+            `omc capability ${node.id} --executable`,
+        ],
+    };
+}
+export function capabilityRouteIndex(registry) {
+    const nodes = buildCapabilityOverview(registry);
+    const routes = nodes.map(routeForNode);
+    return {
+        routes,
+        nodeById: new Map(nodes.map((node) => [node.id, node])),
+        routeByLane: new Map(routes.map((route) => [route.lane, route])),
+    };
+}
+export function capabilityRoutes(registry) {
+    return capabilityRouteIndex(registry).routes;
+}
+export function capabilityRouteForLane(registry, lane) {
+    return capabilityRouteIndex(registry).routeByLane.get(lane);
+}
+export function capabilityRouteForTool(registry, toolName) {
+    const tool = registry.find((entry) => entry.name === toolName);
+    return tool?.lane === undefined ? undefined : capabilityRouteForLane(registry, tool.lane);
+}
+export function executableCapabilityBundle(registry, id) {
+    const resolvedId = resolveCapabilityId(id);
+    if (!resolvedId)
+        return undefined;
+    const nodes = buildCapabilityOverview(registry);
+    const node = nodes.find((entry) => entry.id === resolvedId);
+    if (!node)
+        return undefined;
+    const tools = registry.filter((tool) => tool.lane === node.lane);
+    // Round 13: the per-tool entry used to store the same recipe set three ways —
+    // `executionMetadata.recipes`, `recipes`, and the derived `readback` /
+    // `refusalRecovery` slices. That triplication made `capability <id>
+    // --executable` 34 KB (field) with 31 KB in `orderedTools` alone, read once
+    // and re-sent every later turn. `recipes` is the single copy: readback and
+    // refusal recovery are fields of each recipe, and `executionMetadata` held
+    // nothing but recipes + relatedTools (now folded into `relatedTools`).
+    const orderedTools = tools.map((tool) => {
+        const metadata = tool.executionMetadata;
+        const recipes = metadata?.recipes ?? [];
+        return {
+            name: tool.name,
+            lane: node.lane,
+            schemaRef: `omc describe ${tool.name}`,
+            relatedTools: metadata?.relatedTools ?? [],
+            recipeRefs: recipes.map((recipe) => recipe.id),
+            recipes,
+        };
+    });
+    const availableTopics = new Set(listSkills().map((topic) => topic.name));
+    const relatedTopics = (CAPABILITY_TOPICS[node.id] ?? []).filter((topic) => availableTopics.has(topic));
+    const routing = { ...routeForNode(node), relatedTopics, topicCommands: relatedTopics.map((topic) => `omc help ${topic}`) };
+    return {
+        ...node,
+        dependencyOrder: dependencyOrder(node, nodes),
+        coverageBoundary: {
+            status: node.coverage,
+            lane: node.lane,
+            intent: node.intent,
+            notes: node.notes ?? null,
+        },
+        orderedTools,
+        governance: {
+            readOnly: true,
+            static: true,
+            environmentContact: false,
+            writeGate: "tool execution still requires environment writable permission and production confirmation when applicable",
+            dryRun: { supported: true, command: "omc call <tool> --dry-run --args '<json>'" },
+            output: { defaultMaxBytes: 64 * 1024, oversized: "artifact reference with artifactId and sha256" },
+        },
+        relatedTopics,
+        routing,
+        nextCommands: routing.nextCommands,
+    };
+}
+/**
+ * A compact projection for `omc capabilities` — no prose, no wire detail.
+ *
+ * Round 13: it used to give every one of the 14 capabilities its own `commands`
+ * block (3.2 KB of mechanical strings: `omc capability <id>` etc.) and a
+ * `nickname` that was always equal to `id` (153 B). Both are derivable from
+ * `id`/`lane`, so they move to one top-level `commands` template block and the
+ * node keeps only `id`. The capability id/lane/tools/order/coverage truth is
+ * unchanged; only the repetition is gone.
+ */
+export function compactCapabilities(registry) {
+    const index = capabilityRouteIndex(registry);
+    return {
+        status: "ok",
+        discovery: DISCOVERY_AUTHORITY,
+        // Size hint (dogfood R1): `capabilities` is ~6 KB, not a "safe small" face.
+        // Keep it a one-line pointer so it does not perturb the discovery-budget
+        // baseline more than a hair.
+        outputHint: "~6KB 非安全小档；next 已给路线时可省，单能力用 omc capability <id>",
+        commands: {
+            detail: "omc capability <id>",
+            executable: "omc capability <id> --executable",
+            contract: "omc contract <lane>",
+            readiness: DISCOVERY_AUTHORITY.readiness,
+        },
+        capabilities: index.routes.map((route) => ({
+            id: route.id,
+            title: route.title,
+            lane: route.lane,
+            aliases: route.aliases,
+            tools: route.tools,
+            relatedTopics: route.relatedTopics,
+            requires: index.nodeById.get(route.id)?.requires ?? [],
+            precedes: index.nodeById.get(route.id)?.precedes ?? [],
+            intent: index.nodeById.get(route.id)?.intent.level ?? "none",
+            coverage: index.nodeById.get(route.id)?.coverage ?? "unregistered",
+        })),
+    };
+}
+//# sourceMappingURL=capability-overview.js.map

package/dist/capability-shape.js

@@ -0,0 +1,154 @@
+export const CAPABILITY_CONTROL_TYPES = Object.freeze({
+    0: 1,
+    1: 2,
+    2: 4,
+    3: 3,
+    4: 8,
+    5: 62,
+    6: 9,
+    8: 201,
+    9: 80,
+    10: 14,
+    11: 81,
+    12: 5,
+    13: 6,
+    14: 7,
+    15: 19,
+    16: 82,
+    17: 17,
+    28: 28,
+    50: 50,
+    51: 51,
+    60: 60,
+    61: 61,
+    100: 89,
+});
+const commonEvidence = [
+    "8.6.26 BizPropertyType/BizFormPropertyType",
+    "desensitized-config-shapes.md §3.2",
+    "frontend-dist/admin/js/4280.*.js designer bundle",
+];
+const shape = (propertyType, field, control, evidence = commonEvidence) => ({ propertyType, controlType: CAPABILITY_CONTROL_TYPES[propertyType], field, control, evidence });
+const face = (requiredKeys, defaults, evidence = commonEvidence, nonEmptyKeys) => ({ requiredKeys, defaults, evidence, ...(nonEmptyKeys ? { nonEmptyKeys } : {}) });
+export const FIELD_CAPABILITY_SHAPES = Object.freeze({
+    0: shape(0, face([], { dictionaryData: "" }), face(["defaultValue", "maxLength"], { defaultValue: null, placeholder: "请输入", maxLength: 200, currentMaxLength: 2000000, noRepeat: false, enableEncrypt: false })),
+    1: shape(1, face([], { dictionaryData: "" }), face(["defaultValue", "maxLength"], { defaultValue: null, textAreaType: "longText", maxLength: 2000, placeholder: "请输入" })),
+    2: shape(2, face([], { dictionaryData: "" }), face(["defaultValue", "format"], { defaultValue: null, placeholder: "请输入", computeFormula: "", format1: "decimal", format: "decimal", verifyFormula: "", isFlag: false })),
+    3: shape(3, face(["format"], { dictionaryData: "", format: "YYYY-MM-DD" }), face(["format", "format1"], { defaultValue: null, dataItemDefault: "", format1: "YYYY-MM-DD", format: "YYYY-MM-DD", minDate: "", maxDate: "", verifyFormula: "" })),
+    4: shape(4, face(["defaultValue"], { defaultValue: false }), face(["defaultValue"], { defaultValue: true })),
+    6: shape(6, face([], {}), face(["displayTemplate", "limitNumber", "fileNumber", "batch"], { displayTemplate: true, limitNumber: "unlimited", fileNumber: 1, batch: true, displayFormula: "", requiredFormula: "", readonlyFormula: false, limit: "200M", onUpload: "", onDelete: "" }), ["cp-sources/frontend-dist/admin/js/12404.1675d362.js attachment schema", "cp-sources/frontend-dist/admin/js/24187.6e75bd30.js uploadOptions/baseUploadOptions"]),
+    // CHILD_TABLE(8) — scalar child table. Lifted from blocked on 2026-09-18:
+    // the wire shape is live-accepted (omc-core `childtable-field-contract.ts`,
+    // live record `childtable-execute-20260908070635135.md`, 2026-09-08) and the
+    // Sheet201 form control is live-proven (omc-core
+    // `childtable-sheet201-contract.ts`). The field row carries no `options`; its
+    // definition is the `subSchema` ({code:<parent field code>, properties:[...]})
+    // and the form control is Sheet(201) with `columns`. Nested CHILD_TABLE (a
+    // child of a child) remains out of coverage and is refused in
+    // `assertFieldFamilyAllowed`.
+    8: shape(8, face([], {}), face([], {}), ["omc-core childtable-field-contract.ts (live 2026-09-08)", "omc-core childtable-sheet201-contract.ts", "8.6.26 BizPropertyType CHILD_TABLE=8 / BizFormPropertyType Sheet=201"]),
+    9: shape(9, face([], { dictionaryData: "" }), face([], { schemaCode: "", displayField: "name", relativePropertyMatchCode: "name", queryCode: "", linkMode: true, showStyle: "", selectMode: "popup", isAuthorize: true, treeView: false, treeStartFromRoot: false, mappings: "", searchFormula: "", conditions: "" })),
+    10: shape(10, face(["defaultValue"], { defaultValue: "" }), face(["locationType", "addressDetail", "showEmpty", "emptyValue", "autoGetLocation"], { locationType: "pp-cc-aa", addressDetail: "true", showEmpty: "false", emptyValue: "请选择", autoGetLocation: "false" }), [".scratch/omc-app-management/research/desensitized-config-shapes.md §3.2 ADDRESS", "cp-sources/frontend-dist/admin/js/12404.1675d362.js address schema", ".scratch/omc-app-management/evidence/field-families-fwb-20260914.md:113-119 (fwb field row {\"defaultValue\":\"\",\"virtualField\":false})"]),
+    11: shape(11, face([], { dictionaryData: "" }), face([], { schemaCode: "", displayField: "name", relativePropertyMatchCode: "name", queryCode: "", linkMode: true, showStyle: "", selectMode: "popup", isAuthorize: true, treeView: false, treeStartFromRoot: false, mappings: "", searchFormula: "", conditions: "" })),
+    // Ticket 108 determination: selection families (12/13/14/15) emit NO
+    // dictionaryData — designer-produced rows carry none of it (fwb §12-15
+    // outer key unions) and live 8.6.26 proves the platform merely
+    // accepts-and-persists the extra key without requiring it. The other
+    // text/date/relation families keep the designer-carried empty-string
+    // default; ATTACHMENT(6) stays intentionally empty (system rows often
+    // have no options). The wider 2026-09-14 key unions are multi-field
+    // unions of designer rows — platform auto-fill territory, never required
+    // for creation (minimal default + caller passthrough is the boundary).
+    12: shape(12, face([], {}), face([], { defaultValue: "", options: "", hasLabel: false })),
+    13: shape(13, face([], {}), face([], { defaultValue: "", options: "", hasLabel: false, direction: "horizontal", displaySetting: "showSelected" })),
+    14: shape(14, face([], {}), face([], { displayEmpty: true, emptyValue: "请选择", multi: false })),
+    15: shape(15, face([], {}), face([], { displayEmpty: true, emptyValue: "请选择", multi: true })),
+    16: shape(16, face([], { dictionaryData: "" }), face([], {})),
+    17: shape(17, face(["defaultValue", "dictionaryData", "maxLength"], { defaultValue: "", dictionaryData: "", maxLength: 200 }), face(["defaultValue", "placeholder", "maxLength"], { defaultValue: "", placeholder: "请输入", maxLength: 200 }), [".scratch/omc-app-management/research/desensitized-config-shapes.md §3.2 HYPER_LINK", "cp-sources/frontend-dist/admin/js/12404.1675d362.js URL schema"]),
+    28: shape(28, face(["format"], { defaultValue: "", format: "HH:mm" }), face(["format", "format1"], { defaultValue: "none", dataItemDefault: "", format: "HH:mm", format1: "HH:mm", syncFormate: true }), [".scratch/omc-app-management/research/desensitized-config-shapes.md §3.2 TIME", "cp-sources/frontend-dist/admin/js/46948.4825f4e2.js Time1760153573819"]),
+    // Org-selector families. Evidence: the yst/fwb published-face dumps
+    // (origin/research/yst-examples, 2656 rows of types 5/50/51/60/61) show the
+    // FIELD row (bizproperty) options as null or `{defaultValue, mappings,
+    // virtualField, noRepeat}` — deptVisible/multi NEVER appear there. The
+    // deptVisible/multi discriminator is FORM-CONTROL-face only (source:
+    // DataModelInitUtils.updateSelectionType / BizPropertyTypeUpdateUtils.
+    // disposeUpdateType read `control.options`; ticket 69 already writes them on
+    // the control face). Field faces below mirror the observed publish-safe
+    // shapes (single: defaultValue ""; multi: defaultValue []).
+    5: shape(5, face([], { defaultValue: [], mappings: "", virtualField: false }), face(["defaultValue", "deptVisible", "multi"], { defaultValue: [], defaultValueType: "", deptVisible: "all", multi: "true" })),
+    50: shape(50, face([], { defaultValue: "", mappings: "", virtualField: false }), face(["deptVisible", "multi"], { deptVisible: "user", multi: "false" })),
+    51: shape(51, face([], { defaultValue: [], mappings: "", virtualField: false }), face(["deptVisible", "multi"], { deptVisible: "user", multi: "true" })),
+    60: shape(60, face([], { defaultValue: [], mappings: "", virtualField: false }), face(["deptVisible", "multi"], { deptVisible: "org", multi: "false" })),
+    61: shape(61, face([], { defaultValue: [], mappings: "", virtualField: false }), face(["deptVisible", "multi"], { deptVisible: "org", multi: "true" })),
+    100: shape(100, face([], {}), face([], { defaultValue: null })),
+});
+export const BLOCKED_CAPABILITY_SHAPES = Object.freeze({});
+/**
+ * Ticket 101 — control codes observed in real forms but with NO field-family
+ * emission path. PHONE(24) and PHOTO(10) are authoritative 8.6.26 control
+ * codes (BizFormPropertyType.java:23-51), but BizPropertyType.java:27-54 has
+ * no PHONE/PHOTO entry, so no accepted field family can scaffold them and no
+ * options shape is evidenced for a write. Declared blocked so the absence
+ * reads as policy (fail-closed), not omission; caller-provided explicit
+ * layouts are unaffected. Adding an emission path requires new family
+ * evidence AND consciously lifting this declaration.
+ */
+export const BLOCKED_CONTROL_CODES = Object.freeze({
+    24: "PHONE control has no BizPropertyType mapping (BizPropertyType.java:27-54) — no field family emits it; creation not offered until a family + options shape are evidenced",
+    10: "PHOTO control has no BizPropertyType mapping (BizPropertyType.java:27-54) — no field family emits it; creation not offered until a family + options shape are evidenced",
+});
+export const CAPABILITY_SHAPE_ACCEPTED_TYPES = Object.freeze(Object.keys(FIELD_CAPABILITY_SHAPES).map(Number));
+export function capabilityShapeFor(type) {
+    return FIELD_CAPABILITY_SHAPES[type] ?? BLOCKED_CAPABILITY_SHAPES[type];
+}
+export function capabilityShapeError(type, faceName, options) {
+    const current = capabilityShapeFor(type);
+    if (!current)
+        return `propertyType ${type} has no capability shape`;
+    if (current.blocked)
+        return `${current.citation ?? "blocked capability"} (propertyType ${type})`;
+    const face = current[faceName];
+    const missing = face.requiredKeys.filter((key) => options[key] === undefined || ((face.nonEmptyKeys ?? []).includes(key) && options[key] === ""));
+    return missing.length > 0 ? `capability shape ${faceName} missing required keys for propertyType ${type}: ${missing.join(", ")}` : undefined;
+}
+export function assertCapabilityShapeContract() {
+    for (const type of CAPABILITY_SHAPE_ACCEPTED_TYPES) {
+        const current = FIELD_CAPABILITY_SHAPES[type];
+        if (!current)
+            throw new Error(`capability shape missing for propertyType ${type}`);
+        if (current.blocked && !current.citation)
+            throw new Error(`blocked capability shape ${type} requires citation`);
+        if (current.controlType !== CAPABILITY_CONTROL_TYPES[type])
+            throw new Error(`capability shape control type mismatch for ${type}`);
+        for (const key of current.field.requiredKeys)
+            if (!(key in current.field.defaults))
+                throw new Error(`field shape ${type} missing default for ${key}`);
+        for (const key of current.control.requiredKeys)
+            if (!(key in current.control.defaults))
+                throw new Error(`control shape ${type} missing default for ${key}`);
+    }
+}
+export function assertCapabilityFace(type, faceName, options) {
+    const current = capabilityShapeFor(type);
+    if (!current)
+        throw new Error(`capability shape missing for propertyType ${type}`);
+    if (current.blocked)
+        throw new Error(`propertyType ${type} is blocked: ${current.citation ?? "missing evidence"}`);
+    const face = current[faceName];
+    const missing = face.requiredKeys.filter((key) => options[key] === undefined || ((face.nonEmptyKeys ?? []).includes(key) && options[key] === ""));
+    if (missing.length > 0)
+        throw new Error(`capability shape ${faceName} missing required keys for propertyType ${type}: ${missing.join(", ")}`);
+}
+export function deriveFieldOptions(type, explicit) {
+    const current = capabilityShapeFor(type);
+    if (!current || current.blocked)
+        throw new Error(`propertyType ${type} is blocked or has no capability shape`);
+    return { ...current.field.defaults, ...(explicit ?? {}) };
+}
+export function deriveControlOptions(type, explicit) {
+    const current = capabilityShapeFor(type);
+    if (!current || current.blocked)
+        throw new Error(`propertyType ${type} is blocked or has no capability shape`);
+    return { ...current.control.defaults, ...(explicit ?? {}) };
+}
+//# sourceMappingURL=capability-shape.js.map