@fkqfkq123/opencode-autopilot 0.1.0

package/dist/packages/runtime/src/commands/workflow-open-request.js

@@ -0,0 +1,220 @@
+import { access, readdir, readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+const MAX_DOC_CHARS = 12_000;
+const MAX_CANDIDATE_DOCS = 20;
+const MAX_SCAN_DEPTH = 3;
+const DOC_EXTENSIONS = [".md", ".markdown", ".txt", ".rst", ".adoc", ".pdf", ".docx"];
+const COMMON_DOC_DIRS = ["docs", "doc", "spec", "specs", "design", "prd", "product", "requirements"];
+const trimToEmpty = (value) => value?.trim() ?? "";
+const hasDocExtension = (value) => {
+    const normalized = value.trim().toLowerCase();
+    return DOC_EXTENSIONS.some((extension) => normalized.endsWith(extension));
+};
+const normalizeDocumentLikeInput = (value) => value.trim().replace(/^文档\s*[:：]?\s*/i, "");
+const looksLikeDocumentReference = (value) => {
+    const normalized = normalizeDocumentLikeInput(value);
+    if (!normalized) {
+        return false;
+    }
+    if (!hasDocExtension(normalized)) {
+        return false;
+    }
+    return normalized.startsWith("/")
+        || normalized.startsWith("./")
+        || normalized.startsWith("../")
+        || normalized.includes("/")
+        || normalized.includes("\\");
+};
+const parseStructuredRequest = (payload) => {
+    try {
+        const parsed = JSON.parse(payload);
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        const prompt = typeof parsed.prompt === "string"
+            ? parsed.prompt
+            : undefined;
+        const projectContext = typeof parsed.projectContext === "string"
+            ? parsed.projectContext
+            : undefined;
+        const docPaths = Array.isArray(parsed.docPaths)
+            ? parsed.docPaths.filter((item) => typeof item === "string")
+            : undefined;
+        const hasKnownKey = prompt !== undefined || projectContext !== undefined || docPaths !== undefined;
+        if (!hasKnownKey) {
+            return null;
+        }
+        return {
+            ...(prompt !== undefined ? { prompt } : {}),
+            ...(projectContext !== undefined ? { projectContext } : {}),
+            ...(docPaths !== undefined ? { docPaths } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const toAbsolutePath = (pathValue, workspaceRoot) => isAbsolute(pathValue) ? pathValue : resolve(workspaceRoot, pathValue);
+const normalizeDocSnippet = (content) => {
+    const normalized = content.replace(/\r\n/g, "\n").trim();
+    if (normalized.length <= MAX_DOC_CHARS) {
+        return normalized;
+    }
+    return `${normalized.slice(0, MAX_DOC_CHARS)}\n... (truncated)`;
+};
+const toRelativePath = (workspaceRoot, absolutePath) => {
+    const normalizedRoot = workspaceRoot.endsWith("/") ? workspaceRoot : `${workspaceRoot}/`;
+    return absolutePath.startsWith(normalizedRoot)
+        ? absolutePath.slice(normalizedRoot.length)
+        : absolutePath;
+};
+const listDocCandidatesFromDir = async (baseDir, workspaceRoot, depth, output) => {
+    if (depth > MAX_SCAN_DEPTH || output.length >= MAX_CANDIDATE_DOCS) {
+        return;
+    }
+    try {
+        await access(baseDir);
+    }
+    catch {
+        return;
+    }
+    const dirEntries = await readdir(baseDir, { withFileTypes: true });
+    const sorted = [...dirEntries].sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of sorted) {
+        if (output.length >= MAX_CANDIDATE_DOCS) {
+            return;
+        }
+        if (entry.name.startsWith(".")) {
+            continue;
+        }
+        const childPath = resolve(baseDir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === "dist") {
+                continue;
+            }
+            await listDocCandidatesFromDir(childPath, workspaceRoot, depth + 1, output);
+            continue;
+        }
+        if (entry.isFile() && hasDocExtension(entry.name)) {
+            output.push(toRelativePath(workspaceRoot, childPath));
+        }
+    }
+};
+const discoverCandidateDocs = async (workspaceRoot) => {
+    const candidates = [];
+    for (const dirName of COMMON_DOC_DIRS) {
+        if (candidates.length >= MAX_CANDIDATE_DOCS) {
+            break;
+        }
+        const targetDir = resolve(workspaceRoot, dirName);
+        await listDocCandidatesFromDir(targetDir, workspaceRoot, 0, candidates);
+    }
+    return [...new Set(candidates)].slice(0, MAX_CANDIDATE_DOCS);
+};
+const actionHints = [
+    "开始",
+    "启动",
+    "执行",
+    "推进",
+    "分析",
+    "提炼",
+    "整理",
+    "生成",
+    "新增",
+    "添加",
+    "实现",
+    "开发",
+    "支持",
+    "优化",
+    "修复",
+    "改造",
+    "重构",
+    "需求",
+    "workflow",
+    "工作流",
+    "流程",
+    "review",
+    "plan",
+    "develop",
+    "test",
+];
+function inferOpenIntent(rawPayload, prompt, docPaths) {
+    const lower = rawPayload.toLowerCase();
+    const hasActionHint = actionHints.some((hint) => lower.includes(hint.toLowerCase()));
+    const onlyDocLikeInput = docPaths.length > 0 && !hasActionHint && prompt.length < 20;
+    const explicitDocReference = looksLikeDocumentReference(rawPayload);
+    if (explicitDocReference) {
+        return { needsClarification: false };
+    }
+    if (!hasActionHint || onlyDocLikeInput) {
+        return {
+            needsClarification: true,
+            clarificationQuestion: "我看到你给了一个文档，但还不确定你希望我做什么。你想怎么处理？",
+            clarificationOptions: [
+                "1. 直接启动 workflow",
+                "2. 先分析并提炼需求",
+                "3. 先补全文档再决定",
+                "4. 只看文档，不启动 workflow",
+            ],
+        };
+    }
+    return { needsClarification: false };
+}
+export async function buildWorkflowOpenRequest(payload, workspaceRoot) {
+    const rawPayload = trimToEmpty(payload);
+    const structured = rawPayload ? parseStructuredRequest(rawPayload) : null;
+    const prompt = trimToEmpty(structured?.prompt)
+        || (looksLikeDocumentReference(rawPayload)
+            ? `请基于这份文档启动 workflow。\n${normalizeDocumentLikeInput(rawPayload)}`
+            : rawPayload);
+    const structuredDocPaths = (structured?.docPaths ?? []).map((item) => item.trim()).filter((item) => item.length > 0);
+    const docPaths = structuredDocPaths;
+    const shouldRecallCandidates = !structured && docPaths.length === 0;
+    const candidateDocs = shouldRecallCandidates ? await discoverCandidateDocs(workspaceRoot) : [];
+    const projectContext = trimToEmpty(structured?.projectContext)
+        || undefined;
+    const intent = inferOpenIntent(rawPayload, prompt, docPaths);
+    const lines = [];
+    lines.push("[USER_PROMPT]");
+    lines.push(prompt || "请先基于项目和需求文档完成 spec_refinement。");
+    if (projectContext) {
+        lines.push("");
+        lines.push("[PROJECT_CONTEXT]");
+        lines.push(projectContext);
+    }
+    if (docPaths.length > 0) {
+        lines.push("");
+        lines.push("[REFERENCE_DOCS]");
+        for (const rawPath of docPaths) {
+            const absolutePath = toAbsolutePath(rawPath, workspaceRoot);
+            try {
+                const content = await readFile(absolutePath, "utf8");
+                lines.push("");
+                lines.push(`[DOC_PATH] ${rawPath}`);
+                lines.push("[DOC_CONTENT]");
+                lines.push(normalizeDocSnippet(content));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                lines.push("");
+                lines.push(`[DOC_PATH] ${rawPath}`);
+                lines.push(`[DOC_READ_ERROR] ${message}`);
+            }
+        }
+    }
+    if (candidateDocs.length > 0) {
+        lines.push("");
+        lines.push("[DOC_CANDIDATES]");
+        lines.push(...candidateDocs.map((item) => `- ${item}`));
+        lines.push("[DOC_CANDIDATES_POLICY] Candidate list is recall-only. AI must decide relevance and read selected docs before filling artifact.");
+    }
+    return {
+        userRequest: lines.join("\n"),
+        prompt,
+        docPaths,
+        needsClarification: intent.needsClarification,
+        ...(intent.clarificationQuestion ? { clarificationQuestion: intent.clarificationQuestion } : {}),
+        ...(intent.clarificationOptions ? { clarificationOptions: intent.clarificationOptions } : {}),
+        ...(projectContext ? { projectContext } : {}),
+    };
+}

package/dist/packages/runtime/src/config/skill-registry.d.ts

@@ -0,0 +1,15 @@
+export declare function buildSkillRegistry(skillRoots: string[]): Promise<Map<string, string>>;
+export type SkillRegistryBuildResult = {
+    registry: Map<string, string>;
+    warnings: string[];
+};
+export declare function buildSkillRegistryWithWarnings(skillRoots: string[]): Promise<SkillRegistryBuildResult>;
+export declare function resolveSkillPaths(registry: Map<string, string>, skillNames: string[]): Array<{
+    name: string;
+    path: string;
+}>;
+export declare function loadResolvedSkillContents(registry: Map<string, string>, skillNames: string[]): Promise<Array<{
+    name: string;
+    path: string;
+    content: string;
+}>>;

package/dist/packages/runtime/src/config/skill-registry.js

@@ -0,0 +1,108 @@
+import { access, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+function expandPath(input) {
+    if (input === "~") {
+        return homedir();
+    }
+    if (input.startsWith("~/")) {
+        return join(homedir(), input.slice(2));
+    }
+    return isAbsolute(input) ? input : resolve(input);
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function buildSkillRegistry(skillRoots) {
+    const registry = new Map();
+    for (const rawRoot of skillRoots) {
+        const root = expandPath(rawRoot);
+        let entries = [];
+        try {
+            entries = await readdir(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isFile() && extname(entry.name).toLowerCase() === ".md") {
+                const skillName = basename(entry.name, ".md");
+                registry.set(skillName, join(root, entry.name));
+                continue;
+            }
+            if (entry.isDirectory()) {
+                const skillPath = join(root, entry.name, "SKILL.md");
+                if (await fileExists(skillPath)) {
+                    registry.set(entry.name, skillPath);
+                }
+            }
+        }
+    }
+    return registry;
+}
+export async function buildSkillRegistryWithWarnings(skillRoots) {
+    const registry = new Map();
+    const warnings = [];
+    for (const rawRoot of skillRoots) {
+        const root = expandPath(rawRoot);
+        let entries = [];
+        try {
+            entries = await readdir(root, { withFileTypes: true });
+        }
+        catch {
+            warnings.push(`Skill root not found or unreadable: ${rawRoot}`);
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isFile() && extname(entry.name).toLowerCase() === ".md") {
+                const skillName = basename(entry.name, ".md");
+                const skillPath = join(root, entry.name);
+                if (registry.has(skillName)) {
+                    warnings.push(`Duplicate skill name detected: ${skillName}`);
+                }
+                registry.set(skillName, skillPath);
+                continue;
+            }
+            if (entry.isDirectory()) {
+                const skillPath = join(root, entry.name, "SKILL.md");
+                if (await fileExists(skillPath)) {
+                    if (registry.has(entry.name)) {
+                        warnings.push(`Duplicate skill name detected: ${entry.name}`);
+                    }
+                    registry.set(entry.name, skillPath);
+                }
+            }
+        }
+    }
+    return { registry, warnings };
+}
+export function resolveSkillPaths(registry, skillNames) {
+    return skillNames.flatMap((name) => {
+        const path = registry.get(name);
+        return path ? [{ name, path }] : [];
+    });
+}
+export async function loadResolvedSkillContents(registry, skillNames) {
+    const resolved = resolveSkillPaths(registry, skillNames);
+    const results = [];
+    for (const skill of resolved) {
+        try {
+            const content = await readFile(skill.path, "utf8");
+            results.push({
+                ...skill,
+                content: content.trim(),
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return results;
+}

package/dist/packages/runtime/src/config/workflow-config.d.ts

@@ -0,0 +1,17 @@
+export type WorkflowConfigPhase = "spec_refinement" | "plan" | "develop" | "review" | "test";
+export type WorkflowPhaseConfig = {
+    requiredSkills?: string[];
+};
+export type WorkflowConfigFile = {
+    skillRoots?: string[];
+    phases?: Partial<Record<WorkflowConfigPhase, WorkflowPhaseConfig>>;
+};
+export type ResolvedWorkflowConfig = {
+    skillRoots: string[];
+    phases: Partial<Record<WorkflowConfigPhase, WorkflowPhaseConfig>>;
+    warnings: string[];
+};
+export declare function resolveWorkflowConfig(args: {
+    projectConfigFile: string;
+    homeDir?: string;
+}): Promise<ResolvedWorkflowConfig>;

package/dist/packages/runtime/src/config/workflow-config.js

@@ -0,0 +1,51 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readJsonFile } from "../shared/json-file";
+const EMPTY_CONFIG = {
+    skillRoots: [],
+    phases: {},
+    warnings: [],
+};
+function unique(values) {
+    return [...new Set(values)];
+}
+function normalizePhaseConfig(config) {
+    if (!config || typeof config !== "object") {
+        return undefined;
+    }
+    const requiredSkills = Array.isArray(config.requiredSkills)
+        ? unique(config.requiredSkills.map((value) => value.trim()).filter(Boolean))
+        : undefined;
+    if (!requiredSkills || requiredSkills.length === 0) {
+        return undefined;
+    }
+    return { requiredSkills };
+}
+function mergeConfigs(base, incoming) {
+    if (!incoming) {
+        return base;
+    }
+    const next = {
+        skillRoots: unique([
+            ...base.skillRoots,
+            ...(Array.isArray(incoming.skillRoots)
+                ? incoming.skillRoots.map((value) => value.trim()).filter(Boolean)
+                : []),
+        ]),
+        phases: { ...base.phases },
+        warnings: [...base.warnings],
+    };
+    for (const phase of ["spec_refinement", "plan", "develop", "review", "test"]) {
+        const merged = normalizePhaseConfig(incoming.phases?.[phase]) ?? next.phases[phase];
+        if (merged) {
+            next.phases[phase] = merged;
+        }
+    }
+    return next;
+}
+export async function resolveWorkflowConfig(args) {
+    const globalConfigFile = join(args.homeDir ?? homedir(), ".config", "opencode", "workflow.json");
+    const globalConfig = await readJsonFile(globalConfigFile);
+    const projectConfig = await readJsonFile(args.projectConfigFile);
+    return mergeConfigs(mergeConfigs(EMPTY_CONFIG, globalConfig), projectConfig);
+}

package/dist/packages/runtime/src/diagnostics/workflow-diagnostics-format.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDoctorResult } from "./workflow-doctor";
+import type { WorkflowInstallResult } from "../install/workflow-installer";
+export declare function formatWorkflowDoctorResult(result: WorkflowDoctorResult): string;
+export declare function formatWorkflowInstallResult(result: WorkflowInstallResult): string;

package/dist/packages/runtime/src/diagnostics/workflow-diagnostics-format.js

@@ -0,0 +1,70 @@
+const divider = "=".repeat(64);
+export function formatWorkflowDoctorResult(result) {
+    const lines = [
+        divider,
+        `Workflow Doctor: ${result.ok ? "OK" : "ATTENTION"}`,
+        `Project config: ${result.projectConfigFile}`,
+        `Global config: ${result.globalConfigFile}`,
+    ];
+    lines.push("");
+    lines.push("Checks:");
+    for (const check of result.checks) {
+        const marker = check.status === "ok" ? "[ok]" : check.status === "warning" ? "[warn]" : "[error]";
+        lines.push(`${marker} ${check.name}: ${check.detail}`);
+    }
+    lines.push("");
+    lines.push("Required skills:");
+    if (result.requiredSkills.length === 0) {
+        lines.push("- none");
+    }
+    else {
+        for (const entry of result.requiredSkills) {
+            lines.push(`- ${entry.phase}: ${entry.skills.join(", ")}`);
+        }
+    }
+    if (result.missingSkills.length > 0) {
+        lines.push("");
+        lines.push("Missing skills:");
+        for (const entry of result.missingSkills) {
+            lines.push(`- ${entry.phase}: ${entry.skill}`);
+        }
+    }
+    if (result.nextSteps.length > 0) {
+        lines.push("");
+        lines.push("Next steps:");
+        for (const step of result.nextSteps) {
+            lines.push(`- ${step}`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        lines.push("");
+        lines.push("Warnings:");
+        for (const warning of result.warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    lines.push(divider);
+    return lines.join("\n");
+}
+export function formatWorkflowInstallResult(result) {
+    const lines = [
+        divider,
+        `Workflow Install: ${result.ok ? "OK" : "ATTENTION"}`,
+        `Project workflow.json: ${result.projectWorkflowConfigFile}`,
+        `OpenCode config: ${result.opencodeConfigFile}`,
+        `Plugin entry: ${result.pluginEntry}`,
+    ];
+    if (result.warnings.length > 0) {
+        lines.push("");
+        lines.push("Warnings:");
+        for (const warning of result.warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    lines.push("");
+    lines.push("Recommended next steps:");
+    lines.push("- Run: bun run src/cli.ts doctor");
+    lines.push("- Then open OpenCode and use workflow_open / workflow_attach");
+    lines.push(divider);
+    return lines.join("\n");
+}

package/dist/packages/runtime/src/diagnostics/workflow-doctor.d.ts

@@ -0,0 +1,23 @@
+import type { WorkflowWorkspace } from "../workspace/workflow-workspace";
+export type WorkflowDoctorResult = {
+    ok: boolean;
+    globalConfigFile: string;
+    projectConfigFile: string;
+    skillRoots: string[];
+    requiredSkills: Array<{
+        phase: string;
+        skills: string[];
+    }>;
+    missingSkills: Array<{
+        phase: string;
+        skill: string;
+    }>;
+    checks: Array<{
+        name: string;
+        status: "ok" | "warning" | "error";
+        detail: string;
+    }>;
+    nextSteps: string[];
+    warnings: string[];
+};
+export declare function runWorkflowDoctor(workspace: WorkflowWorkspace): Promise<WorkflowDoctorResult>;

package/dist/packages/runtime/src/diagnostics/workflow-doctor.js

@@ -0,0 +1,120 @@
+import { access } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { buildSkillRegistryWithWarnings } from "../config/skill-registry";
+import { resolveWorkflowConfig } from "../config/workflow-config";
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readTextIfExists(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function gitignoreHasWorkflowHarness(content) {
+    return content.split("\n").some((line) => {
+        const normalized = line.trim();
+        return normalized.includes(".workflow-harness/");
+    });
+}
+export async function runWorkflowDoctor(workspace) {
+    const projectConfigFile = workspace.workflowConfigFile();
+    const globalConfigFile = join(homedir(), ".config", "opencode", "workflow.json");
+    const resolvedConfig = await resolveWorkflowConfig({
+        projectConfigFile,
+    });
+    const registryResult = await buildSkillRegistryWithWarnings(resolvedConfig.skillRoots);
+    const checks = [];
+    const requiredSkills = Object.entries(resolvedConfig.phases)
+        .flatMap(([phase, phaseConfig]) => {
+        const skills = phaseConfig?.requiredSkills ?? [];
+        return skills.length > 0 ? [{ phase, skills }] : [];
+    });
+    const warnings = [...resolvedConfig.warnings, ...registryResult.warnings];
+    const missingSkills = [];
+    for (const { phase, skills } of requiredSkills) {
+        for (const skillName of skills) {
+            if (!registryResult.registry.has(skillName)) {
+                warnings.push(`Missing skill for phase ${phase}: ${skillName}`);
+                missingSkills.push({ phase, skill: skillName });
+            }
+        }
+    }
+    const hasGlobalConfig = await fileExists(globalConfigFile);
+    if (!hasGlobalConfig) {
+        warnings.push(`Global workflow.json not found: ${globalConfigFile}`);
+    }
+    const workspaceRoot = workspace.baseDir().endsWith(".workflow-harness")
+        ? dirname(workspace.baseDir())
+        : workspace.baseDir();
+    const gitignoreFile = join(workspaceRoot, ".gitignore");
+    const gitignoreContent = await readTextIfExists(gitignoreFile);
+    const hasGitignoreRule = gitignoreContent ? gitignoreHasWorkflowHarness(gitignoreContent) : false;
+    checks.push({
+        name: "project-workflow-config",
+        status: (await fileExists(projectConfigFile)) ? "ok" : "warning",
+        detail: projectConfigFile,
+    });
+    checks.push({
+        name: "global-workflow-config",
+        status: hasGlobalConfig ? "ok" : "warning",
+        detail: globalConfigFile,
+    });
+    checks.push({
+        name: "skill-roots",
+        status: resolvedConfig.skillRoots.length > 0 ? "ok" : "warning",
+        detail: resolvedConfig.skillRoots.length > 0 ? resolvedConfig.skillRoots.join(", ") : "No skillRoots configured",
+    });
+    checks.push({
+        name: "required-skills",
+        status: missingSkills.length === 0 ? "ok" : "error",
+        detail: missingSkills.length === 0
+            ? "All required skills resolved"
+            : missingSkills.map((entry) => `${entry.phase}:${entry.skill}`).join(", "),
+    });
+    checks.push({
+        name: "gitignore-workflow-harness",
+        status: hasGitignoreRule ? "ok" : "warning",
+        detail: hasGitignoreRule
+            ? ".workflow-harness runtime files are ignored"
+            : "Recommend ignoring .workflow-harness/ or at least runtime subpaths such as workflows/ and plugin-load.json",
+    });
+    const nextSteps = [];
+    if (!(await fileExists(projectConfigFile))) {
+        nextSteps.push(`Run installer to generate project workflow.json: ${projectConfigFile}`);
+    }
+    if (resolvedConfig.skillRoots.length === 0) {
+        nextSteps.push("Add skillRoots to workflow.json if you want phase skill injection");
+    }
+    if (missingSkills.length > 0) {
+        nextSteps.push("Fix missing requiredSkills or add corresponding skill files under configured skillRoots");
+    }
+    if (!hasGlobalConfig) {
+        nextSteps.push(`Optional: create global workflow defaults at ${globalConfigFile}`);
+    }
+    if (!hasGitignoreRule) {
+        nextSteps.push("Consider ignoring .workflow-harness/ runtime files to avoid accidental commits");
+    }
+    const ok = checks.every((check) => check.status !== "error");
+    return {
+        ok,
+        globalConfigFile,
+        projectConfigFile,
+        skillRoots: resolvedConfig.skillRoots,
+        requiredSkills,
+        missingSkills,
+        checks,
+        nextSteps,
+        warnings,
+    };
+}

package/dist/packages/runtime/src/engine/default-workflow-engine.d.ts

@@ -0,0 +1,9 @@
+import type { WorkflowEngine, WorkflowEngineDeps } from "./workflow-engine";
+export declare class DefaultWorkflowEngine implements WorkflowEngine {
+    private readonly deps;
+    constructor(deps: WorkflowEngineDeps);
+    private isArtifactPhase;
+    private buildRefinementDispatchSummary;
+    private buildDispatchPrompt;
+    tick(workflowId: string): Promise<void>;
+}