@stalfh233/omc-cli 0.4.66 → 0.4.68

package/dist/cli-output.js

@@ -1,6 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { asciiStdout, serializeEnvelope } from "./cli-contract.js";
-import { recordUsageOutput } from "./usage-log.js";
+import { currentUsageCommand, priorRepeatedFailures, recordUsageOutput } from "./usage-log.js";
 let options = { quiet: false, verbose: false };
 /** Parse `--quiet`, `--verbose` and `--out <file>` from the raw argv once, before dispatch. */
 export function configureOutput(argv) {
@@ -85,8 +85,38 @@ function emitAsciiBannerOnce() {
     // 横幅走 stderr（不进管道、不破坏单信封契约），在痛点时刻给出两个解法。
     process.stderr.write("[omc] 当前控制台代码页非 UTF-8，中文已 ASCII 转义防乱码。要原样中文：本次调用加 --utf8，或 chcp 65001 后重跑，或设 OMC_ASCII_STDOUT=0。\n");
 }
+/**
+ * Attach a repeat warning to a refusal that repeats the previous one. Refusal
+ * envelopes already say what is wrong; a third identical failure means the
+ * caller is tuning arguments inside a dead end (r6-onboarding 2026-10-21: 16
+ * repeat runs, 27 avoidable calls), so say so where it will be read.
+ */
+function withRepeatWarning(value) {
+    if (!value || typeof value !== "object")
+        return value;
+    const envelope = value;
+    const status = String(envelope.status ?? "");
+    if (status !== "refused" && status !== "error" && status !== "uncertain")
+        return value;
+    const result = envelope.result && typeof envelope.result === "object" ? envelope.result : undefined;
+    const blocker = typeof result?.blocker === "string" ? result.blocker : typeof envelope.blocker === "string" ? envelope.blocker : undefined;
+    const prior = priorRepeatedFailures(currentUsageCommand(), blocker);
+    if (prior.count < 2)
+        return value;
+    const repeatWarning = {
+        sameFailureCount: prior.count + 1,
+        blocker: blocker ?? null,
+        ...(prior.requestIds.length > 0 ? { previousRequestIds: prior.requestIds } : {}),
+        hint: status === "uncertain"
+            ? `同一调用已连续返回 uncertain ${prior.count + 1} 次。uncertain 表示结果未确定：先按 requestId 回读真实状态再决定，不要盲目重发写请求。`
+            : `同一调用已连续失败 ${prior.count + 1} 次（blocker ${blocker ?? "unknown"}）。不要再微调参数重试：换形状或换工具——先 describe/配方确认契约，或按 blocker 指向的替代路径处理。`,
+    };
+    if (result)
+        return { ...envelope, result: { ...result, repeatWarning } };
+    return { ...envelope, repeatWarning };
+}
 export function writeEnvelope(value) {
-    const outputValue = compactForOutput(value);
+    const outputValue = compactForOutput(withRepeatWarning(value));
     const text = serializeEnvelope(outputValue);
     if (asciiStdout())
         emitAsciiBannerOnce();

package/dist/cli.js

@@ -499,9 +499,16 @@ async function cmdArtifactGet(id, transport, options = {}) {
                 ? { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available, hint: `路径未命中段 "${projected.at}"——available 是该层可用的键/范围；方括号下标（a[0]）与点式（a.0）等价` }
                 : { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: projected.value ?? null }, transport);
         }
-        const result = { status: "ok", artifactId: id, sha256: artifact.sha256, content };
+        // r6-onboarding 2026-10-21: 47 artifact fetches, 0 used a projection; the 10
+        // large ones (up to 55 KB) pulled whole workflow templates just to read one
+        // nested key. Nudge once, in the same response, instead of hoping the hint
+        // in `fetch` is noticed.
+        const unprojected = artifact.content.length > 8192
+            ? { hint: `artifact ${Math.round(artifact.content.length / 1024)}KB 已整包返回。只要其中一段时用 --jq '<path>'（或 --summary 看形状、--keys 取顶层键），不要把整包带进上下文。` }
+            : {};
+        const result = { status: "ok", artifactId: id, sha256: artifact.sha256, content, ...unprojected };
         if (Buffer.byteLength(JSON.stringify(result), "utf8") > transport.maxOutputBytes)
-            return emitTransportResult({ status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, fetch: artifactFetchHint(id) }, transport);
+            return emitTransportResult({ status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, ...unprojected, fetch: artifactFetchHint(id) }, transport);
         return emitTransportResult(result, transport);
     }
     catch (error) {

package/dist/lanes/workflow.js

@@ -2226,10 +2226,18 @@ export function registerWorkflowLane(tools) {
                     schemaCode: linked?.schemaCode ?? wireString(item.schemaCode),
                 };
             });
