@interf/compiler 0.3.3 → 0.4.0

package/dist/lib/workflow-definitions.js

@@ -1,133 +1,17 @@
-import { isWorkflowId, listLocalWorkflowDefinitions, loadLocalWorkflowDefinition } from "./local-workflows.js";
-import { WORKSPACE_INTERF_STARTER_DOCS, } from "./workflow-starter-docs.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { isWorkflowId, listLocalWorkflowDefinitions, loadLocalWorkflowDefinition, loadWorkflowDefinitionFromDir, } from "./local-workflows.js";
+import { PACKAGE_ROOT } from "./config.js";
+import { resolveSourceControlPath } from "./interf.js";
+import { validateWorkspaceContractSequence, } from "./workflow-abi.js";
 import { warnInterf } from "./logger.js";
-import { BUILTIN_WORKSPACE_ZONE_IDS } from "./workspace-schema.js";
-const WORKSPACE_RUNTIME_STAGES = [
-    {
-        id: "summarize",
-        label: "Summarize",
-        description: "Turn source files into per-file summaries.",
-        contractType: "workspace-file-evidence",
-        skillDir: "summarize",
-        reads: [
-            BUILTIN_WORKSPACE_ZONE_IDS.RAW,
-            BUILTIN_WORKSPACE_ZONE_IDS.RUNTIME,
-        ],
-        writes: [
-            BUILTIN_WORKSPACE_ZONE_IDS.SUMMARIES,
-        ],
-        acceptance: {
-            artifacts_exist: [".interf/inventory.json"],
-            state_truthy: ["last_summarize", "inventory_complete"],
-            state_at_least_counts: {
-                summarized: "expected_summary_total",
-            },
-        },
-    },
-    {
-        id: "structure",
-        label: "Structure",
-        description: "Build the cross-file knowledge structure from the summaries.",
-        contractType: "workspace-knowledge-structure",
-        skillDir: "structure",
-        reads: [
-            BUILTIN_WORKSPACE_ZONE_IDS.SUMMARIES,
-            BUILTIN_WORKSPACE_ZONE_IDS.RUNTIME,
-        ],
-        writes: [
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_ENTITIES,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_CLAIMS,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_INDEXES,
-        ],
-        acceptance: {
-            artifacts_exist: ["knowledge/indexes"],
-            state_truthy: ["last_structure", "inventory_complete"],
-            state_at_least_counts: {
-                structured: "summary_total",
-            },
-        },
-    },
-    {
-        id: "shape",
-        label: "Shape",
-        description: "Shape the final workspace around the saved focus and truth checks.",
-        contractType: "workspace-query-shape",
-        skillDir: "shape",
-        reads: [
-            BUILTIN_WORKSPACE_ZONE_IDS.SUMMARIES,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_ENTITIES,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_CLAIMS,
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_INDEXES,
-            BUILTIN_WORKSPACE_ZONE_IDS.RUNTIME,
-        ],
-        writes: [
-            BUILTIN_WORKSPACE_ZONE_IDS.KNOWLEDGE_INDEXES,
-            BUILTIN_WORKSPACE_ZONE_IDS.HOME,
-        ],
-        acceptance: {
-            artifacts_exist: ["home.md"],
-            state_truthy: ["last_shape", "inventory_complete"],
-            state_at_least_counts: {
-                shaped: "summary_total",
-                compiled: "summary_total",
-            },
-        },
-    },
-];
-export const WORKSPACE_WORKFLOWS = [
-    {
-        id: "interf",
-        compilerApi: {
-            kind: "workspace",
-            version: 1,
-        },
-        label: "Interf (Recommended)",
-        hint: "Interf's default methodology: summarize source-grounded evidence, structure the cross-file layer, then shape the final workspace around its focus and saved truth checks.",
-        recommended: true,
-        stages: WORKSPACE_RUNTIME_STAGES,
-        scope: "builtin",
-        stagePolicyNotes: {
-            summarize: [
-                "Favor conservative, source-grounded summaries that preserve evidence tiers and leave broader synthesis for later stages.",
-                "For large reports or decks, capture scope, headline evidence, and chart/table routing in one light pass.",
-                "As soon as one report summary can state scope, headline metrics, and chart/table routing, stop reading and write the summary batch plus runtime artifacts immediately.",
-                "Keep scratch extraction commands single-purpose and non-destructive.",
-            ],
-            structure: [
-                "Bias structure toward canonical entities, claims, timelines, and stable indexes.",
-                "Use taxonomy and ontology only as means to improve retrieval, navigation, and evidence tracking.",
-                "For small datasets, prefer a minimal stable substrate over exhaustive graph sprawl.",
-            ],
-            shape: [
-                "Use the workspace focus and saved truth checks to bias the final workspace toward the job it should be especially good at.",
-                "Do not copy expected answers into the final workspace just because the checks imply them.",
-                "Prefer better routing, prioritization, and focused navigation over speculative synthesis.",
-            ],
-        },
-        starterDocs: WORKSPACE_INTERF_STARTER_DOCS,
-    },
-];
-function titleCaseWorkflowId(workflowId) {
-    return workflowId
-        .split("-")
-        .filter((part) => part.length > 0)
-        .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
-        .join(" ");
-}
+import { workflowPackagePathForWorkspace } from "./workspace-paths.js";
+let builtinInterfWorkflowCache = null;
 function validateWorkspaceStages(stages) {
     if (stages.length < 3)
         return false;
-    const order = new Map([
-        ["workspace-file-evidence", 0],
-        ["workspace-knowledge-structure", 1],
-        ["workspace-query-shape", 2],
-    ]);
-    const contractTypes = stages.map((stage) => stage.contractType);
-    if (!contractTypes.every((contractType, index) => index === 0 || (order.get(contractType) ?? -1) >= (order.get(contractTypes[index - 1]) ?? -1)))
-        return false;
-    return contractTypes.includes("workspace-file-evidence") &&
-        contractTypes.includes("workspace-knowledge-structure") &&
-        contractTypes.includes("workspace-query-shape");
+    const sequence = validateWorkspaceContractSequence(stages.map((stage) => stage.contractType));
+    return sequence.ok;
 }
 function toWorkflowStages(stages, fallbackStages) {
     if (!stages || stages.length === 0)
@@ -143,14 +27,6 @@ function toWorkflowStages(stages, fallbackStages) {
         ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
     }));
 }
