agentweaver 0.1.2 → 0.1.3

package/dist/pipeline/spec-validator.js

@@ -0,0 +1,290 @@
+import { TaskRunnerError } from "../errors.js";
+import { isPromptTemplateRef } from "./prompt-registry.js";
+function assert(condition, message) {
+    if (!condition) {
+        throw new TaskRunnerError(message);
+    }
+}
+function validateValueSpec(value, path) {
+    if ("const" in value || "ref" in value || "artifact" in value || "artifactList" in value) {
+        return;
+    }
+    if ("template" in value) {
+        if (value.vars) {
+            for (const [key, candidate] of Object.entries(value.vars)) {
+                validateValueSpec(candidate, `${path}.vars.${key}`);
+            }
+        }
+        return;
+    }
+    if ("appendPrompt" in value) {
+        if (value.appendPrompt.base) {
+            validateValueSpec(value.appendPrompt.base, `${path}.appendPrompt.base`);
+        }
+        validateValueSpec(value.appendPrompt.suffix, `${path}.appendPrompt.suffix`);
+        return;
+    }
+    if ("concat" in value) {
+        value.concat.forEach((candidate, index) => validateValueSpec(candidate, `${path}.concat[${index}]`));
+        return;
+    }
+    if ("list" in value) {
+        value.list.forEach((candidate, index) => validateValueSpec(candidate, `${path}.list[${index}]`));
+        return;
+    }
+    throw new TaskRunnerError(`Unsupported value spec at ${path}`);
+}
+function validateCondition(condition, path) {
+    if (!condition) {
+        return;
+    }
+    if ("ref" in condition) {
+        return;
+    }
+    if ("not" in condition) {
+        validateCondition(condition.not, `${path}.not`);
+        return;
+    }
+    if ("all" in condition) {
+        condition.all.forEach((candidate, index) => validateCondition(candidate, `${path}.all[${index}]`));
+        return;
+    }
+    if ("any" in condition) {
+        condition.any.forEach((candidate, index) => validateCondition(candidate, `${path}.any[${index}]`));
+        return;
+    }
+    if ("equals" in condition) {
+        validateValueSpec(condition.equals[0], `${path}.equals[0]`);
+        validateValueSpec(condition.equals[1], `${path}.equals[1]`);
+        return;
+    }
+    if ("exists" in condition) {
+        validateValueSpec(condition.exists, `${path}.exists`);
+        return;
+    }
+    throw new TaskRunnerError(`Unsupported condition at ${path}`);
+}
+function validateStep(step, nodeRegistry, path) {
+    assert(nodeRegistry.has(step.node), `Unknown node kind '${step.node}' at ${path}.node`);
+    const nodeMeta = nodeRegistry.getMeta(step.node);
+    validateCondition(step.when, `${path}.when`);
+    if (step.prompt) {
+        assert(nodeMeta.prompt !== "forbidden", `Node '${step.node}' does not accept prompt binding at ${path}.prompt`);
+        assert(Boolean(step.prompt.templateRef || step.prompt.inlineTemplate), `Prompt binding at ${path}.prompt must define templateRef or inlineTemplate`);
+    }
+    assert(step.prompt !== undefined || nodeMeta.prompt !== "required", `Node '${step.node}' requires prompt binding at ${path}.prompt`);
+    for (const requiredParam of nodeMeta.requiredParams ?? []) {
+        assert(step.params?.[requiredParam] !== undefined, `Node '${step.node}' requires param '${requiredParam}' at ${path}.params.${requiredParam}`);
+    }
+    if (step.prompt?.templateRef) {
+        assert(isPromptTemplateRef(step.prompt.templateRef), `Unknown prompt template '${step.prompt.templateRef}' at ${path}.prompt.templateRef`);
+    }
+    if (step.prompt?.vars) {
+        for (const [key, value] of Object.entries(step.prompt.vars)) {
+            validateValueSpec(value, `${path}.prompt.vars.${key}`);
+        }
+    }
+    if (step.prompt?.extraPrompt) {
+        validateValueSpec(step.prompt.extraPrompt, `${path}.prompt.extraPrompt`);
+    }
+    if (step.params) {
+        for (const [key, value] of Object.entries(step.params)) {
+            validateValueSpec(value, `${path}.params.${key}`);
+        }
+    }
+    if (step.expect) {
+        step.expect.forEach((expectation, index) => validateExpectation(expectation, `${path}.expect[${index}]`));
+    }
+    if (step.stopFlowIf) {
+        validateCondition(step.stopFlowIf, `${path}.stopFlowIf`);
+    }
+    if (step.after) {
+        step.after.forEach((action, index) => validateAfterAction(action, `${path}.after[${index}]`));
+    }
+}
+function validateExpectation(expectation, path) {
+    validateCondition(expectation.when, `${path}.when`);
+    if (expectation.kind === "require-artifacts") {
+        validateValueSpec(expectation.paths, `${path}.paths`);
+        return;
+    }
+    if (expectation.kind === "require-file") {
+        validateValueSpec(expectation.path, `${path}.path`);
+        return;
+    }
+    if (expectation.kind === "step-output") {
+        validateValueSpec(expectation.value, `${path}.value`);
+        if (expectation.equals) {
+            validateValueSpec(expectation.equals, `${path}.equals`);
+        }
+        return;
+    }
+    throw new TaskRunnerError(`Unsupported expectation at ${path}`);
+}
+function validateAfterAction(action, path) {
+    validateCondition(action.when, `${path}.when`);
+    if (action.kind === "set-summary-from-file") {
+        validateValueSpec(action.path, `${path}.path`);
+        return;
+    }
+    throw new TaskRunnerError(`Unsupported after action at ${path}`);
+}
+function validatePhase(phase, nodeRegistry, path) {
+    assert(phase.id.trim().length > 0, `Phase id must be non-empty at ${path}.id`);
+    validateCondition(phase.when, `${path}.when`);
+    phase.steps.forEach((step, index) => validateStep(step, nodeRegistry, `${path}.steps[${index}]`));
+}
+function validateRefPath(ref, phases, currentPhaseIndex, currentStepIndex, path, allowCurrentStepRef = false) {
+    const [scope, ...rest] = ref.split(".");
+    const supportedScopes = new Set(["params", "flow", "context", "repeat", "steps"]);
+    assert(supportedScopes.has(scope ?? ""), `Unsupported ref scope '${scope ?? ""}' at ${path}`);
+    if (scope !== "steps") {
+        return;
+    }
+    assert(rest.length >= 3, `Invalid step ref '${ref}' at ${path}`);
+    const [phaseId, stepId, stepScope] = rest;
+    assert(stepScope === "outputs" || stepScope === "value" || stepScope === "status", `Unsupported step ref scope '${stepScope}' at ${path}`);
+    const phaseIndex = phases.findIndex((candidate) => candidate.id === phaseId);
+    assert(phaseIndex >= 0, `Unknown phase '${phaseId}' in ref '${ref}' at ${path}`);
+    const phase = phases[phaseIndex];
+    if (!phase) {
+        throw new TaskRunnerError(`Unknown phase '${phaseId}' in ref '${ref}' at ${path}`);
+    }
+    const stepIndex = phase.steps.findIndex((candidate) => candidate.id === stepId);
+    assert(stepIndex >= 0, `Unknown step '${stepId}' in ref '${ref}' at ${path}`);
+    const isCurrentOrFuturePhase = phaseIndex > currentPhaseIndex || (phaseIndex === currentPhaseIndex && stepIndex > currentStepIndex);
+    const isCurrentStep = phaseIndex === currentPhaseIndex && stepIndex === currentStepIndex;
+    assert(!isCurrentOrFuturePhase, `Step ref '${ref}' at ${path} must point to a previously completed step`);
+    assert(allowCurrentStepRef || !isCurrentStep, `Step ref '${ref}' at ${path} must not point to the current step`);
+}
+function validateExpandedValueSpec(value, phases, currentPhaseIndex, currentStepIndex, path, allowCurrentStepRef = false) {
+    if ("const" in value) {
+        return;
+    }
+    if ("ref" in value) {
+        validateRefPath(value.ref, phases, currentPhaseIndex, currentStepIndex, path, allowCurrentStepRef);
+        return;
+    }
+    if ("artifact" in value) {
+        validateExpandedValueSpec(value.artifact.taskKey, phases, currentPhaseIndex, currentStepIndex, `${path}.artifact.taskKey`, allowCurrentStepRef);
+        if (value.artifact.iteration) {
+            validateExpandedValueSpec(value.artifact.iteration, phases, currentPhaseIndex, currentStepIndex, `${path}.artifact.iteration`, allowCurrentStepRef);
+        }
+        return;
+    }
+    if ("artifactList" in value) {
+        validateExpandedValueSpec(value.artifactList.taskKey, phases, currentPhaseIndex, currentStepIndex, `${path}.artifactList.taskKey`, allowCurrentStepRef);
+        return;
+    }
+    if ("template" in value) {
+        Object.entries(value.vars ?? {}).forEach(([key, candidate]) => validateExpandedValueSpec(candidate, phases, currentPhaseIndex, currentStepIndex, `${path}.vars.${key}`, allowCurrentStepRef));
+        return;
+    }
+    if ("appendPrompt" in value) {
+        if (value.appendPrompt.base) {
+            validateExpandedValueSpec(value.appendPrompt.base, phases, currentPhaseIndex, currentStepIndex, `${path}.appendPrompt.base`, allowCurrentStepRef);
+        }
+        validateExpandedValueSpec(value.appendPrompt.suffix, phases, currentPhaseIndex, currentStepIndex, `${path}.appendPrompt.suffix`, allowCurrentStepRef);
+        return;
+    }
+    if ("concat" in value) {
+        value.concat.forEach((candidate, index) => validateExpandedValueSpec(candidate, phases, currentPhaseIndex, currentStepIndex, `${path}.concat[${index}]`, allowCurrentStepRef));
+        return;
+    }
+    if ("list" in value) {
+        value.list.forEach((candidate, index) => validateExpandedValueSpec(candidate, phases, currentPhaseIndex, currentStepIndex, `${path}.list[${index}]`, allowCurrentStepRef));
+    }
+}
+function validateExpandedCondition(condition, phases, currentPhaseIndex, currentStepIndex, path, allowCurrentStepRef = false) {
+    if (!condition) {
+        return;
+    }
+    if ("ref" in condition) {
+        validateRefPath(condition.ref, phases, currentPhaseIndex, currentStepIndex, path, allowCurrentStepRef);
+        return;
+    }
+    if ("not" in condition) {
+        validateExpandedCondition(condition.not, phases, currentPhaseIndex, currentStepIndex, `${path}.not`, allowCurrentStepRef);
+        return;
+    }
+    if ("all" in condition) {
+        condition.all.forEach((candidate, index) => validateExpandedCondition(candidate, phases, currentPhaseIndex, currentStepIndex, `${path}.all[${index}]`, allowCurrentStepRef));
+        return;
+    }
+    if ("any" in condition) {
+        condition.any.forEach((candidate, index) => validateExpandedCondition(candidate, phases, currentPhaseIndex, currentStepIndex, `${path}.any[${index}]`, allowCurrentStepRef));
+        return;
+    }
+    if ("equals" in condition) {
+        validateExpandedValueSpec(condition.equals[0], phases, currentPhaseIndex, currentStepIndex, `${path}.equals[0]`, allowCurrentStepRef);
+        validateExpandedValueSpec(condition.equals[1], phases, currentPhaseIndex, currentStepIndex, `${path}.equals[1]`, allowCurrentStepRef);
+        return;
+    }
+    if ("exists" in condition) {
+        validateExpandedValueSpec(condition.exists, phases, currentPhaseIndex, currentStepIndex, `${path}.exists`, allowCurrentStepRef);
+    }
+}
+export function validateFlowSpec(spec, nodeRegistry) {
+    assert(spec.kind.trim().length > 0, "Flow spec kind must be non-empty");
+    assert(Number.isInteger(spec.version) && spec.version > 0, "Flow spec version must be a positive integer");
+    spec.phases.forEach((item, index) => {
+        if ("repeat" in item) {
+            assert(item.repeat.var.trim().length > 0, `Repeat var must be non-empty at phases[${index}].repeat.var`);
+            assert(item.repeat.to >= item.repeat.from, `Repeat range is invalid at phases[${index}].repeat`);
+            item.phases.forEach((phase, phaseIndex) => validatePhase(phase, nodeRegistry, `phases[${index}].phases[${phaseIndex}]`));
+            return;
+        }
+        validatePhase(item, nodeRegistry, `phases[${index}]`);
+    });
+}
+export function validateExpandedPhases(phases) {
+    const ids = new Set();
+    for (const [phaseIndex, phase] of phases.entries()) {
+        if (ids.has(phase.id)) {
+            throw new TaskRunnerError(`Duplicate expanded phase id: ${phase.id}`);
+        }
+        ids.add(phase.id);
+        validateExpandedCondition(phase.when, phases, phaseIndex, 0, `phases.${phase.id}.when`);
+        const stepIds = new Set();
+        for (const [stepIndex, step] of phase.steps.entries()) {
+            if (stepIds.has(step.id)) {
+                throw new TaskRunnerError(`Duplicate step id '${step.id}' inside phase '${phase.id}'`);
+            }
+            stepIds.add(step.id);
+            validateExpandedCondition(step.when, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.when`);
+            if (step.prompt?.vars) {
+                Object.entries(step.prompt.vars).forEach(([key, value]) => validateExpandedValueSpec(value, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.prompt.vars.${key}`));
+            }
+            if (step.prompt?.extraPrompt) {
+                validateExpandedValueSpec(step.prompt.extraPrompt, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.prompt.extraPrompt`);
+            }
+            if (step.params) {
+                Object.entries(step.params).forEach(([key, value]) => validateExpandedValueSpec(value, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.params.${key}`));
+            }
+            if (step.expect) {
+                step.expect.forEach((expectation, index) => {
+                    validateExpandedCondition(expectation.when, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.expect[${index}].when`);
+                    if (expectation.kind === "require-artifacts") {
+                        validateExpandedValueSpec(expectation.paths, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.expect[${index}].paths`);
+                        return;
+                    }
+                    if (expectation.kind === "require-file") {
+                        validateExpandedValueSpec(expectation.path, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.expect[${index}].path`);
+                        return;
+                    }
+                    validateExpandedValueSpec(expectation.value, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.expect[${index}].value`);
+                    if (expectation.equals) {
+                        validateExpandedValueSpec(expectation.equals, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.expect[${index}].equals`);
+                    }
+                });
+            }
+            validateExpandedCondition(step.stopFlowIf, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.stopFlowIf`, true);
+            if (step.after) {
+                step.after.forEach((action, index) => {
+                    validateExpandedCondition(action.when, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.after[${index}].when`);
+                    validateExpandedValueSpec(action.path, phases, phaseIndex, stepIndex, `phases.${phase.id}.steps.${step.id}.after[${index}].path`);
+                });
+            }
+        }
+    }
+}

package/dist/pipeline/value-resolver.js

@@ -0,0 +1,199 @@
+import { existsSync } from "node:fs";
+import { artifactFile, designFile, jiraTaskFile, planArtifacts, planFile, qaFile, readyToMergeFile, taskSummaryFile, } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+import { formatTemplate } from "../prompts.js";
+function readStepRef(segments, context, originalPath) {
+    const [phaseId, stepId, scope, ...rest] = segments;
+    if (!phaseId || !stepId || !scope) {
+        throw new TaskRunnerError(`Invalid step ref '${originalPath}'`);
+    }
+    const phase = context.executionState?.phases.find((candidate) => candidate.id === phaseId);
+    if (!phase) {
+        throw new TaskRunnerError(`Unable to resolve step ref '${originalPath}': unknown phase '${phaseId}'`);
+    }
+    const step = phase.steps.find((candidate) => candidate.id === stepId);
+    if (!step) {
+        throw new TaskRunnerError(`Unable to resolve step ref '${originalPath}': unknown step '${stepId}' in phase '${phaseId}'`);
+    }
+    let current;
+    if (scope === "outputs") {
+        current = step.outputs;
+    }
+    else if (scope === "value") {
+        current = step.value;
+    }
+    else if (scope === "status") {
+        current = step.status;
+    }
+    else {
+        throw new TaskRunnerError(`Unsupported step ref scope in '${originalPath}'`);
+    }
+    for (const segment of rest) {
+        if (!segment) {
+            continue;
+        }
+        if (!current || typeof current !== "object" || !(segment in current)) {
+            throw new TaskRunnerError(`Unable to resolve ref '${originalPath}'`);
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function readRef(path, context) {
+    const [scope, ...rest] = path.split(".");
+    if (scope === "steps") {
+        return readStepRef(rest, context, path);
+    }
+    const root = scope === "params"
+        ? context.flowParams
+        : scope === "flow"
+            ? context.flowConstants
+            : scope === "context"
+                ? context.pipelineContext
+                : scope === "repeat"
+                    ? context.repeatVars
+                    : undefined;
+    if (root === undefined) {
+        throw new TaskRunnerError(`Unsupported ref scope in '${path}'`);
+    }
+    let current = root;
+    for (const segment of rest) {
+        if (!segment) {
+            continue;
+        }
+        if (!current || typeof current !== "object" || !(segment in current)) {
+            throw new TaskRunnerError(`Unable to resolve ref '${path}'`);
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function resolveArtifact(spec, context) {
+    const taskKey = String(resolveValue(spec.taskKey, context));
+    const iteration = spec.iteration === undefined ? undefined : Number(resolveValue(spec.iteration, context));
+    switch (spec.kind) {
+        case "design-file":
+            return designFile(taskKey);
+        case "jira-task-file":
+            return jiraTaskFile(taskKey);
+        case "plan-file":
+            return planFile(taskKey);
+        case "qa-file":
+            return qaFile(taskKey);
+        case "ready-to-merge-file":
+            return readyToMergeFile(taskKey);
+        case "review-file":
+            if (iteration === undefined) {
+                throw new TaskRunnerError("review-file requires iteration");
+            }
+            return artifactFile("review", taskKey, iteration);
+        case "review-fix-file":
+            if (iteration === undefined) {
+                throw new TaskRunnerError("review-fix-file requires iteration");
+            }
+            return artifactFile("review-fix", taskKey, iteration);
+        case "review-reply-file":
+            if (iteration === undefined) {
+                throw new TaskRunnerError("review-reply-file requires iteration");
+            }
+            return artifactFile("review-reply", taskKey, iteration);
+        case "review-reply-summary-file":
+            if (iteration === undefined) {
+                throw new TaskRunnerError("review-reply-summary-file requires iteration");
+            }
+            return artifactFile("review-reply-summary", taskKey, iteration);
+        case "review-summary-file":
+            if (iteration === undefined) {
+                throw new TaskRunnerError("review-summary-file requires iteration");
+            }
+            return artifactFile("review-summary", taskKey, iteration);
+        case "task-summary-file":
+            return taskSummaryFile(taskKey);
+    }
+}
+function resolveArtifactList(spec, context) {
+    const taskKey = String(resolveValue(spec.taskKey, context));
+    switch (spec.kind) {
+        case "plan-artifacts":
+            return planArtifacts(taskKey);
+    }
+}
+export function resolveValue(value, context) {
+    if ("const" in value) {
+        return value.const;
+    }
+    if ("ref" in value) {
+        return readRef(value.ref, context);
+    }
+    if ("artifact" in value) {
+        return resolveArtifact(value.artifact, context);
+    }
+    if ("artifactList" in value) {
+        return resolveArtifactList(value.artifactList, context);
+    }
+    if ("template" in value) {
+        const vars = Object.fromEntries(Object.entries(value.vars ?? {}).map(([key, candidate]) => [key, String(resolveValue(candidate, context))]));
+        return formatTemplate(value.template, vars);
+    }
+    if ("appendPrompt" in value) {
+        const base = value.appendPrompt.base === undefined ? null : resolveValue(value.appendPrompt.base, context);
+        const suffix = resolveValue(value.appendPrompt.suffix, context);
+        const baseText = base === null || base === undefined ? "" : String(base).trim();
+        const suffixText = String(suffix).trim();
+        if (!baseText) {
+            return suffixText;
+        }
+        if (!suffixText) {
+            return baseText;
+        }
+        return `${baseText}\n${suffixText}`;
+    }
+    if ("concat" in value) {
+        return value.concat
+            .map((candidate) => resolveValue(candidate, context))
+            .filter((chunk) => chunk !== null && chunk !== undefined)
+            .map((chunk) => String(chunk))
+            .join("");
+    }
+    if ("list" in value) {
+        return value.list.map((candidate) => resolveValue(candidate, context));
+    }
+    throw new TaskRunnerError("Unsupported value spec");
+}
+export function resolveParams(params, context) {
+    if (!params) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, resolveValue(value, context)]));
+}
+function truthy(value) {
+    return Boolean(value);
+}
+export function evaluateCondition(condition, context) {
+    if (!condition) {
+        return true;
+    }
+    if ("ref" in condition) {
+        return truthy(readRef(condition.ref, context));
+    }
+    if ("not" in condition) {
+        return !evaluateCondition(condition.not, context);
+    }
+    if ("all" in condition) {
+        return condition.all.every((candidate) => evaluateCondition(candidate, context));
+    }
+    if ("any" in condition) {
+        return condition.any.some((candidate) => evaluateCondition(candidate, context));
+    }
+    if ("equals" in condition) {
+        return resolveValue(condition.equals[0], context) === resolveValue(condition.equals[1], context);
+    }
+    if ("exists" in condition) {
+        const value = resolveValue(condition.exists, context);
+        if (typeof value !== "string") {
+            throw new TaskRunnerError("exists condition requires string path");
+        }
+        return existsSync(value);
+    }
+    return false;
+}

package/dist/prompts.js

@@ -4,9 +4,7 @@ export const PLAN_PROMPT_TEMPLATE = "Посмотри и проанализир
     "Разработай системный дизайн решения, запиши в {design_file}. " +
     "Разработай подробный план реализации и запиши его в {plan_file}. " +
     "Разработай план тестирования для QA и запиши в {qa_file}. ";
-export const IMPLEMENT_PROMPT_TEMPLATE = "Проанализируй системный дизайн {design_file}, план реализации {plan_file} и приступай к реализации по плану. " +
-    "По окончании обязательно прогони вне песочницы линтер, все тесты, сгенерируй make swagger. " +
-    "Исправь ошибки линтера и тестов, если будут.";
+export const IMPLEMENT_PROMPT_TEMPLATE = "Проанализируй системный дизайн {design_file}, план реализации {plan_file} и приступай к реализации по плану. ";
 export const REVIEW_PROMPT_TEMPLATE = "Проведи код-ревью текущих изменений. " +
     "Сверься с задачей в {jira_task_file}, дизайном {design_file} и планом {plan_file}. " +
     "Замечания и комментарии запиши в {review_file}. " +

package/dist/runtime/process-runner.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import process from "node:process";
 import { spawn } from "node:child_process";
-import { dim, formatDone, getOutputAdapter, setCurrentExecutor } from "../tui.js";
+import { getExecutionState, getOutputAdapter, printFramedBlock, printInfo, setCurrentExecutor } from "../tui.js";
 import { shellQuote } from "./command-resolution.js";
 export function formatCommand(argv, env) {
     const envParts = Object.entries(env ?? {})
@@ -16,6 +16,23 @@ export function formatDuration(ms) {
     const seconds = String(totalSeconds % 60).padStart(2, "0");
     return `${minutes}:${seconds}`;
 }
+function formatLaunchDetails(statusLabel) {
+    const state = getExecutionState();
+    const lines = [];
+    if (state.node) {
+        lines.push(`Node: ${state.node}`);
+    }
+    const executorLabel = state.executor ?? statusLabel;
+    const separatorIndex = executorLabel.indexOf(":");
+    if (separatorIndex >= 0) {
+        lines.push(`Executor: ${executorLabel.slice(0, separatorIndex)}`);
+        lines.push(`Model: ${executorLabel.slice(separatorIndex + 1)}`);
+    }
+    else {
+        lines.push(`Executor: ${executorLabel}`);
+    }
+    return lines.join("\n");
+}
 export async function runCommand(argv, options = {}) {
     const { env, dryRun = false, verbose = false, label, printFailureOutput = true } = options;
     const outputAdapter = getOutputAdapter();
@@ -44,8 +61,6 @@ export async function runCommand(argv, options = {}) {
     }
     const startedAt = Date.now();
     const statusLabel = label ?? path.basename(argv[0] ?? argv.join(" "));
-    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-    let frameIndex = 0;
     let output = "";
     const child = spawn(argv[0] ?? "", argv.slice(1), {
         env,
@@ -55,38 +70,27 @@ export async function runCommand(argv, options = {}) {
     child.stdout?.on("data", (chunk) => {
         const text = String(chunk);
         output += text;
-        if (!outputAdapter.supportsTransientStatus || verbose) {
+        if (verbose) {
             outputAdapter.writeStdout(text);
         }
     });
     child.stderr?.on("data", (chunk) => {
         const text = String(chunk);
         output += text;
-        if (!outputAdapter.supportsTransientStatus || verbose) {
+        if (verbose) {
             outputAdapter.writeStderr(text);
         }
     });
-    if (!outputAdapter.supportsTransientStatus && outputAdapter.renderAuxiliaryOutput !== false) {
-        outputAdapter.writeStdout(`Running ${statusLabel}\n`);
+    if (outputAdapter.renderAuxiliaryOutput !== false) {
+        printFramedBlock("Запуск", formatLaunchDetails(statusLabel), "cyan");
     }
-    const timer = outputAdapter.supportsTransientStatus
-        ? setInterval(() => {
-            const elapsed = formatDuration(Date.now() - startedAt);
-            process.stdout.write(`\r${frames[frameIndex]} ${statusLabel} ${dim(elapsed)}`);
-            frameIndex = (frameIndex + 1) % frames.length;
-        }, 200)
-        : null;
     try {
         const exitCode = await new Promise((resolve, reject) => {
             child.on("error", reject);
             child.on("exit", (code) => resolve(code ?? 1));
         });
-        if (timer) {
-            clearInterval(timer);
-            process.stdout.write(`\r${" ".repeat(80)}\r${formatDone(formatDuration(Date.now() - startedAt))}\n`);
-        }
-        else if (outputAdapter.renderAuxiliaryOutput !== false) {
-            outputAdapter.writeStdout(`Done ${formatDuration(Date.now() - startedAt)}\n`);
+        if (outputAdapter.renderAuxiliaryOutput !== false) {
+            printInfo(`Закончили работу: ${statusLabel} (${formatDuration(Date.now() - startedAt)})`);
         }
         if (exitCode !== 0) {
             if (output && printFailureOutput && outputAdapter.supportsTransientStatus) {
@@ -104,8 +108,5 @@ export async function runCommand(argv, options = {}) {
     }
     finally {
         setCurrentExecutor(null);
-        if (timer) {
-            clearInterval(timer);
-        }
     }
 }