+            // r6-onboarding 2026-10-21: 89 of 117 calls used this tool with only a
+            // schemaCode — mostly to ask "where did the flow go", which the todo query
+            // cannot answer (it lists pending items only). Say what this call is for
+            // at the moment it is used, and name the two substitutes.
+            const purposeHint = args.workflowInstanceId === undefined && args.workflowCode === undefined
+                ? "本调用用于发现待办并取 workItemId 做审批；只想看流程走到哪，用 workflow.instanceActivity；提交/审批后优先复用 data.submit 的 readback.nextSubmit，不要重复查询。"
+                : undefined;
             return {
                 total: page.total,
                 totalPages: page.totalPages,
                 count: items.length,
+                ...(purposeHint ? { purposeHint } : {}),
                 ...(page.unfilteredTotal !== undefined ? { unfilteredTotal: page.unfilteredTotal } : {}),
                 items,
             };

package/dist/usage-log.js

@@ -1,4 +1,4 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, openSync, readFileSync, readSync, closeSync, statSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { dirname, resolve } from "node:path";
 let pending;
@@ -9,6 +9,47 @@ function logPath() {
     const projectEnv = resolve(process.cwd(), ".omc-env");
     return existsSync(projectEnv) ? resolve(process.cwd(), ".omc", "usage.jsonl") : undefined;
 }
