oh-my-knowledge 1.0.0-beta.4 → 1.0.0-beta.6

package/README.md

@@ -22,6 +22,16 @@ Observe real-world performance, measure version differences, and determine wheth
 
 📖 **Full documentation: [oh-my-knowledge.pages.dev](https://oh-my-knowledge.pages.dev)** (searchable, English / 简体中文)
 
+## What knowledge means in OMK
+
+**Entities are the things knowledge describes; knowledge expresses their states, relationships, or actions in a specific context.**
+
+**How knowledge is expressed:**
+
+> **Time scope + scenario + conditions + entity A + relation or action + entity B (if any)**
+
+See [How OMK understands knowledge](docs/explanation/knowledge.md) for entity roles, shared relationships, and the distinction between knowledge and its carriers. Entity-based retrieval remains a design direction.
+
 ## What OMK helps you know
 
 | Decision | Command | Evidence you get |
@@ -35,6 +45,8 @@ Observe real-world performance, measure version differences, and determine wheth
 
 ## Quick start
 
+Already have a Node.js service, retriever, or Agent? Start with [Use OMK in your service](docs/guides/eval-runtime.md): run an example without model credentials, choose a scorer, connect your service, and read the results. The command-line quickstart follows below.
+
 ```bash
 npm i -g oh-my-knowledge
 omk init demo && cd demo
@@ -228,7 +240,7 @@ The full docs are published at **[oh-my-knowledge.pages.dev](https://oh-my-knowl
 - **[CLI reference](docs/reference/cli.md)** — all top-level commands with bash examples and flag tables
 - **[Migrate to the 1.0 preview](docs/guides/v1-preview-migration.md)** — install channel, storage reset, sample protocol, CLI automation, and embedded API changes since 0.54
 - **[Evaluation Core cutover](docs/guides/eval-core-cutover.md)** — `BREAKING-SCHEMA` storage, resume, Studio, Gold, managed-evidence, and evolve migration
-- **[Embed OMK in a service](docs/guides/eval-runtime.md)** — canonical `evaluate()` plus repeat-run `evaluateSeries()` for Node.js and FaaS hosts
+- **[Embed OMK in a service](docs/guides/eval-runtime.md)** — choose a scorer, connect a Node.js service, and interpret scores and failures
 - **[Storage layout v2](docs/specs/storage-layout-spec.md)** — project/global domains, compatibility boundary, and Git policy
 - **[Executors](docs/reference/executors.md)** & **[artifact layout](docs/reference/artifact-layout.md)** — built-in / custom executors; how `variant` resolves to an artifact + runtime context
 - **[How-to guides](docs/guides/agent-eval.md)** — [evaluate an agent](docs/guides/agent-eval.md) (project runtime context) and [use non-Claude models](docs/guides/non-claude-models.md) (GLM / Qwen / DeepSeek / Moonshot / Ollama)

package/README.zh.md

@@ -22,6 +22,16 @@
 
 📖 **完整文档：[oh-my-knowledge.pages.dev/zh](https://oh-my-knowledge.pages.dev/zh/)**（可搜索，可切换英文）
 
+## OMK 中的知识是什么
+
+**实体是知识所描述的事物；知识表达实体在特定上下文中的状态、关系或行为。**
+
+**知识的表达形式：**
+
+> **时间范围＋场景＋条件＋实体 A＋关系或行为＋实体 B（如有）**
+
+实体角色、多实体关联及知识与载体的区别，见[OMK 如何理解知识](docs/zh/explanation/knowledge.md)。实体关联检索仍是设计方向。
+
 ## OMK 让你知道什么
 
 | 决策问题 | 命令 | 你会得到的证据 |
@@ -35,6 +45,8 @@
 
 ## 快速开始
 
+已有 Node.js 服务、检索系统或 Agent，希望接入评分与版本对比？从[在服务中使用 OMK](docs/zh/guides/eval-runtime.md)开始：先运行无需模型凭证的示例，再选择评分方法、接入自己的服务并解读结果。下面是命令行上手流程。
+
 ```bash
 npm i -g oh-my-knowledge
 omk init demo && cd demo
@@ -228,7 +240,7 @@ omk-mcp
 - **[CLI 参考](docs/zh/reference/cli.md)** —— 顶层命令的 bash 示例和 flag 表
 - **[迁移到 1.0 预览版](docs/zh/guides/v1-preview-migration.md)** —— 从 `0.54` 升级时的安装渠道、存储重建、用例协议、CLI 自动化与嵌入式 API 变化
 - **[Evaluation Core 生产切换](docs/zh/guides/eval-core-cutover.md)** —— `BREAKING-SCHEMA` 存储、resume、Studio、Gold、受管证据与 evolve 迁移
-- **[在服务中嵌入 OMK](docs/zh/guides/eval-runtime.md)** —— 面向 Node.js 与 FaaS 宿主的 canonical `evaluate()` 与重复运行 `evaluateSeries()`
+- **[在服务中嵌入 OMK](docs/zh/guides/eval-runtime.md)** —— 选择评分方法、接入 Node.js 服务、解读分数与失败原因
 - **[存储布局 v2](docs/zh/specs/storage-layout-spec.md)** —— 项目／全局领域、迁移兼容与 Git 策略
 - **[执行器](docs/zh/reference/executors.md)** & **[知识载体布局](docs/zh/reference/artifact-layout.md)** —— 内置 / 自定义执行器；variant 如何解析为 artifact + runtime context
 - **[操作指南](docs/zh/guides/agent-eval.md)** —— [评测 agent](docs/zh/guides/agent-eval.md)（项目 runtime context）与[使用非 Claude 模型](docs/zh/guides/non-claude-models.md)（GLM / 通义 / DeepSeek / Moonshot / Ollama）

package/dist/cli/commands/eval/index.js

@@ -160,6 +160,10 @@ async function runEval(_args, flags, lang) {
             process.stdout.write(`Core: ${outcome.status?.runStatus ?? 'prepared'}／${outcome.status?.evidenceStatus ?? 'n/a'}／${outcome.status?.conclusionStatus ?? 'n/a'}\n`
                 + `Gate: ${outcome.gate?.gateStatus ?? 'not-applicable'}${outcome.gate?.reasonCodes?.length ? `（${outcome.gate.reasonCodes.join(', ')}）` : ''}\n`);
         }
+        // A blocked gate exits immediately through oclif; flush a piped JSON report first.
+        await new Promise((resolve, reject) => {
+            process.stdout.write('', (error) => error ? reject(error) : resolve());
+        });
         throw new CliExit(result.exitCode);
     }
     catch (err) {

package/dist/cli/commands/install.js

@@ -6,7 +6,7 @@ import { Args, Flags } from '@oclif/core';
 import { LANG_FLAG, bilingual } from '../oclif/i18n.js';
 import { BaseCommand } from '../oclif/base-command.js';
 import { tCli } from '../lib/i18n.js';
-import { resolveInstallSource, resolveRemoteGitSource, SourceResolveError } from '../../eval-workflows/inputs/source-resolver.js';
+import { resolveInstallSource, resolveRemoteGitSource, SourceResolveError } from '../../knowledge-artifacts/sources/install-source.js';
 import { buildManagedArtifactRecord, hashArtifactSource, distributableCopyFilter, managedDir, recordManagedArtifact } from '../../knowledge-artifacts/governance/index.js';
 const BUILTIN_OMK_AGENT_SKILL_ID = 'omk-agent-skill';
 const INSTALLABLE_KINDS = ['skill', 'prompt', 'agent', 'workflow'];

package/dist/cli/lib/evaluation-composition.d.ts

@@ -0,0 +1,3 @@
+import { type NodeEvaluationEnvironment, type ClassifiedEnvironmentEntry } from '../../eval-workflows/hosts/application.js';
+export declare function classifyNodeCliEnvironment(environment: NodeJS.ProcessEnv): Readonly<Record<string, ClassifiedEnvironmentEntry>>;
+export declare function captureNodeCliEvaluationEnvironment(environment?: NodeJS.ProcessEnv): NodeEvaluationEnvironment;

package/dist/cli/lib/evaluation-composition.js

@@ -0,0 +1,96 @@
+import { access, realpath } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { delimiter, isAbsolute, join } from 'node:path';
+import { NodeCliProductionCompositionError, } from '../../eval-workflows/hosts/application.js';
+const CREDENTIAL_ENVIRONMENT = new Set([
+    'ANTHROPIC_API_KEY',
+    'CLAUDE_CODE_OAUTH_TOKEN',
+    'OPENAI_API_KEY',
+]);
+const SECRET_TAINT_ENVIRONMENT = new Set([
+    'ALL_PROXY',
+    'HTTPS_PROXY',
+    'HTTP_PROXY',
+    'all_proxy',
+    'http_proxy',
+    'https_proxy',
+]);
+const EFFECT_LOCATOR_ENVIRONMENT = new Set([
+    'ALL_PROXY',
+    'CODEX_HOME',
+    'CURL_CA_BUNDLE',
+    'HOME',
+    'HTTPS_PROXY',
+    'HTTP_PROXY',
+    'NODE_EXTRA_CA_CERTS',
+    'NO_PROXY',
+    'PATH',
+    'REQUESTS_CA_BUNDLE',
+    'SSL_CERT_DIR',
+    'SSL_CERT_FILE',
+    'TMPDIR',
+    'XDG_CACHE_HOME',
+    'XDG_CONFIG_HOME',
+    'XDG_DATA_HOME',
+    'all_proxy',
+    'http_proxy',
+    'https_proxy',
+    'no_proxy',
+]);
+const BEHAVIOR_ENVIRONMENT = new Set([
+    'LANG',
+    'LC_ALL',
+    'NO_COLOR',
+]);
+export function classifyNodeCliEnvironment(environment) {
+    const keys = new Set([
+        ...CREDENTIAL_ENVIRONMENT,
+        ...EFFECT_LOCATOR_ENVIRONMENT,
+        ...BEHAVIOR_ENVIRONMENT,
+    ]);
+    return Object.freeze(Object.fromEntries([...keys].sort().flatMap((key) => {
+        const value = environment[key];
+        if (value === undefined)
+            return [];
+        const identity = CREDENTIAL_ENVIRONMENT.has(key)
+            ? { identityKind: 'credential' }
+            : EFFECT_LOCATOR_ENVIRONMENT.has(key)
+                ? { identityKind: 'effect-locator' }
+                : { identityKind: 'behavior', value };
+        return [[key, Object.freeze({
+                    value,
+                    identity,
+                    ...(SECRET_TAINT_ENVIRONMENT.has(key) ? { outputTaint: 'secret' } : {}),
+                })]];
+    })));
+}
+async function resolveExecutable(command, environment) {
+    const candidates = isAbsolute(command)
+        ? [command]
+        : (environment.PATH ?? '').split(delimiter).filter(Boolean).map((directory) => (join(directory, command)));
+    for (const candidate of candidates) {
+        try {
+            await access(candidate, constants.X_OK);
+            return await realpath(candidate);
+        }
+        catch {
+            // Continue through the explicit PATH snapshot.
+        }
+    }
+    throw new NodeCliProductionCompositionError('NODE_CLI_EXECUTABLE_UNAVAILABLE', `执行器「${command}」在当前 PATH 中不可用。`);
+}
+function requiredCredential(environment, key) {
+    const value = environment[key]?.trim();
+    if (value !== undefined && value !== '')
+        return value;
+    throw new NodeCliProductionCompositionError('NODE_CLI_CREDENTIAL_MISSING', `执行器需要环境变量 ${key}。`);
+}
+export function captureNodeCliEvaluationEnvironment(environment = process.env) {
+    const captured = Object.freeze({ ...environment });
+    return Object.freeze({
+        environment: captured,
+        classifiedEnvironment: classifyNodeCliEnvironment(captured),
+        resolveExecutable: (command) => resolveExecutable(command, captured),
+        requiredCredential: (key) => requiredCredential(captured, key),
+    });
+}

package/dist/cli/lib/parse-run-config/variant-resolution.js

@@ -18,7 +18,7 @@
  *     否则会被解析成两个 artifact 后用 `x` / `x#2` 消歧,变成同一份 skill 自比,
  *     悄悄废掉「control 不能等于 treatment」的测量保护。
  */
-import { discoverVariants, variantExprToSkillName, variantIdentity, parseVariantCwd } from '../../../eval-workflows/inputs/skill-loader.js';
+import { discoverVariants, variantExprToSkillName, variantIdentity, parseVariantCwd } from '../../../knowledge-artifacts/sources/artifact-resolution.js';
 import { configVariantsToSpecs } from '../../../eval-workflows/inputs/eval-config.js';
 /** CLI 的 --control / --treatment 只收 artifact 身份。`name@cwd` 语法已移除:撞到就抛迁移错误,
  *  引导用户改用 --control-cwd / --treatment-cwd 或 eval.yaml 的 variant.cwd。git 修订语法 `@{...}`

package/dist/cli/lib/run-core-evaluation.d.ts

@@ -1,5 +1,5 @@
 import type { EvalConfig } from '../../eval-workflows/inputs/contracts/config.js';
-import { type CoreRunArtifactStore, type StoredCoreRunArtifacts } from '../../eval-workflows/artifact-store/index.js';
+import { type CoreRunArtifactStore, type StoredCoreRunArtifacts } from '../../eval-workflows/hosts/application.js';
 import type { RunConfig } from './parse-run-config.js';
 import type { CliLang } from './i18n.js';
 export interface RunCoreEvaluationCommandInput {
@@ -17,5 +17,4 @@ export interface RunCoreEvaluationCommandResult {
     readonly stored?: StoredCoreRunArtifacts;
     readonly outputDirectory: string;
 }
-/** Executes the single authoritative Node CLI → Evaluation Core production path. */
 export declare function runCoreEvaluationCommand(input: Readonly<RunCoreEvaluationCommandInput>): Promise<RunCoreEvaluationCommandResult>;

package/dist/cli/lib/run-core-evaluation.js

@@ -1,33 +1,10 @@
 import { existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { compileCliEvaluationInput, parseCliEvaluationRequest, } from '../../eval-workflows/input-compilation/index.js';
-import { createNodeCoreBatchArtifactStore, createNodeCoreContentStore, createNodeCoreRunArtifactStore, createOverlayCoreRunArtifactStore, } from '../../eval-workflows/artifact-store/index.js';
-import { createNodeCliProductionComposition, createProductionEvaluationHost, executeProductionEvaluationSeries, persistCoreArtifactSidecars, resolveNodeCliEvaluationRequest, } from '../../eval-workflows/production-host/index.js';
-import { projectCoreCliDryRun, projectCoreCliBatchOutcome, projectCoreCliRunOutcome, projectCoreCliSeriesOutcome, } from '../../eval-workflows/projections/cli.js';
-import { projectCoreManagedEvidence } from '../../eval-workflows/projections/managed.js';
-import { discoverBatchSkills } from '../../eval-workflows/inputs/skill-loader.js';
+import { createNodeEvaluationApplication, parseCliEvaluationRequest, } from '../../eval-workflows/hosts/application.js';
+import { captureNodeCliEvaluationEnvironment } from './evaluation-composition.js';
 import { withLocalizedSampleDiscovery } from './localized-sample-discovery.js';
 import { projectReportsDir, globalReportsDir } from '../../evidence/storage/directories.js';
-import { generateRunId } from '../../evidence/storage/run-id.js';
-import { globalLayout, projectLayout } from '../../evidence/storage/layout.js';
-function runStoreForOutput(outputDirectory, primaryContentResolver) {
-    const primary = createNodeCoreRunArtifactStore(outputDirectory, {
-        contentResolver: primaryContentResolver,
-    });
-    const resolved = resolve(outputDirectory);
-    const project = projectLayout();
-    const global = globalLayout();
-    const fallbackDirs = resolved === resolve(project.evalDir)
-        ? [global.evalDir]
-        : [];
-    const unique = [...new Set(fallbackDirs.map((dir) => resolve(dir)))]
-        .filter((dir) => dir !== resolved);
-    if (unique.length === 0)
-        return primary;
-    return createOverlayCoreRunArtifactStore(primary, unique.map((dir) => (createNodeCoreRunArtifactStore(dir, {
-        contentResolver: createNodeCoreContentStore(join(dir, 'content')),
-    }))));
-}
+import { globalLayout } from '../../evidence/storage/layout.js';
 function requestFor(input, projectRoot) {
     const projectMcpConfig = join(projectRoot, '.mcp.json');
     return parseCliEvaluationRequest({
@@ -98,246 +75,58 @@ async function announceCoreReport(artifacts, store, outputDirectory, serve, lang
     const { openWorkbench } = await import('./open-workbench.js');
     await openWorkbench(reportUrl, lang);
 }
-async function appendManagedEvidenceSafely(stored, enabled, lang) {
-    if (!enabled)
-        return;
-    try {
-        const { recordCoreEvalEvidence } = await import('../../knowledge-artifacts/governance/evidence.js');
-        const written = recordCoreEvalEvidence(projectCoreManagedEvidence(stored));
-        if (written.length > 0)
+function renderNotice(notice, lang) {
+    switch (notice.noticeKind) {
+        case 'doctor-skipped':
             process.stderr.write(lang === 'zh'
-                ? `已写入 ${written.length} 条 Core 受管证据。\n`
-                : `Recorded ${written.length} Core managed evidence reference(s).\n`);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        process.stderr.write(lang === 'zh'
-            ? `警告：Core 受管证据写入失败：${message}\n`
-            : `Warning: failed to record Core managed evidence: ${message}\n`);
-    }
-}
-async function persistArtifactGraph(stored, outputDirectory, cwd) {
-    await persistCoreArtifactSidecars({ source: stored, outputDirectory, cwd });
-}
-function resumeRunId(request) {
-    const locator = request.values.orchestration.resumeSourceLocator?.trim();
-    if (locator === undefined || locator === '')
-        return undefined;
-    if (!/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/i.test(locator)) {
-        throw new TypeError('--resume 只接受 Core runId，不接受旧报告路径。');
+                ? '警告：--skip-doctor 已开启，Core 静态健康检查已跳过；依赖正确性由用户负责。\n'
+                : 'Warning: --skip-doctor is enabled; Core static health checks were skipped and dependency correctness is user-owned.\n');
+            break;
+        case 'batch-item':
+            process.stderr.write(lang === 'zh' ? `\nCore Batch：${notice.name}\n` : `\nCore Batch: ${notice.name}\n`);
+            break;
+        case 'managed-evidence-recorded':
+            process.stderr.write(lang === 'zh' ? `已写入 ${notice.count} 条 Core 受管证据。\n` : `Recorded ${notice.count} Core managed evidence reference(s).\n`);
+            break;
+        case 'managed-evidence-failed': {
+            const message = notice.error instanceof Error ? notice.error.message : String(notice.error);
+            process.stderr.write(lang === 'zh' ? `警告：Core 受管证据写入失败：${message}\n` : `Warning: failed to record Core managed evidence: ${message}\n`);
+            break;
+        }
+        case 'series-managed-evidence-skipped':
+            process.stderr.write(lang === 'zh'
+                ? 'Core Series 不写入单次 member 受管证据；需由预注册的 Series 总体决定投影后再纳入生命周期。\n'
+                : 'Core Series does not write single-member managed evidence; lifecycle admission requires a preregistered Series-level decision projection.\n');
     }
-    return locator;
 }
-/** Executes the single authoritative Node CLI → Evaluation Core production path. */
 export async function runCoreEvaluationCommand(input) {
     const projectRoot = resolve(input.projectRoot ?? process.cwd());
     const machineLayout = globalLayout(input.environment?.OMK_HOME);
-    const request = requestFor(input, projectRoot);
-    if (request.values.orchestration.preflight.doctor === 'skip') {
-        process.stderr.write(input.lang === 'zh'
-            ? '警告：--skip-doctor 已开启，Core 静态健康检查已跳过；依赖正确性由用户负责。\n'
-            : 'Warning: --skip-doctor is enabled; Core static health checks were skipped and dependency correctness is user-owned.\n');
-    }
-    if (request.values.orchestration.batch) {
-        const entries = withLocalizedSampleDiscovery(() => discoverBatchSkills(resolve(projectRoot, request.values.locators.skillDirectory)), input.lang);
-        if (entries.length === 0) {
-            throw new TypeError(input.lang === 'zh'
-                ? `没有找到带 canonical 私有用例的目录 skill：${request.values.locators.skillDirectory}。每个 skill 应使用 <skill>/.omk/eval-samples.json 或 eval-samples.yaml。`
-                : `No directory skill with canonical private samples found in ${request.values.locators.skillDirectory}. Use <skill>/.omk/eval-samples.json or eval-samples.yaml for each skill.`);
-        }
-        if (request.values.orchestration.resumeSourceLocator !== undefined) {
-            throw new TypeError('Batch resume 必须按 child runId 显式执行，不能复用旧聚合报告。');
-        }
-        const children = [];
-        for (const entry of entries) {
-            process.stderr.write(input.lang === 'zh'
-                ? `\nCore Batch：${entry.name}\n`
-                : `\nCore Batch: ${entry.name}\n`);
-            children.push(await runCoreEvaluationCommand({
-                ...input,
-                flags: {
-                    ...input.flags,
-                    batch: undefined,
-                    control: 'baseline',
-                    treatment: entry.skillPath,
-                    samples: entry.samplesPath,
-                    'no-serve': true,
-                },
-            }));
-        }
-        const outputDirectory = children[0].outputDirectory;
-        if (request.values.orchestration.dryRun) {
-            return {
-                exitCode: 0,
-                output: Object.freeze({
-                    projectionKind: 'core-cli-batch-dry-run',
-                    children: Object.freeze(entries.map((entry, index) => Object.freeze({
-                        itemId: entry.name,
-                        plan: children[index].output,
-                    }))),
-                }),
-                outputDirectory,
-            };
-        }
-        const storedChildren = children.map((child) => {
-            if (child.stored === undefined)
-                throw new Error('Core Batch child 缺少持久化产物。');
-            return child.stored;
-        });
-        const contentResolver = createNodeCoreContentStore(join(outputDirectory, 'content'));
-        const runStore = input.store ?? runStoreForOutput(outputDirectory, contentResolver);
-        const batchId = generateRunId(['batch']);
-        const batch = await createNodeCoreBatchArtifactStore(outputDirectory, runStore).save({
-            batchId,
-            createdAt: new Date().toISOString(),
-            children: storedChildren.map((child, index) => ({
-                itemId: entries[index].name,
-                runId: child.manifest.runId,
-            })),
-        });
-        const output = projectCoreCliBatchOutcome({
-            batch,
-            children: storedChildren,
-            exitMode: request.values.presentation.exitMode,
-            diagnosticMode: request.values.orchestration.diagnostic === 'enabled-outside-core'
-                ? 'enabled'
-                : 'disabled',
+    const application = createNodeEvaluationApplication(captureNodeCliEvaluationEnvironment(input.environment));
+    try {
+        const result = await application.run({
+            request: requestFor(input, projectRoot), projectRoot,
+            materializationRoot: machineLayout.resolvedInputsDir, resourceLeaseRoot: machineLayout.resourceLeasesDir,
+            store: input.store,
+            createProgressSink: () => emitProgress(input.lang),
+            onNotice: (notice) => renderNotice(notice, input.lang),
+            requestForBatchItem: (entry) => requestFor({ ...input, flags: { ...input.flags, batch: undefined, control: 'baseline', treatment: entry.skillPath, samples: entry.samplesPath, 'no-serve': true } }, projectRoot),
+            async onCompleted(completed, request) {
+                if (completed.outcomeKind === 'run')
+                    await announceCoreReport(completed.artifacts, completed.store, completed.outputDirectory, request.values.presentation.serve, input.lang);
+                if (completed.outcomeKind === 'series')
+                    process.stderr.write(input.lang === 'zh'
+                        ? `Core Series 已完成：${completed.outcome.seriesId}（${completed.outcome.members.length} 个独立 run）\n`
+                        : `Core Series completed: ${completed.outcome.seriesId} (${completed.outcome.members.length} independent runs)\n`);
+            },
         });
         return {
-            exitCode: output.gate.exitCode,
-            output,
-            outputDirectory,
+            exitCode: result.outcomeKind === 'dry-run' || result.outcomeKind === 'batch-dry-run' ? 0 : result.outcome.gate.exitCode,
+            output: result.outcome, outputDirectory: result.outputDirectory,
+            ...(result.outcomeKind === 'run' ? { stored: result.artifacts } : {}),
         };
     }
-    const outputDirectory = resolve(projectRoot, request.values.presentation.outputDirectoryLocator);
-    const resolved = await resolveNodeCliEvaluationRequest(request, {
-        projectRoot,
-        materializationRoot: machineLayout.resolvedInputsDir,
-        ...(input.environment === undefined ? {} : { environment: input.environment }),
-        ...(request.values.orchestration.repeatCount > 1
-            ? { seriesInstanceId: generateRunId(['series']) }
-            : {}),
-    });
-    const compiled = compileCliEvaluationInput(resolved);
-    const composition = await createNodeCliProductionComposition({
-        compiled,
-        projectRoot,
-        outputDirectory,
-        resourceLeaseRoot: machineLayout.resourceLeasesDir,
-        environment: input.environment,
-    });
-    const store = input.store ?? runStoreForOutput(outputDirectory, composition.support.contentResolver);
-    const host = {
-        compiled,
-        ...composition,
-        artifactStore: store,
-    };
-    if (compiled.orchestration.dryRun) {
-        const prepared = await createProductionEvaluationHost(host).prepare();
-        const output = projectCoreCliDryRun({ plan: prepared.plan, preflight: prepared.preflight });
-        return { exitCode: 0, output, outputDirectory };
-    }
-    const sourceRunId = resumeRunId(request);
-    const independentSeries = compiled.orchestration.independentSeries;
-    if (independentSeries !== undefined) {
-        if (sourceRunId !== undefined) {
-            throw new TypeError('Independent Series resume 必须按 member runId 单独执行。');
-        }
-        const createdAt = new Date().toISOString();
-        const series = await executeProductionEvaluationSeries({
-            host,
-            members: independentSeries.memberships.map((membership) => ({
-                runId: generateRunId([membership.memberId]),
-                createdAt,
-                progressSink: emitProgress(input.lang),
-            })),
-            bundleId: generateRunId(['series-analysis']),
-            reportId: generateRunId(['series-report']),
-        });
-        await series.result;
-        const evolution = await series.evolution;
-        if (evolution === undefined)
-            throw new Error('Core Series 未完成，无法生成 evolution evidence。');
-        const memberArtifacts = await Promise.all(series.members.map(async (member) => {
-            if (member.executionStatus !== 'started')
-                throw member.error;
-            await member.run.result;
-            const persistence = await member.run.persistence;
-            if (persistence.persistenceStatus !== 'stored') {
-                if (persistence.persistenceStatus === 'failed')
-                    throw persistence.error;
-                throw new Error(`Core Series member 产物未保存：${persistence.reasonCode}`);
-            }
-            return persistence.artifacts;
-        }));
-        const output = projectCoreCliSeriesOutcome({
-            evolution,
-            members: memberArtifacts,
-            exitMode: request.values.presentation.exitMode,
-            diagnosticMode: request.values.orchestration.diagnostic === 'enabled-outside-core'
-                ? 'enabled'
-                : 'disabled',
-        });
-        for (const artifacts of memberArtifacts) {
-            await persistArtifactGraph(artifacts, outputDirectory, projectRoot);
-        }
-        if (compiled.orchestration.managedEvidence === 'append') {
-            process.stderr.write(input.lang === 'zh'
-                ? 'Core Series 不写入单次 member 受管证据；需由预注册的 Series 总体决定投影后再纳入生命周期。\n'
-                : 'Core Series does not write single-member managed evidence; lifecycle admission requires a preregistered Series-level decision projection.\n');
-        }
-        process.stderr.write(input.lang === 'zh'
-            ? `Core Series 已完成：${output.seriesId}（${output.members.length} 个独立 run）\n`
-            : `Core Series completed: ${output.seriesId} (${output.members.length} independent runs)\n`);
-        return { exitCode: output.gate.exitCode, output, outputDirectory };
-    }
-    const prepared = await createProductionEvaluationHost(host).prepare();
-    let stored;
-    if (sourceRunId !== undefined) {
-        const admission = await prepared.admitResume({
-            locator: { locatorKind: 'core-run', runId: sourceRunId },
-            policy: {
-                rejectionMode: 'fail-closed',
-                minimumSourceTrust: 'unknown',
-                cacheReceiptMode: 'allow-indeterminate',
-                budgetVerificationMode: 'allow-indeterminate',
-            },
-        });
-        if (admission.disposition !== 'reuse') {
-            throw new Error(`Core resume 被拒绝：${admission.reasonCode}`);
-        }
-        stored = admission.artifacts;
-    }
-    else {
-        const targetIds = prepared.plan.execution.targets.map((target) => target.targetId);
-        const runId = generateRunId(targetIds);
-        const run = await prepared.execute({
-            runId,
-            createdAt: new Date().toISOString(),
-            progressSink: emitProgress(input.lang),
-        });
-        await run.result;
-        const persistence = await run.persistence;
-        if (persistence.persistenceStatus !== 'stored') {
-            if (persistence.persistenceStatus === 'failed')
-                throw persistence.error;
-            throw new Error(`Core 产物未保存：${persistence.reasonCode}`);
-        }
-        stored = persistence.artifacts;
+    catch (error) {
+        return withLocalizedSampleDiscovery(() => { throw error; }, input.lang);
     }
-    const output = projectCoreCliRunOutcome(stored, {
-        exitMode: request.values.presentation.exitMode,
-        diagnosticMode: request.values.orchestration.diagnostic === 'enabled-outside-core'
-            ? 'enabled'
-            : 'disabled',
-    });
-    await persistArtifactGraph(stored, outputDirectory, projectRoot);
-    await appendManagedEvidenceSafely(stored, compiled.orchestration.managedEvidence === 'append', input.lang);
-    await announceCoreReport(stored, store, outputDirectory, request.values.presentation.serve, input.lang);
-    return {
-        exitCode: output.gate.exitCode,
-        output,
-        stored,
-        outputDirectory,
-    };
 }

package/dist/dsh-plugin/core-adapter.d.ts

@@ -1,7 +1,7 @@
 import { type EvaluationDefinition } from '../eval-core/contracts/index.js';
 import { type ExecutionExecutor } from '../eval-core/execution/index.js';
-import type { OmkBindingResourceLeaseAccess } from '../eval-workflows/runtime-adapter/resource-leases/types.js';
-import type { RuntimeBindingOf } from '../eval-workflows/runtime-adapter/types.js';
+import type { OmkBindingResourceLeaseAccess } from '../eval-workflows/hosts/resource-leases/types.js';
+import type { RuntimeBindingOf } from '../eval-workflows/hosts/types.js';
 import type { DshAgentLike, DshHostContextLike } from './host-executor.js';
 export { DSH_HOST_CORE_ADAPTER_IMPLEMENTATION_VERSION, createDshHostCoreSchemaValidators, } from './core-protocol.js';
 export declare const DEFAULT_DSH_HOST_CORE_MAX_INPUT_BYTES: number;

package/dist/dsh-plugin/core-adapter.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { JsonValueSchema, RuntimeIdentitySchema, canonicalizeJson, deepFreezeCanonicalJson, digestCanonicalJson, } from '../eval-core/contracts/index.js';
 import { ExecutionPortFailure, } from '../eval-core/execution/index.js';
 import { createDshHostRuntimeFingerprint } from '../executors/core/runtime-fingerprint.js';
-import { captureClaudeCliRunState, captureClaudeCliTarget, disposeClaudeCliTrial, openClaudeCliTrial, } from '../eval-workflows/runtime-adapter/adapters/claude/resources.js';
+import { captureClaudeCliRunState, captureClaudeCliTarget, disposeClaudeCliTrial, openClaudeCliTrial, } from '../eval-workflows/hosts/adapters/claude/resources.js';
 import { createSameProcessExecutorAdapter } from '../eval-runtime/adapters/same-process.js';
 import { DSH_HOST_CORE_ADAPTER_IMPLEMENTATION_VERSION, dshHostCoreExecutorCapabilities, parseDshHostCoreResult, } from './core-protocol.js';
 import { supportsDshTraceEventType } from './trace-adapter.js';
@@ -716,7 +716,7 @@ export async function createDshHostCoreExecutorAdapter(input) {
                 }
                 runState.acquireTrial();
                 try {
-                    return openClaudeCliTrial(trial, runState, host.maxInputBytes, RESOURCE_PROFILE);
+                    return await openClaudeCliTrial(trial, runState, host.maxInputBytes, RESOURCE_PROFILE);
                 }
                 catch (error) {
                     await runState.releaseTrial();
@@ -726,8 +726,8 @@ export async function createDshHostCoreExecutorAdapter(input) {
             execute({ runState, trialState, attempt, scope }) {
                 return executeDshHost(host, target, runState, trialState, attempt, scope.operationIsolationKey);
             },
-            disposeTrial({ runState }) {
-                return disposeClaudeCliTrial(runState, RESOURCE_PROFILE);
+            disposeTrial({ runState, trialState }) {
+                return disposeClaudeCliTrial(runState, trialState, RESOURCE_PROFILE);
             },
             disposeRun({ runState }) {
                 return runState.requestDispose();

package/dist/dsh-plugin/core-command.d.ts

@@ -1,4 +1,4 @@
-import { type StoredCoreRunArtifacts } from '../eval-workflows/artifact-store/index.js';
+import { type StoredCoreRunArtifacts } from '../eval-workflows/hosts/application.js';
 import type { CoreCliRunOutcome, CoreCliSeriesOutcome } from '../eval-workflows/projections/contracts.js';
 import type { EvalConfig } from '../eval-workflows/inputs/contracts/config.js';
 import { type DshAgentLike, type DshHostContextLike } from './host-executor.js';