@interf/compiler 0.7.3 → 0.9.1

package/dist/cli/commands/web.js

@@ -0,0 +1,373 @@
+import { existsSync, mkdirSync, readFileSync, } from "node:fs";
+import { join, resolve } from "node:path";
+import chalk from "chalk";
+import { resolveLocalExecutor, } from "../../packages/agents/lib/executors.js";
+import { ActionProposalPlanSchema, startLocalService, } from "../../packages/local-service/index.js";
+import { loadSourceFolderConfig, saveSourceFolderConfig, sourceFolderConfigPath, } from "../../packages/project-model/source-config.js";
+import { runConfiguredCompiledCompile, } from "./compile-controller.js";
+import { draftReadinessChecks, } from "./check-draft.js";
+import { runTestCommand, } from "./test.js";
+import { runWorkflowAuthoringDraft, } from "../../packages/workflow-authoring/workflow-authoring.js";
+import { PACKAGE_ROOT } from "../../packages/workflow-package/lib/package-root.js";
+import { seedLocalDefaultWorkflow } from "../../packages/workflow-package/local-workflows.js";
+import { findNearestInterfInstanceConfig, hasInterfInstanceConfig, relativeSourceFolderPath, resolveInterfInstanceContext, } from "./control-path.js";
+import { listSourceFolderChoices, } from "../../packages/project-model/source-folders.js";
+export const webCommand = {
+    command: "web",
+    describe: "Start Interf UI and the local Interf API",
+    builder: (yargs) => yargs
+        .option("host", {
+        type: "string",
+        describe: "Host for the local Interf service",
+    })
+        .option("port", {
+        type: "number",
+        describe: "Port for the local Interf service",
+    })
+        .option("control-path", {
+        type: "string",
+        describe: "Folder where Interf stores local config, Methods, runs, and portable context",
+    })
+        .option("source-folder", {
+        type: "string",
+        describe: "Source Folder to prepare when initializing a new Interf Workspace",
+    }),
+    handler: async (argv) => {
+        await runWebCommand(argv);
+    },
+};
+function stringOption(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function numberOption(value) {
+    if (typeof value !== "number" || !Number.isInteger(value))
+        return undefined;
+    return value;
+}
+function extractJsonObject(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        const match = text.match(/\{[\s\S]*\}/);
+        if (!match)
+            throw new Error("Planner did not write a JSON object.");
+        return JSON.parse(match[0]);
+    }
+}
+function readActionSkill() {
+    const skillDir = join(PACKAGE_ROOT, "agent-skills", "interf-actions");
+    const skillPath = join(skillDir, "SKILL.md");
+    const cliReferencePath = join(skillDir, "references", "cli.md");
+    try {
+        const skill = readFileSync(skillPath, "utf8");
+        const cliReference = readFileSync(cliReferencePath, "utf8");
+        return [
+            skill,
+            "## Bundled reference: references/cli.md",
+            cliReference,
+        ].join("\n\n");
+    }
+    catch {
+        return [
+            "# Interf Actions",
+            "Use `interf --help`, `interf list`, `interf status`, and command-specific help as the source of truth.",
+            "In Interf proposal mode, do not run CLI commands. Write the requested JSON proposal only.",
+        ].join("\n\n");
+    }
+}
+export function resolveWebProjectPaths(argv = {}, cwd = process.cwd()) {
+    const currentPath = resolve(cwd);
+    const configuredControlPath = stringOption(argv["control-path"]);
+    const configuredSourceFolder = stringOption(argv["source-folder"]);
+    if (configuredControlPath) {
+        return {
+            controlPath: resolve(currentPath, configuredControlPath),
+            sourceFolderPath: configuredSourceFolder ? resolve(currentPath, configuredSourceFolder) : null,
+        };
+    }
+    const existingControlPath = findNearestInterfInstanceConfig(currentPath);
+    if (existingControlPath) {
+        return {
+            controlPath: existingControlPath,
+            sourceFolderPath: configuredSourceFolder ? resolve(currentPath, configuredSourceFolder) : null,
+        };
+    }
+    if (configuredSourceFolder) {
+        const resolvedSourceFolder = resolve(currentPath, configuredSourceFolder);
+        const context = resolveInterfInstanceContext(resolvedSourceFolder);
+        return {
+            controlPath: context.controlPath,
+            sourceFolderPath: resolvedSourceFolder,
+        };
+    }
+    const context = resolveInterfInstanceContext(currentPath);
+    return {
+        controlPath: context.controlPath,
+        sourceFolderPath: context.defaultSourceFolderPath ?? currentPath,
+    };
+}
+export function ensureWebProjectInitialized(controlPath, options = {}) {
+    const inferSourceFolderPath = () => {
+        if (options.sourceFolderPath)
+            return options.sourceFolderPath;
+        const choices = listSourceFolderChoices(controlPath);
+        return choices.length === 1 ? resolve(controlPath, choices[0]?.value ?? "") : null;
+    };
+    if (existsSync(sourceFolderConfigPath(controlPath))) {
+        if (!hasInterfInstanceConfig(controlPath)) {
+            throw new Error(`Interf Workspace path is not usable: ${sourceFolderConfigPath(controlPath)}. Choose a different --control-path.`);
+        }
+        const existing = loadSourceFolderConfig(controlPath);
+        const sourceFolderPath = existing?.source_folder ? null : inferSourceFolderPath();
+        if (existing && sourceFolderPath) {
+            saveSourceFolderConfig(controlPath, {
+                source_folder: {
+                    path: relativeSourceFolderPath(controlPath, sourceFolderPath),
+                },
+                preparations: existing.preparations ?? existing.datasets ?? [],
+            });
+        }
+        return;
+    }
+    seedLocalDefaultWorkflow({ sourcePath: controlPath });
+    const sourceFolderPath = inferSourceFolderPath();
+    saveSourceFolderConfig(controlPath, {
+        ...(sourceFolderPath
+            ? {
+                source_folder: {
+                    path: relativeSourceFolderPath(controlPath, sourceFolderPath),
+                },
+            }
+            : {}),
+        preparations: [],
+    });
+}
+function buildActionPlannerPrompt(request, context, outputPath) {
+    const actionSkill = readActionSkill();
+    const preparations = context.datasets.map((preparation) => ({
+        name: preparation.name,
+        path: preparation.path,
+        about: preparation.about ?? null,
+        method: preparation.method ?? preparation.workflow ?? null,
+        checks: preparation.checks?.length ?? 0,
+    }));
+    const recentProposals = context.recentProposals.map((proposal) => ({
+        status: proposal.status,
+        action_type: proposal.action_type,
+        title: proposal.title,
+        preparation: proposal.preparation ?? null,
+        request: proposal.request,
+        command_preview: proposal.command_preview ?? null,
+    }));
+    const sourceFolders = context.sourceFolders.map((folder) => ({
+        path: folder.value,
+        label: folder.label,
+        hint: folder.hint,
+    }));
+    return `You are the local Interf action planner.
+
+User request:
+${request.message}
+
+Selected Preparation hint: ${request.preparation ?? "(none)"}
+
+Structured request values:
+${JSON.stringify(request.values ?? {}, null, 2)}
+
+Available Preparations:
+${JSON.stringify(preparations, null, 2)}
+
+Visible Source Folders:
+${JSON.stringify(sourceFolders, null, 2)}
+
+Action health:
+${JSON.stringify(context.preparationHealth, null, 2)}
+
+Recent proposals, newest first. A short follow-up like "target source only" may be correcting the latest pending proposal:
+${JSON.stringify(recentProposals, null, 2)}
+
+Interf action skill source:
+${actionSkill}
+
+Use the Interf action skill source as the authority for CLI semantics and Interf proposal mode. Preserve user intent over defaults.
+Use Action health to avoid proposing work that cannot run yet. If can_check_readiness is false, prefer the recommended next actions; do not propose a generic readiness check unless the user explicitly asks for a source-files-only baseline.
+If the user is asking a question or making casual conversation, return "clarification" with a helpful assistant_message. Do not invent a CLI command for non-action chat.
+If a field does not apply, omit it instead of writing null or an empty string.
+Do not run any CLI command. Do not edit files except the output JSON file.
+
+Write only this JSON object to:
+${outputPath}
+
+JSON schema:
+{
+  "action_type": "preparation-setup" | "compile" | "test" | "readiness-check-draft" | "method-authoring" | "clarification",
+  "preparation": "Preparation id if applicable",
+  "method": "Method id if applicable",
+  "values": {},
+  "title": "short approval card title",
+  "summary": "one sentence describing what will run",
+  "assistant_message": "concise explanation for the user",
+  "command_preview": "interf command the user is approving"
+}
+`;
+}
+export async function runWebCommand(argv = {}) {
+    const { controlPath, sourceFolderPath } = resolveWebProjectPaths(argv);
+    ensureWebProjectInitialized(controlPath, { sourceFolderPath });
+    const handlers = {
+        async planActionProposal(request, context) {
+            const resolved = resolveLocalExecutor({ preflight: true });
+            if (!resolved.executor) {
+                return ActionProposalPlanSchema.parse({
+                    action_type: "clarification",
+                    preparation: request.preparation,
+                    assistant_message: resolved.error ?? "No local agent detected for action planning.",
+                });
+            }
+            const planRoot = join(context.sourcePath, "interf", ".service", "action-plans", Date.now().toString(36));
+            mkdirSync(planRoot, { recursive: true });
+            const outputPath = join(planRoot, "proposal.json");
+            const prompt = buildActionPlannerPrompt(request, context, outputPath);
+            const exitCode = await resolved.executor.execute(context.sourcePath, prompt, {
+                eventLogPath: join(planRoot, "planner.events.ndjson"),
+                statusLogPath: join(planRoot, "planner.status.log"),
+                completionCheck: () => existsSync(outputPath),
+            });
+            if (exitCode !== 0 && !existsSync(outputPath)) {
+                return ActionProposalPlanSchema.parse({
+                    action_type: "clarification",
+                    preparation: request.preparation,
+                    assistant_message: `${resolved.executor.displayName} could not create a safe Interf proposal.`,
+                });
+            }
+            try {
+                return ActionProposalPlanSchema.parse(extractJsonObject(readFileSync(outputPath, "utf8")));
+            }
+            catch {
+                return ActionProposalPlanSchema.parse({
+                    action_type: "clarification",
+                    preparation: request.preparation,
+                    assistant_message: "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.",
+                });
+            }
+        },
+        async createCompileRun(request, context) {
+            const resolved = resolveLocalExecutor({ preflight: true });
+            if (!resolved.executor) {
+                throw new Error(resolved.error ?? "No local agent detected.");
+            }
+            const ok = await runConfiguredCompiledCompile({
+                executor: resolved.executor,
+                compiledPath: context.compiledPath,
+                sourcePath: context.sourcePath,
+                compiledConfig: context.datasetConfig,
+                maxAttemptsOverride: request.max_attempts ?? null,
+                maxLoopsOverride: request.max_loops ?? null,
+                preserveStageShells: request.preserve_stage_shells,
+                runId: context.runId,
+                events: context.events,
+            });
+            return { ok };
+        },
+        async createTestRun(request, context) {
+            const failureRef = {};
+            const ok = await runTestCommand({
+                sourcePath: context.sourcePath,
+                dataset: context.datasetConfig.name,
+                datasetConfig: context.datasetConfig,
+                target: request.mode,
+                skipService: true,
+                onFailure(result) {
+                    failureRef.current = result;
+                },
+            });
+            return {
+                ok,
+                ...(failureRef.current ? { error: failureRef.current.message } : {}),
+            };
+        },
+        async createReadinessCheckDraft(request, context) {
+            const resolved = resolveLocalExecutor({ preflight: true });
+            if (!resolved.executor) {
+                throw new Error(resolved.error ?? "No local agent detected.");
+            }
+            context.emit({
+                type: "log.appended",
+                step_id: "agent-draft",
+                message: `Using ${resolved.executor.displayName} for readiness-check drafting.`,
+            });
+            const drafted = await draftReadinessChecks({
+                datasetName: request.preparation,
+                datasetPath: request.source_folder_path,
+                about: request.about,
+                executor: resolved.executor,
+                targetCount: request.target_count,
+                onStatus: (line) => context.emit({
+                    type: "log.appended",
+                    step_id: "agent-draft",
+                    message: line,
+                }),
+            });
+            if (!drafted.checks) {
+                throw new Error(drafted.error ?? "Could not draft readiness checks from this Source Folder.");
+            }
+            return {
+                checks: drafted.checks,
+            };
+        },
+        async createWorkflowAuthoringRun(request, context) {
+            const resolved = resolveLocalExecutor({ preflight: true });
+            if (!resolved.executor) {
+                throw new Error(resolved.error ?? "No local agent detected.");
+            }
+            context.emit({
+                type: "log.appended",
+                step_id: "draft-package",
+                message: `Using ${resolved.executor.displayName} for Method authoring.`,
+            });
+            const result = await runWorkflowAuthoringDraft({
+                sourcePath: context.sourcePath,
+                datasetPath: request.source_folder_path,
+                baseWorkflowId: request.reference_method_id ?? request.base_method_id,
+                workflowId: request.method_id,
+                label: request.label,
+                hint: request.hint,
+                taskPrompt: request.task_prompt,
+                checks: request.checks,
+                executor: resolved.executor,
+                onStatus: (line) => context.emit({
+                    type: "log.appended",
+                    step_id: "draft-package",
+                    message: line,
+                }),
+            });
+            return {
+                status: result.status,
+                changed: result.changed,
+                summary: result.summary,
+                validation: result.validation,
+                method_path: result.workflowPath,
+                shell_path: result.shellPath,
+            };
+        },
+    };
+    const service = await startLocalService({
+        rootPath: controlPath,
+        host: stringOption(argv.host),
+        port: numberOption(argv.port),
+        handlers,
+    });
+    console.log(chalk.green(`  Interf: ${service.url}/`));
+    console.log(chalk.dim(`  Health: ${service.url}/health`));
+    console.log(chalk.dim("  Press Ctrl-C to stop the local Interf service."));
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            void service.close().finally(resolve);
+        };
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+    });
+}

