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

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,35 +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, } from '../../eval-hosts/node/node-cli-composition.js';
-import { createProductionEvaluationHost, executeProductionEvaluationSeries, persistCoreArtifactSidecars, } from '../../eval-workflows/production-host/index.js';
-import { resolveNodeCliEvaluationRequest, } from '../../eval-hosts/node/node-cli-evaluation-resolver.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({
@@ -100,247 +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.contentResolver);
-    const host = {
-        compiled,
-        runtime: composition.runtime,
-        schemaValidators: composition.schemaValidators,
-        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;
-            const persistence = await member.run.persistence;
-            await member.run.result;
-            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),
-        });
-        const persistence = await run.persistence;
-        await run.result;
-        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-hosts/runtime-adapter/resource-leases/types.js';
-import type { RuntimeBindingOf } from '../eval-hosts/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-hosts/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';

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';