-function mergeStarterDocs(baseDocs, overrideDocs) {
-    const merged = new Map();
-    for (const doc of baseDocs ?? [])
-        merged.set(doc.relativePath, doc);
-    for (const doc of overrideDocs ?? [])
-        merged.set(doc.relativePath, doc);
-    return Array.from(merged.values()).sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-}
 function mergeStagePolicyNotes(stages, baseNotes, overrideNotes) {
     const merged = {};
     for (const definition of stages) {
@@ -164,69 +40,111 @@ function mergeStagePolicyNotes(stages, baseNotes, overrideNotes) {
     }
     return Object.keys(merged).length > 0 ? merged : undefined;
 }
-function toResolvedWorkflowDefinition(local, base) {
-    const stages = toWorkflowStages(local.stages, base.stages);
+export function standaloneWorkflowDefinitionFromLocalPackage(local) {
+    if (!local.stages || local.stages.length === 0) {
+        throw new Error(`Workflow package "${local.id}" is missing explicit stages. Workspace-local and portable workflow packages must be standalone.`);
+    }
+    const stages = toWorkflowStages(local.stages, []);
     return {
         id: local.id,
-        compilerApi: local.compiler_api ?? base.compilerApi,
+        compilerApi: local.compiler_api ?? {
+            kind: "workspace",
+            version: 1,
+        },
         label: local.label,
         hint: local.hint,
         recommended: false,
         stages,
-        stagePolicyNotes: mergeStagePolicyNotes(stages, base.stagePolicyNotes, local.stage_policy_notes),
-        starterDocs: mergeStarterDocs(base.starterDocs, local.starter_docs),
+        stagePolicyNotes: mergeStagePolicyNotes(stages, undefined, local.stage_policy_notes),
+        starterDocs: [...local.starter_docs],
         scope: "local",
     };
 }
-function fallbackWorkspaceWorkflow(workflowId) {
-    warnInterf(`Warning: no workflow definition found for workspace workflow "${workflowId}". Falling back to Interf defaults.`);
-    const base = WORKSPACE_WORKFLOWS[0];
-    return {
-        ...base,
-        id: workflowId,
-        label: titleCaseWorkflowId(workflowId),
-        hint: `Missing local workflow definition for "${workflowId}". Falling back to Interf defaults.`,
-        recommended: false,
-        scope: "local",
+function builtinWorkflowPackagePath(workflowId) {
+    return join(PACKAGE_ROOT, "builtin-workflows", workflowId);
+}
+function getBuiltinInterfWorkflow() {
+    if (builtinInterfWorkflowCache)
+        return builtinInterfWorkflowCache;
+    const local = loadWorkflowDefinitionFromDir(builtinWorkflowPackagePath("interf"));
+    if (!local) {
+        throw new Error("Missing built-in Interf workflow package at builtin-workflows/interf.");
+    }
+    const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
+    if (!validateWorkspaceStages(resolved.stages)) {
+        throw new Error("Built-in Interf workflow package has an invalid stage ordering.");
+    }
+    builtinInterfWorkflowCache = {
+        ...resolved,
+        id: "interf",
+        recommended: true,
+        scope: "builtin",
     };
+    return builtinInterfWorkflowCache;
 }
-function resolveWorkspaceWorkflowFromLocal(workflowId, sourcePath, visited) {
-    if (visited.has(workflowId))
-        return fallbackWorkspaceWorkflow(workflowId);
+function listBuiltinWorkspaceWorkflows() {
+    return [getBuiltinInterfWorkflow()];
+}
+function resolveWorkspaceWorkflowFromLocal(workflowId, sourcePath) {
     const local = loadLocalWorkflowDefinition(sourcePath, workflowId);
     if (!local)
         return null;
-    visited.add(workflowId);
-    const base = local.extends
-        ? getWorkspaceWorkflow(local.extends, { sourcePath, visited })
-        : WORKSPACE_WORKFLOWS[0];
-    const resolved = toResolvedWorkflowDefinition(local, base);
+    if (local.extends) {
+        throw new Error(`Workflow "${workflowId}" uses legacy extends. Rewrite it as a standalone package before creating or compiling a workspace.`);
+    }
+    const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
     if (!validateWorkspaceStages(resolved.stages)) {
-        warnInterf(`Warning: workspace workflow "${workflowId}" has an invalid stage ordering. Workspace workflows must have one or more workspace-file-evidence stages followed by one or more workspace-knowledge-structure stages and one or more workspace-query-shape stages.`);
-        return fallbackWorkspaceWorkflow(workflowId);
+        throw new Error(`Workflow "${workflowId}" has an invalid stage ordering. Workspace workflows must have one or more workspace-file-evidence stages followed by one or more workspace-knowledge-structure stages and one or more workspace-query-shape stages.`);
     }
     return resolved;
 }
 export function listWorkspaceWorkflowChoices(sourcePath) {
-    const builtins = [...WORKSPACE_WORKFLOWS];
+    const builtins = listBuiltinWorkspaceWorkflows();
     if (!sourcePath)
         return builtins;
     const locals = listLocalWorkflowDefinitions(sourcePath)
         .filter((definition) => definition.id !== "interf")
-        .map((definition) => resolveWorkspaceWorkflowFromLocal(definition.id, sourcePath, new Set()))
+        .map((definition) => {
+        try {
+            return resolveWorkspaceWorkflowFromLocal(definition.id, sourcePath);
+        }
+        catch (error) {
+            warnInterf(`Warning: skipping local workflow "${definition.id}" because it could not be resolved cleanly: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    })
         .filter((definition) => definition !== null);
     return [...builtins, ...locals];
 }
 export function getWorkspaceWorkflow(workflowId, options = {}) {
-    const builtin = WORKSPACE_WORKFLOWS.find((candidate) => candidate.id === workflowId);
+    const builtin = listBuiltinWorkspaceWorkflows().find((candidate) => candidate.id === workflowId);
     if (builtin)
         return builtin;
     if (options.sourcePath) {
-        const local = resolveWorkspaceWorkflowFromLocal(workflowId, options.sourcePath, options.visited ?? new Set());
+        const local = resolveWorkspaceWorkflowFromLocal(workflowId, options.sourcePath);
         if (local)
             return local;
+        throw new Error(`No local workflow package found for "${workflowId}" under ${join(options.sourcePath, "interf", "workflows", workflowId)}.`);
     }
-    return fallbackWorkspaceWorkflow(workflowId);
+    throw new Error(`Workflow "${workflowId}" is not built-in. Provide a source path so Interf Compiler can resolve a local workflow package.`);
+}
+export function getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId) {
+    const workflowPath = workflowPackagePathForWorkspace(workspacePath);
+    if (existsSync(join(workflowPath, "workflow.json"))) {
+        const local = loadWorkflowDefinitionFromDir(workflowPath);
+        if (!local) {
+            throw new Error(`Workspace-local workflow package at ${workflowPath} is missing or invalid. Interf compile runs the workspace-local package directly; recreate or reseed this workspace instead of relying on source-root fallback.`);
+        }
+        if (local.extends) {
+            throw new Error(`Workspace-local workflow package at ${workflowPath} still uses legacy extends. Materialize it as a standalone package before compiling this workspace.`);
+        }
+        const resolved = standaloneWorkflowDefinitionFromLocalPackage(local);
+        if (!validateWorkspaceStages(resolved.stages)) {
+            throw new Error(`Workspace-local workflow package at ${workflowPath} has an invalid stage ordering. Interf compile will not silently switch methods for this workspace.`);
+        }
+        return resolved;
+    }
+    throw new Error(`Missing workspace-local workflow package at ${workflowPath}. Interf compile runs the workspace-local package directly, so recreate or reseed this workspace instead of relying on source-root workflow "${fallbackWorkflowId}" under ${resolveSourceControlPath(workspacePath)}.`);
 }
 export function resolveWorkspaceWorkflowId(value) {
     if (typeof value === "string" && isWorkflowId(value)) {
@@ -243,6 +161,13 @@ export function resolveWorkspaceWorkflowFromConfig(config) {
 export function formatWorkspaceWorkflowStageStep(workflowId, stage, options = {}) {
     return formatWorkflowStageStep(getWorkspaceWorkflow(workflowId, options), stage);
 }
+function resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath) {
+    if (sourcePath &&
+        existsSync(join(workflowPackagePathForWorkspace(sourcePath), "workflow.json"))) {
+        return getActiveWorkspaceWorkflow(sourcePath, workflowId);
+    }
+    return getWorkspaceWorkflow(workflowId, { sourcePath });
+}
 function formatWorkflowStageStep(workflow, stage) {
     const stageIndex = workflow.stages.findIndex((candidate) => candidate.id === stage);
     if (stageIndex === -1) {
@@ -255,7 +180,7 @@ function formatWorkflowStageStep(workflow, stage) {
     return `Step ${stageIndex + 1}/${workflow.stages.length} - ${stageDefinition.label}`;
 }
 export function getWorkflowStageDefinition(workflowId, stage, sourcePath) {
-    const workflow = getWorkspaceWorkflow(workflowId, { sourcePath });
+    const workflow = resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath);
     return workflow.stages.find((candidate) => candidate.id === stage) ?? null;
 }
 export function getWorkflowStagePosition(workflowId, stage, sourcePath) {
@@ -270,10 +195,22 @@ export function getWorkflowStagePosition(workflowId, stage, sourcePath) {
     };
 }
 export function getWorkflowStages(workflowId, sourcePath) {
-    return getWorkspaceWorkflow(workflowId, { sourcePath }).stages.map((definition) => definition.id);
+    return resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath).stages.map((definition) => definition.id);
+}
+export function getActiveWorkspaceStages(workspacePath, fallbackWorkflowId) {
+    return getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId).stages.map((definition) => definition.id);
 }
 export function getWorkflowStagePolicyNotes(workflowId, stage, sourcePath) {
-    const workflow = getWorkspaceWorkflow(workflowId, { sourcePath });
+    const workflow = resolveWorkflowDefinitionForStageMetadata(workflowId, sourcePath);
+    return [...(workflow.stagePolicyNotes?.[stage] ?? [])];
+}
+export function getActiveWorkspaceStagePolicyNotes(workspacePath, fallbackWorkflowId, stage) {
+    const workflow = getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId);
     return [...(workflow.stagePolicyNotes?.[stage] ?? [])];
 }
-//# sourceMappingURL=workflow-definitions.js.map
+export function resolveActiveWorkspaceStageAcceptance(workspacePath, fallbackWorkflowId, stage) {
+    return getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId).stages.find((candidate) => candidate.id === stage)?.acceptance;
+}
+export function formatActiveWorkspaceWorkflowStageStep(workspacePath, fallbackWorkflowId, stage) {
+    return formatWorkflowStageStep(getActiveWorkspaceWorkflow(workspacePath, fallbackWorkflowId), stage);
+}

package/dist/lib/workflow-helpers.d.ts

@@ -9,8 +9,8 @@ export interface WorkflowStageResult {
     code: number;
     summary?: string | null;
 }
-export declare function workflowCreateDirectory(): string;
 export declare function workflowQueryDirectory(): string;
+export declare function workflowImproveDirectory(): string;
 export declare function workflowCompileStageDirectory(stageDir: string): string;
 export interface LocalSkillContractExtension {
     reads: string[];
@@ -37,4 +37,3 @@ export declare function validateStageOutcome(_dirPath: string, validation: {
     ok: boolean;
     summary: string;
 };
-//# sourceMappingURL=workflow-helpers.d.ts.map

package/dist/lib/workflow-helpers.js

@@ -1,16 +1,18 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { join, relative, sep } from "node:path";
 import { listFilesRecursive } from "./filesystem.js";
 import { isMarkdownFile } from "./util.js";
+import { workspaceBundledSkillForContractType } from "./workflow-abi.js";
 import { getWorkspaceWorkflow, } from "./workflow-definitions.js";
 import { parseJsonFrontmatter } from "./parse.js";
+import { workflowPackagePathForWorkspace } from "./workspace-paths.js";
 const LOCAL_SKILL_READ_LIMIT = 50;
-export function workflowCreateDirectory() {
-    return "workflow/create";
-}
 export function workflowQueryDirectory() {
     return "workflow/use/query";
 }
+export function workflowImproveDirectory() {
+    return "workflow/improve";
+}
 export function workflowCompileStageDirectory(stageDir) {
     return `workflow/compile/stages/${stageDir}`;
 }
@@ -39,9 +41,10 @@ function collectLocalSkillDocs(rootPath, directories) {
 }
 function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories) {
     const docs = new Map();
-    const rootReadme = join(rootPath, "workflow", "README.md");
+    const workflowRoot = workflowPackagePathForWorkspace(rootPath);
+    const rootReadme = join(workflowRoot, "README.md");
     if (existsSync(rootReadme)) {
-        const read = relative(relativeToPath, rootReadme);
+        const read = projectWorkflowReadPath(rootPath, relativeToPath, rootReadme);
         docs.set(read, {
             read,
             absolutePath: rootReadme,
@@ -49,8 +52,9 @@ function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories)
         });
     }
     for (const directory of directories) {
-        for (const filePath of listFilesRecursive(join(rootPath, directory), isMarkdownFile)) {
-            const read = relative(relativeToPath, filePath);
+        const absoluteDirectory = resolveAuthoringDirectory(rootPath, directory);
+        for (const filePath of listFilesRecursive(absoluteDirectory, isMarkdownFile)) {
+            const read = projectWorkflowReadPath(rootPath, relativeToPath, filePath);
             docs.set(read, {
                 read,
                 absolutePath: filePath,
@@ -62,6 +66,25 @@ function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories)
         .sort((a, b) => a.read.localeCompare(b.read))
         .slice(0, LOCAL_SKILL_READ_LIMIT);
 }
+function resolveAuthoringDirectory(rootPath, directory) {
+    if (directory === "workflow") {
+        return workflowPackagePathForWorkspace(rootPath);
+    }
+    if (directory.startsWith(`workflow${sep}`) || directory.startsWith("workflow/")) {
+        const relativeWorkflowPath = directory.replace(/^workflow[\\/]/, "");
+        return join(workflowPackagePathForWorkspace(rootPath), relativeWorkflowPath);
+    }
+    return join(rootPath, directory);
+}
+function projectWorkflowReadPath(rootPath, relativeToPath, absolutePath) {
+    const workflowRoot = workflowPackagePathForWorkspace(rootPath);
+    const normalizedWorkflowRoot = `${workflowRoot}${sep}`;
+    if (absolutePath === workflowRoot || absolutePath.startsWith(normalizedWorkflowRoot)) {
+        const relativeWorkflowPath = relative(workflowRoot, absolutePath);
+        return relative(relativeToPath, join(rootPath, "workflow", relativeWorkflowPath));
+    }
+    return relative(relativeToPath, absolutePath);
+}
 export function buildLocalSkillContractExtension(rootPath, directories, purpose) {
     const docs = collectLocalSkillDocs(rootPath, directories);
     return buildContractExtensionFromDocs(docs, directories, purpose);
@@ -138,18 +161,7 @@ export function reportValidationFailure(reporter, summary, errors = []) {
     }
 }
 export function bundledSkillForContractType(contractType) {
-    switch (contractType) {
-        case "workspace-file-evidence":
-            return "workspace/summarize";
-        case "workspace-knowledge-structure":
-            return "workspace/structure";
-        case "workspace-query-shape":
-            return "workspace/shape";
-        default: {
-            const exhaustiveCheck = contractType;
-            throw new Error(`Unknown workspace contract type: ${exhaustiveCheck}`);
-        }
-    }
+    return workspaceBundledSkillForContractType(contractType);
 }
 export function resolveStageAcceptance(workflowId, stageId, sourcePath) {
     return getWorkspaceWorkflow(workflowId, { sourcePath }).stages.find((stage) => stage.id === stageId)?.acceptance;
@@ -157,4 +169,3 @@ export function resolveStageAcceptance(workflowId, stageId, sourcePath) {
 export function validateStageOutcome(_dirPath, validation) {
     return validation;
 }
-//# sourceMappingURL=workflow-helpers.js.map

package/dist/lib/workflow-improvement.d.ts

@@ -0,0 +1,22 @@
+import type { WorkflowExecutor } from "./executors.js";
+import { type WorkflowValidationResult } from "./local-workflows.js";
+import type { SourceWorkspaceConfig, WorkflowImprovementLoopSummary } from "./schema.js";
+export interface WorkflowImprovementRunResult {
+    status: "updated" | "no-change" | "invalid" | "executor-failed";
+    changed: boolean;
+    validation: WorkflowValidationResult | null;
+    summary: string;
+    shellPath: string;
+    loopRootPath: string;
+}
+export declare function runWorkflowImprovementLoop(options: {
+    executor: WorkflowExecutor;
+    workspacePath: string;
+    workflowId: string;
+    workspaceConfig: Pick<SourceWorkspaceConfig, "checks">;
+    runId: string;
+    loopIndex: number;
+    maxLoops: number;
+    maxAttempts: number;
+    previousVariations: WorkflowImprovementLoopSummary[];
+}): Promise<WorkflowImprovementRunResult>;