package/dist/cli/index.d.ts

@@ -8,6 +8,7 @@ import { statusCommand } from "./commands/status.js";
 import { resetCommand } from "./commands/reset.js";
 import { defaultCommand } from "./commands/default.js";
 import { verifyCommand } from "./commands/verify.js";
+import { webCommand } from "./commands/web.js";
 export declare function buildCli(argv?: string[]): import("yargs").Argv<{}>;
 export declare function runCli(argv?: string[]): {
     [x: string]: unknown;
@@ -18,4 +19,4 @@ export declare function runCli(argv?: string[]): {
     _: (string | number)[];
     $0: string;
 }>;
-export { initCommand, createCommand, compileCommand, testCommand, doctorCommand, listCommand, statusCommand, resetCommand, defaultCommand, verifyCommand, };
+export { initCommand, createCommand, compileCommand, testCommand, doctorCommand, listCommand, statusCommand, resetCommand, defaultCommand, verifyCommand, webCommand, };

package/dist/cli/index.js

@@ -10,6 +10,7 @@ import { statusCommand } from "./commands/status.js";
 import { resetCommand } from "./commands/reset.js";
 import { defaultCommand } from "./commands/default.js";
 import { verifyCommand } from "./commands/verify.js";
+import { webCommand } from "./commands/web.js";
 export function buildCli(argv = hideBin(process.argv)) {
     return yargs(argv)
         .scriptName("interf")
@@ -22,6 +23,7 @@ export function buildCli(argv = hideBin(process.argv)) {
         .command(listCommand)
         .command(statusCommand)
         .command(verifyCommand)
+        .command(webCommand)
         .command(resetCommand)
         .strict()
         .help()
@@ -30,4 +32,4 @@ export function buildCli(argv = hideBin(process.argv)) {
 export function runCli(argv = hideBin(process.argv)) {
     return buildCli(argv).parse();
 }
-export { initCommand, createCommand, compileCommand, testCommand, doctorCommand, listCommand, statusCommand, resetCommand, defaultCommand, verifyCommand, };
+export { initCommand, createCommand, compileCommand, testCommand, doctorCommand, listCommand, statusCommand, resetCommand, defaultCommand, verifyCommand, webCommand, };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export * as compiler from "./packages/compiler/index.js";
 export * as workflowPackage from "./packages/workflow-package/index.js";
 export * as workflowAuthoring from "./packages/workflow-authoring/index.js";
+export * as execution from "./packages/execution/index.js";
+export * as localService from "./packages/local-service/index.js";
 export * as projectModel from "./packages/project-model/index.js";
 export * as agents from "./packages/agents/index.js";
 export * as testing from "./packages/testing/index.js";
@@ -8,14 +10,14 @@ export { createCompiled, } from "./packages/project-model/interf.js";
 export { compileCompiled, runCompiledSummarize, runCompiledCompile, } from "./packages/compiler/workflows.js";
 export { createRawTestTarget, createCompiledTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./packages/testing/test.js";
 export { computeCompiledHealth, } from "./packages/compiler/state.js";
-export { SOURCE_FOLDER_CONFIG_FILE, SOURCE_FOLDER_CONFIG_PATH, legacySourceFolderConfigPath, loadSourceFolderConfig, migrateLegacySourceFolderConfig, resolveSourceFolderConfigPath, sourceFolderConfigPath, buildTestSpecFromSourceFolderConfig, } from "./packages/project-model/source-config.js";
+export { SOURCE_FOLDER_CONFIG_FILE, SOURCE_FOLDER_CONFIG_PATH, loadSourceFolderConfig, resolveSourceFolderConfigPath, sourceFolderConfigPath, buildTestSpecFromSourceFolderConfig, } from "./packages/project-model/source-config.js";
 export { validateCompiledSummarize, validateCompiledCompile, } from "./packages/compiler/validate.js";
 export { InterfConfigSchema, SourceFolderConfigSchema, } from "./packages/project-model/lib/schema.js";
 export { TestSpecSchema, } from "./packages/testing/lib/schema.js";
 export { CompiledHealthSchema, } from "./packages/compiler/lib/schema.js";
 export type { InterfConfig } from "./packages/project-model/lib/schema.js";
 export type { TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, LoadedTestSpec, TestTargetCandidate, } from "./packages/testing/index.js";
-export type { SourceTruthCheck, SourceDatasetConfig, SourceFolderConfig, } from "./packages/project-model/lib/schema.js";
+export type { SourceReadinessCheck, SourceDatasetConfig, SourceFolderConfig, } from "./packages/project-model/lib/schema.js";
 export type { TestCaseExpect, } from "./packages/testing/lib/schema.js";
 export type { CompiledHealth, } from "./packages/compiler/lib/schema.js";
 export type { CompiledStageValidation, CompiledWorkflowValidation, } from "./packages/compiler/validate.js";

package/dist/index.js

@@ -1,6 +1,8 @@
 export * as compiler from "./packages/compiler/index.js";
 export * as workflowPackage from "./packages/workflow-package/index.js";
 export * as workflowAuthoring from "./packages/workflow-authoring/index.js";
+export * as execution from "./packages/execution/index.js";
+export * as localService from "./packages/local-service/index.js";
 export * as projectModel from "./packages/project-model/index.js";
 export * as agents from "./packages/agents/index.js";
 export * as testing from "./packages/testing/index.js";
@@ -8,7 +10,7 @@ export { createCompiled, } from "./packages/project-model/interf.js";
 export { compileCompiled, runCompiledSummarize, runCompiledCompile, } from "./packages/compiler/workflows.js";
 export { createRawTestTarget, createCompiledTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./packages/testing/test.js";
 export { computeCompiledHealth, } from "./packages/compiler/state.js";
-export { SOURCE_FOLDER_CONFIG_FILE, SOURCE_FOLDER_CONFIG_PATH, legacySourceFolderConfigPath, loadSourceFolderConfig, migrateLegacySourceFolderConfig, resolveSourceFolderConfigPath, sourceFolderConfigPath, buildTestSpecFromSourceFolderConfig, } from "./packages/project-model/source-config.js";
+export { SOURCE_FOLDER_CONFIG_FILE, SOURCE_FOLDER_CONFIG_PATH, loadSourceFolderConfig, resolveSourceFolderConfigPath, sourceFolderConfigPath, buildTestSpecFromSourceFolderConfig, } from "./packages/project-model/source-config.js";
 export { validateCompiledSummarize, validateCompiledCompile, } from "./packages/compiler/validate.js";
 export { InterfConfigSchema, SourceFolderConfigSchema, } from "./packages/project-model/lib/schema.js";
 export { TestSpecSchema, } from "./packages/testing/lib/schema.js";

package/dist/packages/agents/lib/execution.js

@@ -18,6 +18,7 @@ export function spawnAgent(agent, dirPath, prompt, options = {}) {
         const launchLine = `Launching ${agent.displayName}...`;
         console.log(chalk.dim(`  ${launchLine}`));
         appendAgentStatusLog(options.statusLogPath, launchLine);
+        options.onStatus?.(launchLine);
         const proc = spawn(agent.command, args, {
             cwd: dirPath,
             env: buildAgentEnv(agent),
@@ -95,6 +96,7 @@ export function spawnAgent(agent, dirPath, prompt, options = {}) {
                     : `${agent.displayName} started, but has not emitted visible progress yet... (${seconds}s)`;
             console.log(chalk.dim(`  ${label}`));
             appendAgentStatusLog(options.statusLogPath, label);
+            options.onStatus?.(label);
         }, 5000);
         const forwardSignal = () => {
             requestProcessStop("SIGINT");
@@ -173,14 +175,14 @@ export function spawnAgent(agent, dirPath, prompt, options = {}) {
                         lastToolActivity = toolActivity;
                     }
                     failureStatus ||= extractAgentFailureStatus(event);
-                    if (displayAgentEvent(event, options.statusLogPath, lastVisibleText)) {
+                    if (displayAgentEvent(event, options.statusLogPath, lastVisibleText, options.onStatus)) {
                         sawVisibleEvent = true;
                         lastVisibleOutputAt = Date.now();
                     }
                     maybeInterruptAfterTerminalStatus();
                 }
                 catch {
-                    if (emitVisibleAgentText(line, options.statusLogPath, lastVisibleText)) {
+                    if (emitVisibleAgentText(line, options.statusLogPath, lastVisibleText, options.onStatus)) {
                         sawVisibleEvent = true;
                         lastVisibleOutputAt = Date.now();
                     }

package/dist/packages/agents/lib/executors.d.ts

@@ -11,6 +11,7 @@ export interface WorkflowExecuteOptions {
     eventLogPath?: string | null;
     statusLogPath?: string | null;
     completionCheck?: (() => boolean) | null;
+    onStatus?: (line: string) => void;
 }
 export interface WorkflowExecutor {
     kind: WorkflowExecutorKind;

package/dist/packages/agents/lib/executors.js

@@ -26,6 +26,7 @@ export function createLocalAgentExecutor(agent, executionProfile = {}) {
                 statusLogPath: options?.statusLogPath,
                 executionProfile,
                 completionCheck: options?.completionCheck,
+                onStatus: options?.onStatus,
             });
         },
     };

package/dist/packages/agents/lib/render.d.ts

@@ -3,6 +3,6 @@ export interface VisibleTextState {
     terminated?: boolean;
     terminalStatus?: string | null;
 }
-export declare function emitVisibleAgentText(text: string, statusLogPath: string | null | undefined, lastVisibleText?: VisibleTextState): boolean;
-export declare function displayAgentEvent(event: Record<string, unknown>, statusLogPath: string | null | undefined, lastVisibleText: VisibleTextState): boolean;
+export declare function emitVisibleAgentText(text: string, statusLogPath: string | null | undefined, lastVisibleText?: VisibleTextState, onStatus?: (line: string) => void): boolean;
+export declare function displayAgentEvent(event: Record<string, unknown>, statusLogPath: string | null | undefined, lastVisibleText: VisibleTextState, onStatus?: (line: string) => void): boolean;
 export declare function summarizeAgentToolActivity(event: Record<string, unknown>): string | null;

package/dist/packages/agents/lib/render.js

@@ -2,7 +2,7 @@ import { basename } from "node:path";
 import chalk from "chalk";
 import { SHOW_AGENT_TOOL_EVENTS, VISIBLE_STATUS_PREFIXES, } from "./constants.js";
 import { appendAgentStatusLog } from "./logs.js";
-export function emitVisibleAgentText(text, statusLogPath, lastVisibleText) {
+export function emitVisibleAgentText(text, statusLogPath, lastVisibleText, onStatus) {
     if (lastVisibleText?.terminated) {
         return false;
     }
@@ -17,6 +17,7 @@ export function emitVisibleAgentText(text, statusLogPath, lastVisibleText) {
         }
         console.log(chalk.dim(`  ${line}`));
         appendAgentStatusLog(statusLogPath, line);
+        onStatus?.(line);
         if (lastVisibleText) {
             lastVisibleText.current = line;
             if (isTerminalVisibleStatus(line)) {
@@ -28,7 +29,7 @@ export function emitVisibleAgentText(text, statusLogPath, lastVisibleText) {
     }
     return displayed;
 }
-export function displayAgentEvent(event, statusLogPath, lastVisibleText) {
+export function displayAgentEvent(event, statusLogPath, lastVisibleText, onStatus) {
     const type = event.type;
     let displayed = false;
     if (type === "tool_use" && SHOW_AGENT_TOOL_EVENTS) {
@@ -50,7 +51,7 @@ export function displayAgentEvent(event, statusLogPath, lastVisibleText) {
             for (const block of content) {
                 if (block.type === "text" && block.text) {
                     const text = block.text.trim();
-                    displayed = emitVisibleAgentText(text, statusLogPath, lastVisibleText) || displayed;
+                    displayed = emitVisibleAgentText(text, statusLogPath, lastVisibleText, onStatus) || displayed;
                 }
                 if (block.type === "tool_use" && SHOW_AGENT_TOOL_EVENTS) {
                     const name = block.name;
@@ -70,7 +71,7 @@ export function displayAgentEvent(event, statusLogPath, lastVisibleText) {
     if (type === "item.started" || type === "item.completed") {
         const item = event.item;
         if (item) {
-            displayed = displayItemEvent(type, item, statusLogPath, lastVisibleText) || displayed;
+            displayed = displayItemEvent(type, item, statusLogPath, lastVisibleText, onStatus) || displayed;
         }
     }
     if (type === "result") {
@@ -79,7 +80,7 @@ export function displayAgentEvent(event, statusLogPath, lastVisibleText) {
         if (result && subtype !== "tool_result") {
             const lines = result.split("\n");
             for (const line of lines) {
-                displayed = emitVisibleAgentText(line, statusLogPath, lastVisibleText) || displayed;
+                displayed = emitVisibleAgentText(line, statusLogPath, lastVisibleText, onStatus) || displayed;
             }
         }
     }
@@ -90,7 +91,7 @@ export function displayAgentEvent(event, statusLogPath, lastVisibleText) {
         pickString(event.summary);
     if (message && type !== "assistant" && type !== "result") {
         const text = message.trim();
-        displayed = emitVisibleAgentText(text, statusLogPath, lastVisibleText) || displayed;
+        displayed = emitVisibleAgentText(text, statusLogPath, lastVisibleText, onStatus) || displayed;
     }
     return displayed;
 }
@@ -129,16 +130,16 @@ function pickString(value) {
     }
     return null;
 }
-function displayItemEvent(type, item, statusLogPath, lastVisibleText) {
+function displayItemEvent(type, item, statusLogPath, lastVisibleText, onStatus) {
     const itemType = item.type;
     if (itemType === "agent_message") {
         const text = item.text?.trim();
-        return text ? emitVisibleAgentText(text, statusLogPath, lastVisibleText) : false;
+        return text ? emitVisibleAgentText(text, statusLogPath, lastVisibleText, onStatus) : false;
     }
     if (itemType === "command_execution" && type === "item.completed") {
         const output = item.aggregated_output?.trim();
         if (output) {
-            return emitVisibleAgentText(output, statusLogPath, lastVisibleText);
+            return emitVisibleAgentText(output, statusLogPath, lastVisibleText, onStatus);
         }
     }
     if (!SHOW_AGENT_TOOL_EVENTS) {

package/dist/packages/agents/lib/shells.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimeContractType, WorkflowImprovementContext } from "../../compiler/lib/schema.js";
-import type { SourceTruthCheck } from "../../project-model/lib/schema.js";
+import type { SourceReadinessCheck } from "../../project-model/lib/schema.js";
 import { type ContextInterfaceZoneId as WorkflowZoneId } from "../../workflow-package/context-interface.js";
 export interface NativeStageDefinition {
     id: string;
@@ -18,22 +18,14 @@ export declare function renderCompiledAgents(compiledPath: string, name: string,
 export declare function renderCompiledQuerySkill(): string;
 export declare function syncStageExecutionShellWrites(compiledPath: string, shellRoot: string, stage: NativeStageDefinition, writeArtifacts?: readonly string[]): void;
 export declare function renderClaudeBootstrap(content: string): string;
-export interface WorkflowAuthoringPreviewInfo {
-    compiledPath: string;
-    compileResult: {
-        ok: boolean;
-        failedStage: string | null;
-    };
-}
 export declare function createWorkflowAuthoringShell(options: {
     workflowPath: string;
     workflowId: string;
     label: string;
-    baseWorkflowId: string;
+    referenceWorkflowId?: string | null;
     datasetPath: string;
     taskPrompt: string;
-    checks: SourceTruthCheck[];
-    preview?: WorkflowAuthoringPreviewInfo | null;
+    checks: SourceReadinessCheck[];
 }): {
     rootPath: string;
     workflowBeforePath: string;