+/** The command string of the in-flight invocation (for diagnostics). */
+export function currentUsageCommand() {
+    return pending?.command;
+}
+/**
+ * How many consecutive PRIOR invocations failed the same way. A refusal tells
+ * the caller what is wrong; three identical refusals in a row mean the caller is
+ * tuning arguments inside a dead end instead of changing approach (r6-onboarding
+ * 2026-10-21: 16 such runs, 43 calls, 27 of them avoidable).
+ */
+export function priorRepeatedFailures(command, blocker, limit = 40) {
+    if (!command)
+        return { count: 0, requestIds: [] };
+    const path = logPath();
+    if (!path)
+        return { count: 0, requestIds: [] };
+    // Read only the tail: this runs on every refusal, and the log grows with the
+    // session (r6: 1528 records). Parsing the last ~64 KB is enough for `limit`.
+    const tail = readUsageTail(path, 65536).slice(-limit);
+    const matches = (record) => {
+        if (String(record.command ?? "") !== command)
+            return false;
+        const status = String(record.status ?? "");
+        if (status === "ok" || status === "dry-run" || status === "no-envelope")
+            return false;
+        if (blocker === undefined)
+            return true;
+        return String(record.blocker ?? "") === blocker;
+    };
+    let count = 0;
+    const requestIds = [];
+    for (let index = tail.length - 1; index >= 0; index -= 1) {
+        if (!matches(tail[index]))
+            break;
+        count += 1;
+        const requestId = tail[index].requestId;
+        if (typeof requestId === "string" && requestIds.length < 3)
+            requestIds.push(requestId);
+    }
+    return { count, requestIds };
+}
 function commandOf(argv) {
     const values = [];
     for (let index = 2; index < argv.length && values.length < 2; index += 1) {
@@ -91,6 +132,12 @@ export function recordUsageOutput(value, stdoutBytes, fileBytes = 0) {
     pending.status = String(envelope.status ?? "unknown");
     if (typeof error?.code === "string")
         pending.errorCode = error.code;
+    // The blocker is the actionable half of a refusal (policy-refused alone says
+    // nothing); record it so repeat detection and accounting can group by cause.
+    const resultEnvelope = envelope.result && typeof envelope.result === "object" ? envelope.result : undefined;
+    const blocker = typeof resultEnvelope?.blocker === "string" ? resultEnvelope.blocker : typeof envelope.blocker === "string" ? envelope.blocker : undefined;
+    if (blocker)
+        pending.blocker = blocker;
     // 0.4.16：requestId 落盘（信封瘦身把它从 stdout 移除后，排障关联的唯一落点）
     if (typeof envelope.requestId === "string")
         pending.requestId = envelope.requestId;
@@ -118,10 +165,37 @@ export function completeUsage(exitCode) {
         status: current.status,
         exitCode,
         ...(current.errorCode ? { errorCode: current.errorCode } : {}),
+        ...(current.blocker ? { blocker: current.blocker } : {}),
         ...(current.requestId ? { requestId: current.requestId } : {}),
     };
     appendFileSync(path, `${JSON.stringify(record)}\n`, "utf8");
 }
+function readUsageTail(path, maxBytes) {
+    if (!existsSync(path))
+        return [];
+    const size = statSync(path).size;
+    const start = Math.max(0, size - maxBytes);
+    const fd = openSync(path, "r");
+    try {
+        const buffer = Buffer.alloc(size - start);
+        readSync(fd, buffer, 0, buffer.length, start);
+        const text = buffer.toString("utf8");
+        // Drop a leading partial line when the tail started mid-record.
+        const body = start > 0 ? text.slice(text.indexOf("\n") + 1) : text;
+        return body.split(/\r?\n/).filter(Boolean).flatMap((line) => {
+            try {
+                const value = JSON.parse(line);
+                return value && typeof value === "object" ? [value] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 function readUsage(path) {
     if (!existsSync(path))
         return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.4.66",
+  "version": "0.4.68",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -50,9 +50,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@stalfh233/omc-fake-platform": "0.4.66",
+    "@stalfh233/omc-fake-platform": "0.4.68",
     "commander": "14.0.3",
-    "omc-core": "0.4.66",
+    "omc-core": "0.4.68",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",

package/skills/omc-business-configuration.md

@@ -150,6 +150,8 @@ rules:
 
 - **两条路**：模型+表单+流程一揽子交付走**意图**（`intent` 的 `workflow` 能力，声明式一次 apply）；只动流程或想逐步控制走**低层链** `workflow.create → workflow.update（权限/节点）→ workflow.publish`，标准链配方见 `omc describe workflow.update`（含多级审批/participant 三形态/自动回填说明）。流程权限细节见下节。
 - 一个模型只能有一个流程；已有流程的模型直接 `workflow.update`，不要另建。
+- **清理测试数据用批量删除**：`data.delete --args '{"schemaCode":"<code>","bizObjectIds":["id1","id2"]}'` 一次往返删多条（真机 r6：207 次逐条 `data.delete` 占 13.5% 调用）。
+- **取 artifact 先投影**：`artifact get <id> --summary` 看形状 → `--jq '<path>'` 取那一段；只有确实要整份时才裸取（r6：47 次整包拉取 650KB，0 次用投影）。
 - **核验状态用投影，别重复整条读**：`data.load --args '{"schemaCode":..,"bizObjectId":..,"fields":["sequenceStatus","<业务状态字段>"]}'` 只回指定字段（缺失项在 `missingFields`）——r4 实测同一对象被整条读 74 次；大结果先 `artifact get <id> --summary` → `--keys/--jq`，别整包内联进推理。
 - **流程第一个节点必须是 `{Originator}` 填写节点**：平台 `WorkflowTemplateValidateUtility.validateStartActivity` 对「START 后直接接审批」报 401035「发起节点的参与者只能是{Originator}」，publish 回 errcode 0 但一个 ValidateMessage[] 就把模板挡在门外、不落库（真机 2026-10-21）。OMC 0.4.65 起在 `workflow.update`/`publish` 出门前拒绝（`workflow-first-activity-not-originator`）。
 - **跨模型回写的目标行必须已提交（COMPLETED）**：DRAFT 行不参与目标查询，运行 0 行命中且日志只有「查找范围不存在数据」。单跳关联字段可直接作 DYNAMIC 来源（引擎取关联对象 id）；点号路径按子表解析，`关联字段.id` / 两跳路径都不支持。