agentweaver 0.1.18 → 0.1.20

package/dist/pipeline/auto-flow-blocks.js

@@ -0,0 +1,307 @@
+const SOURCE_SLOT = ["source"];
+const NORMALIZE_SLOT = ["normalize"];
+const PLANNING_SLOT = ["planning"];
+const DESIGN_REVIEW_SLOT = ["designReview"];
+const IMPLEMENTATION_SLOT = ["implementation"];
+const REVIEW_SLOT = ["review"];
+const ref = (value) => ({ ref: value });
+const constant = (value) => ({ const: value });
+function sourcePhase() {
+    return {
+        id: "source",
+        steps: [
+            {
+                id: "fetch_jira_source",
+                when: { ref: "params.jiraApiUrl" },
+                node: "flow-run",
+                params: {
+                    fileName: constant("jira-fetch.json"),
+                    labelText: constant("Fetching Jira task source"),
+                    jiraApiUrl: ref("params.jiraApiUrl"),
+                    taskKey: ref("params.taskKey"),
+                },
+            },
+            {
+                id: "collect_manual_source",
+                when: { not: { ref: "params.jiraApiUrl" } },
+                node: "flow-run",
+                params: {
+                    fileName: constant("manual-jira-input.json"),
+                    labelText: constant("Collecting manual Jira task source"),
+                    taskKey: ref("params.taskKey"),
+                },
+            },
+        ],
+    };
+}
+function normalizePhase() {
+    return {
+        id: "normalize",
+        steps: [
+            {
+                id: "run_normalize_source",
+                node: "flow-run",
+                params: {
+                    fileName: constant("normalize-task-source.json"),
+                    labelText: constant("Normalizing task source"),
+                    taskKey: ref("params.taskKey"),
+                    iteration: ref("params.taskContextIteration"),
+                    llmExecutor: ref("params.llmExecutor"),
+                    llmModel: ref("params.llmModel"),
+                    extraPrompt: ref("params.extraPrompt"),
+                },
+            },
+        ],
+    };
+}
+function planningPhase() {
+    return {
+        id: "plan",
+        steps: [
+            {
+                id: "run_plan_flow",
+                node: "flow-run",
+                params: {
+                    fileName: constant("plan.json"),
+                    labelText: constant("Running planning flow"),
+                    taskKey: ref("params.taskKey"),
+                    taskContextIteration: ref("params.taskContextIteration"),
+                    designIteration: ref("params.designIteration"),
+                    planIteration: ref("params.planIteration"),
+                    qaIteration: ref("params.qaIteration"),
+                    llmExecutor: ref("params.llmExecutor"),
+                    llmModel: ref("params.llmModel"),
+                    extraPrompt: ref("params.extraPrompt"),
+                    mdLang: ref("params.mdLang"),
+                },
+            },
+        ],
+    };
+}
+function designReviewLoopPhase() {
+    return {
+        id: "design_review_loop",
+        steps: [
+            {
+                id: "run_design_review_loop",
+                node: "flow-run",
+                params: {
+                    fileName: constant("design-review-loop.json"),
+                    labelText: constant("Running design-review loop"),
+                    taskKey: ref("params.taskKey"),
+                    baseIteration: ref("params.designReviewBaseIteration"),
+                    workspaceDir: ref("params.workspaceDir"),
+                    extraPrompt: ref("params.extraPrompt"),
+                    llmExecutor: ref("params.llmExecutor"),
+                    llmModel: ref("params.llmModel"),
+                },
+                stopFlowIf: {
+                    equals: [
+                        ref("steps.design_review_loop.run_design_review_loop.value.executionState.terminationOutcome"),
+                        constant("stopped"),
+                    ],
+                },
+                stopFlowOutcome: "stopped",
+            },
+        ],
+    };
+}
+function implementationPromptVars(context) {
+    const vars = {
+        design_file: ref("steps.implement.resolve_planning_bundle.value.designFile"),
+        design_json_file: ref("steps.implement.resolve_planning_bundle.value.designJsonFile"),
+        plan_file: ref("steps.implement.resolve_planning_bundle.value.planFile"),
+        plan_json_file: ref("steps.implement.resolve_planning_bundle.value.planJsonFile"),
+        qa_file: ref("steps.implement.resolve_planning_bundle.value.qaFile"),
+        qa_json_file: ref("steps.implement.resolve_planning_bundle.value.qaJsonFile"),
+    };
+    if (context.presetId === "standard") {
+        vars.project_guidance_file = constant("not provided");
+        vars.project_guidance_json_file = constant("not provided");
+    }
+    return vars;
+}
+function implementationPhase(context) {
+    const routingGroup = context.presetId === "standard" ? "implementation" : undefined;
+    const runImplementStep = {
+        id: "run_implement",
+        node: "llm-prompt",
+        ...(routingGroup ? { routingGroup } : {}),
+        prompt: {
+            templateRef: "implement",
+            vars: implementationPromptVars(context),
+            extraPrompt: ref("params.extraPrompt"),
+            format: "task-prompt",
+        },
+        params: {
+            labelText: constant("Running implementation mode locally"),
+            model: ref("params.llmModel"),
+            executor: ref("params.llmExecutor"),
+        },
+    };
+    return {
+        id: "implement",
+        steps: [
+            {
+                id: "resolve_planning_bundle",
+                node: "planning-bundle",
+                params: {
+                    taskKey: ref("params.taskKey"),
+                },
+            },
+            runImplementStep,
+            {
+                id: "notify_implement_complete",
+                node: "telegram-notify",
+                params: {
+                    message: {
+                        template: "Implementation phase for {taskKey} complete.",
+                        vars: {
+                            taskKey: ref("params.taskKey"),
+                        },
+                    },
+                },
+            },
+        ],
+    };
+}
+function reviewLoopPhase(context) {
+    const runReviewLoopStep = {
+        id: "run_review_loop",
+        node: "flow-run",
+        ...(context.presetId === "standard"
+            ? {
+                stopFlowIf: {
+                    not: {
+                        equals: [
+                            ref("steps.review-loop.run_review_loop.value.executionState.terminationOutcome"),
+                            constant("success"),
+                        ],
+                    },
+                },
+                stopFlowOutcome: "stopped",
+            }
+            : {}),
+        params: {
+            fileName: constant("review-loop.json"),
+            labelText: constant("Running review-loop"),
+            taskKey: ref("params.taskKey"),
+            baseIteration: ref("params.baseIteration"),
+            workspaceDir: ref("params.workspaceDir"),
+            extraPrompt: ref("params.extraPrompt"),
+            reviewFixPoints: ref("params.reviewFixPoints"),
+            reviewBlockingSeverities: ref("params.reviewBlockingSeverities"),
+            llmExecutor: ref("params.llmExecutor"),
+            llmModel: ref("params.llmModel"),
+        },
+    };
+    return {
+        id: "review-loop",
+        steps: [
+            runReviewLoopStep,
+            {
+                id: "notify_task_complete",
+                node: "telegram-notify",
+                params: {
+                    message: {
+                        template: "Task {taskKey} complete.",
+                        vars: {
+                            taskKey: ref("params.taskKey"),
+                        },
+                    },
+                },
+            },
+        ],
+    };
+}
+export const BUILT_IN_AUTO_FLOW_BLOCKS = [
+    {
+        id: "source.jira",
+        title: "Task source",
+        category: "source",
+        allowedSlots: SOURCE_SLOT,
+        requires: [],
+        provides: ["task.source"],
+        locked: true,
+        defaultEnabled: true,
+        createPhase: sourcePhase,
+    },
+    {
+        id: "normalize.task-source",
+        title: "Task source normalization",
+        category: "normalize",
+        allowedSlots: NORMALIZE_SLOT,
+        requires: ["task.source"],
+        provides: ["task.context"],
+        locked: true,
+        defaultEnabled: true,
+        createPhase: normalizePhase,
+    },
+    {
+        id: "planning.plan",
+        title: "Planning",
+        category: "planning",
+        allowedSlots: PLANNING_SLOT,
+        requires: ["task.context"],
+        provides: ["planning.result", "planning.bundle"],
+        locked: true,
+        defaultEnabled: true,
+        createPhase: planningPhase,
+    },
+    {
+        id: "review.design-loop",
+        title: "Design review loop",
+        category: "review",
+        allowedSlots: DESIGN_REVIEW_SLOT,
+        requires: ["planning.result"],
+        provides: ["design-review.result"],
+        defaultEnabled: true,
+        params: {
+            maxIterations: {
+                type: "integer",
+                min: 1,
+                max: 5,
+                default: 3,
+                supportedExecutableValues: [3],
+            },
+        },
+        createPhase: designReviewLoopPhase,
+    },
+    {
+        id: "implementation.default",
+        title: "Default implementation",
+        category: "implementation",
+        allowedSlots: IMPLEMENTATION_SLOT,
+        requires: ["planning.bundle"],
+        provides: ["implementation.result"],
+        locked: true,
+        defaultEnabled: true,
+        createPhase: implementationPhase,
+    },
+    {
+        id: "review.loop",
+        title: "Review loop",
+        category: "review",
+        allowedSlots: REVIEW_SLOT,
+        requires: ["implementation.result"],
+        provides: ["review.result"],
+        defaultEnabled: true,
+        params: {
+            maxIterations: {
+                type: "integer",
+                min: 1,
+                max: 5,
+                default: 5,
+                supportedExecutableValues: [5],
+            },
+        },
+        createPhase: reviewLoopPhase,
+    },
+];
+const builtInBlockById = new Map(BUILT_IN_AUTO_FLOW_BLOCKS.map((block) => [block.id, block]));
+export function listBuiltInAutoFlowBlockDefinitions() {
+    return [...BUILT_IN_AUTO_FLOW_BLOCKS];
+}
+export function getBuiltInAutoFlowBlockDefinition(blockId) {
+    return builtInBlockById.get(blockId) ?? null;
+}

package/dist/pipeline/auto-flow-config.js

@@ -0,0 +1,273 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { TaskRunnerError } from "../errors.js";
+import { agentweaverConfigDir } from "../runtime/env-loader.js";
+import { getBuiltInAutoFlowBlockDefinition } from "./auto-flow-blocks.js";
+export const AUTO_FLOW_PRESETS = ["simple", "standard"];
+export const AUTO_FLOW_SLOT_NAMES = [
+    "designReview",
+    "postImplementationChecks",
+    "review",
+    "final",
+];
+export const AUTO_FLOW_BLOCK_IDS = [
+    "review.design-loop",
+    "checks.go.linter",
+    "checks.go.tests",
+    "review.loop",
+];
+const SLOT_BLOCKS = {
+    designReview: ["review.design-loop"],
+    postImplementationChecks: ["checks.go.linter", "checks.go.tests"],
+    review: ["review.loop"],
+    final: ["checks.go.linter", "checks.go.tests"],
+};
+const ITERATIVE_BLOCKS = new Set([
+    "review.design-loop",
+    "checks.go.linter",
+    "checks.go.tests",
+    "review.loop",
+]);
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function formatConfigError(configName, configPath, issue) {
+    const location = configPath ? ` at ${configPath}` : "";
+    return new TaskRunnerError(`Auto flow config '${configName}'${location}: ${issue}`);
+}
+function assertConfig(condition, configName, configPath, issue) {
+    if (!condition) {
+        throw formatConfigError(configName, configPath, issue);
+    }
+}
+function validateConfigNameForPath(name) {
+    if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+        throw new TaskRunnerError(`Auto flow config name '${name}' is invalid. Use only letters, numbers, dots, underscores, and dashes.`);
+    }
+}
+function assertOnlyKeys(value, allowed, configName, configPath, objectPath) {
+    const allowedSet = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        assertConfig(allowedSet.has(key), configName, configPath, `unsupported key '${key}' at ${objectPath}`);
+    }
+}
+function isPreset(value) {
+    return typeof value === "string" && AUTO_FLOW_PRESETS.includes(value);
+}
+function isSlotName(value) {
+    return AUTO_FLOW_SLOT_NAMES.includes(value);
+}
+function isBlockId(value) {
+    return typeof value === "string" && AUTO_FLOW_BLOCK_IDS.includes(value);
+}
+function isEnabled(value) {
+    return value === true || value === false || value === "auto";
+}
+function parameterBoundsForBlock(blockId, paramName) {
+    const definition = getBuiltInAutoFlowBlockDefinition(blockId);
+    const paramDefinition = definition?.params?.[paramName];
+    if (paramDefinition?.type === "integer") {
+        return {
+            min: paramDefinition.min,
+            max: paramDefinition.max,
+        };
+    }
+    if (paramName === "maxIterations" && ITERATIVE_BLOCKS.has(blockId)) {
+        return {
+            min: 1,
+            max: 5,
+        };
+    }
+    return null;
+}
+function validateBlock(rawBlock, slotName, index, configName, configPath) {
+    const objectPath = `slots.${slotName}.blocks[${index}]`;
+    assertConfig(isRecord(rawBlock), configName, configPath, `${objectPath} must be an object`);
+    assertOnlyKeys(rawBlock, ["id", "enabled", "maxIterations"], configName, configPath, objectPath);
+    const blockId = rawBlock["id"];
+    assertConfig(isBlockId(blockId), configName, configPath, `${objectPath}.id must be a known block id`);
+    assertConfig(SLOT_BLOCKS[slotName].includes(blockId), configName, configPath, `${objectPath}.id '${blockId}' is not supported in slot '${slotName}'`);
+    const enabled = rawBlock["enabled"];
+    assertConfig(enabled === undefined || isEnabled(enabled), configName, configPath, `${objectPath}.enabled must be true, false, or auto`);
+    const maxIterations = rawBlock["maxIterations"];
+    assertConfig(maxIterations === undefined || (Number.isInteger(maxIterations) && Number(maxIterations) > 0), configName, configPath, `${objectPath}.maxIterations must be a positive integer`);
+    assertConfig(maxIterations === undefined || ITERATIVE_BLOCKS.has(blockId), configName, configPath, `${objectPath}.maxIterations is not supported by block '${blockId}'`);
+    const maxIterationBounds = parameterBoundsForBlock(blockId, "maxIterations");
+    assertConfig(maxIterations === undefined
+        || !maxIterationBounds
+        || (Number(maxIterations) >= maxIterationBounds.min && Number(maxIterations) <= maxIterationBounds.max), configName, configPath, `${objectPath}.maxIterations for block '${blockId}' must be between ${maxIterationBounds?.min ?? 1} and ${maxIterationBounds?.max ?? 5}; received ${Number(maxIterations)}`);
+    return {
+        id: blockId,
+        ...(enabled !== undefined ? { enabled } : {}),
+        ...(maxIterations !== undefined ? { maxIterations: Number(maxIterations) } : {}),
+    };
+}
+export function validateAutoFlowConfigValue(value, requestedName, configPath) {
+    const configNameForErrors = isRecord(value) && typeof value["name"] === "string" && value["name"].trim()
+        ? value["name"].trim()
+        : requestedName;
+    assertConfig(isRecord(value), configNameForErrors, configPath, "config root must be an object");
+    assertOnlyKeys(value, ["kind", "version", "name", "basePreset", "slots"], configNameForErrors, configPath, "root");
+    assertConfig(value["kind"] === "auto-flow-config", configNameForErrors, configPath, "kind must be 'auto-flow-config'");
+    assertConfig(value["version"] === 1, configNameForErrors, configPath, "version must be 1");
+    assertConfig(typeof value["name"] === "string" && value["name"].trim().length > 0, configNameForErrors, configPath, "name must be a non-empty string");
+    const name = String(value["name"]).trim();
+    assertConfig(name === requestedName, name, configPath, `name must match requested config name '${requestedName}'`);
+    assertConfig(isPreset(value["basePreset"]), name, configPath, "basePreset must be simple or standard");
+    let slots;
+    const rawSlots = value["slots"];
+    if (rawSlots !== undefined) {
+        assertConfig(isRecord(rawSlots), name, configPath, "slots must be an object");
+        slots = {};
+        for (const [slotName, rawSlot] of Object.entries(rawSlots)) {
+            assertConfig(isSlotName(slotName), name, configPath, `unknown slot '${slotName}'`);
+            assertConfig(isRecord(rawSlot), name, configPath, `slots.${slotName} must be an object`);
+            assertOnlyKeys(rawSlot, ["blocks"], name, configPath, `slots.${slotName}`);
+            const rawBlocks = rawSlot["blocks"];
+            assertConfig(Array.isArray(rawBlocks), name, configPath, `slots.${slotName}.blocks must be an array`);
+            slots[slotName] = {
+                blocks: rawBlocks.map((block, index) => validateBlock(block, slotName, index, name, configPath)),
+            };
+        }
+    }
+    return {
+        kind: "auto-flow-config",
+        version: 1,
+        name,
+        basePreset: value["basePreset"],
+        ...(slots !== undefined ? { slots } : {}),
+    };
+}
+export function normalizeAutoFlowConfigYaml(config) {
+    return YAML.stringify(config);
+}
+export function projectAutoFlowConfigPath(name, cwd = process.cwd()) {
+    validateConfigNameForPath(name);
+    return path.join(cwd, ".agentweaver", "flow-configs", `${name}.yaml`);
+}
+export function userAutoFlowConfigPath(name) {
+    validateConfigNameForPath(name);
+    return path.join(agentweaverConfigDir(), "flow-configs", `${name}.yaml`);
+}
+export function autoFlowConfigSearchPaths(name, cwd = process.cwd()) {
+    return {
+        projectPath: projectAutoFlowConfigPath(name, cwd),
+        userPath: userAutoFlowConfigPath(name),
+    };
+}
+function configNamesInDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        return [];
+    }
+    return readdirSync(dirPath, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && /\.ya?ml$/i.test(entry.name))
+        .map((entry) => entry.name.replace(/\.ya?ml$/i, ""))
+        .filter((name) => /^[A-Za-z0-9._-]+$/.test(name));
+}
+export function listAutoFlowConfigs(cwd = process.cwd()) {
+    const projectDir = path.join(cwd, ".agentweaver", "flow-configs");
+    const userDir = path.join(agentweaverConfigDir(), "flow-configs");
+    const names = new Set([...configNamesInDir(projectDir), ...configNamesInDir(userDir)]);
+    return [...names]
+        .sort((left, right) => left.localeCompare(right))
+        .map((name) => {
+        const projectPath = projectAutoFlowConfigPath(name, cwd);
+        const userPath = userAutoFlowConfigPath(name);
+        const hasProject = existsSync(projectPath);
+        const hasUser = existsSync(userPath);
+        return {
+            name,
+            ...(hasProject ? { projectPath } : {}),
+            ...(hasUser ? { userPath } : {}),
+            selectedSource: hasProject ? "project" : "user",
+        };
+    });
+}
+export function loadAutoFlowConfigByName(name, cwd = process.cwd()) {
+    const requestedName = name.trim();
+    validateConfigNameForPath(requestedName);
+    const { projectPath, userPath } = autoFlowConfigSearchPaths(requestedName, cwd);
+    const projectExists = existsSync(projectPath);
+    const userExists = existsSync(userPath);
+    const selectedPath = projectExists ? projectPath : userExists ? userPath : null;
+    if (!selectedPath) {
+        throw new TaskRunnerError(`Auto flow config '${requestedName}' was not found. Searched ${projectPath} and ${userPath}.`);
+    }
+    const rawYaml = readFileSync(selectedPath, "utf8");
+    let parsed;
+    try {
+        parsed = YAML.parse(rawYaml);
+    }
+    catch (error) {
+        throw formatConfigError(requestedName, selectedPath, `YAML parse failed: ${error.message}`);
+    }
+    const config = validateAutoFlowConfigValue(parsed, requestedName, selectedPath);
+    return {
+        config,
+        rawYaml,
+        normalizedYaml: normalizeAutoFlowConfigYaml(config),
+        source: {
+            type: projectExists ? "project" : "user",
+            path: selectedPath,
+            ...(projectExists && userExists ? { shadowedUserPath: userPath } : {}),
+        },
+    };
+}
+function writeTextAtomic(filePath, content) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tempPath, content, "utf8");
+    renameSync(tempPath, filePath);
+}
+export function saveAutoFlowConfig(config, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const location = options.location ?? "project";
+    validateConfigNameForPath(config.name);
+    const configPath = location === "project"
+        ? projectAutoFlowConfigPath(config.name, cwd)
+        : userAutoFlowConfigPath(config.name);
+    const normalizedConfig = validateAutoFlowConfigValue(config, config.name, configPath);
+    const normalizedYaml = normalizeAutoFlowConfigYaml(normalizedConfig);
+    writeTextAtomic(configPath, normalizedYaml);
+    return {
+        config: normalizedConfig,
+        normalizedYaml,
+        source: {
+            type: location,
+            path: configPath,
+        },
+    };
+}
+export function allowedAutoFlowBlocksForSlot(slotName) {
+    return SLOT_BLOCKS[slotName];
+}
+export function validateAutoFlowBlockInsertion(slotName, blockId) {
+    if (!isSlotName(slotName)) {
+        return {
+            ok: false,
+            message: `Unknown auto-flow slot '${slotName}'.`,
+        };
+    }
+    if (!isBlockId(blockId)) {
+        return {
+            ok: false,
+            message: `Unknown auto-flow block '${blockId}'.`,
+            slotName,
+        };
+    }
+    if (!SLOT_BLOCKS[slotName].includes(blockId)) {
+        return {
+            ok: false,
+            message: `Auto-flow block '${blockId}' cannot be inserted into slot '${slotName}'. Allowed blocks: ${SLOT_BLOCKS[slotName].join(", ")}.`,
+            slotName,
+            blockId,
+        };
+    }
+    return {
+        ok: true,
+        message: `Auto-flow block '${blockId}' can be inserted into slot '${slotName}'.`,
+        slotName,
+        blockId,
+    };
+}

package/dist/pipeline/auto-flow-identity.js

@@ -0,0 +1,49 @@
+export const AUTO_FLOW_STANDARD_FLOW_ID = "auto-common";
+export const AUTO_FLOW_SIMPLE_FLOW_ID = "auto-simple";
+export const AUTO_FLOW_CONFIG_FLOW_ID_PREFIX = "auto-config:";
+const VALID_AUTO_FLOW_CONFIG_ID_RE = /^[A-Za-z0-9._-]+$/;
+export function defaultAutoFlowSelection() {
+    return { kind: "preset", preset: "standard" };
+}
+export function autoFlowIdentityForSelection(selection, resolved) {
+    if (selection.kind === "config") {
+        return {
+            flowId: `${AUTO_FLOW_CONFIG_FLOW_ID_PREFIX}${resolved.config.name}`,
+            displayLabel: `config ${resolved.config.name}`,
+            selectedCommand: resolved.document.selectedCommand,
+        };
+    }
+    return {
+        flowId: selection.preset === "simple" ? AUTO_FLOW_SIMPLE_FLOW_ID : AUTO_FLOW_STANDARD_FLOW_ID,
+        displayLabel: `${selection.preset} preset`,
+        selectedCommand: selection.preset === "simple" ? AUTO_FLOW_SIMPLE_FLOW_ID : AUTO_FLOW_STANDARD_FLOW_ID,
+    };
+}
+export function isConfigurableAutoConfigFlowId(flowId) {
+    if (!flowId.startsWith(AUTO_FLOW_CONFIG_FLOW_ID_PREFIX)) {
+        return false;
+    }
+    const configName = flowId.slice(AUTO_FLOW_CONFIG_FLOW_ID_PREFIX.length);
+    return VALID_AUTO_FLOW_CONFIG_ID_RE.test(configName);
+}
+export function isConfigurableAutoPresetFlowId(flowId) {
+    return flowId === AUTO_FLOW_STANDARD_FLOW_ID || flowId === AUTO_FLOW_SIMPLE_FLOW_ID;
+}
+export function isConfigurableAutoFlowId(flowId) {
+    return isConfigurableAutoPresetFlowId(flowId) || isConfigurableAutoConfigFlowId(flowId);
+}
+export function isRestartArchivingFlowId(flowId) {
+    return (flowId === AUTO_FLOW_STANDARD_FLOW_ID ||
+        flowId === AUTO_FLOW_SIMPLE_FLOW_ID ||
+        flowId === "auto-common-guided" ||
+        flowId === "auto-golang" ||
+        flowId === "instant-task" ||
+        isConfigurableAutoConfigFlowId(flowId));
+}
+export function isContinuableParentFlowId(flowId) {
+    return (flowId === AUTO_FLOW_STANDARD_FLOW_ID ||
+        flowId === AUTO_FLOW_SIMPLE_FLOW_ID ||
+        flowId === "auto-golang" ||
+        flowId === "instant-task" ||
+        isConfigurableAutoConfigFlowId(flowId));
+}

package/dist/pipeline/auto-flow-presets.js

@@ -0,0 +1,52 @@
+export const VIRTUAL_BUILT_IN_AUTO_FLOW_FILE_NAMES = ["auto-simple.json", "auto-common.json"];
+export const BUILT_IN_AUTO_FLOW_PRESETS = [
+    {
+        id: "simple",
+        title: "Simple auto flow",
+        fileName: "auto-simple.json",
+        kind: "auto-flow",
+        version: 1,
+        description: "End-to-end resumable pipeline without language-specific checks. Runs: task source collection -> task source normalization -> plan -> implement -> review loop.",
+        blocks: [
+            { blockId: "source.jira", slot: "source", locked: true, defaultEnabled: true },
+            { blockId: "normalize.task-source", slot: "normalize", locked: true, defaultEnabled: true },
+            { blockId: "planning.plan", slot: "planning", locked: true, defaultEnabled: true },
+            { blockId: "implementation.default", slot: "implementation", locked: true, defaultEnabled: true },
+            { blockId: "review.loop", slot: "review", defaultEnabled: true },
+        ],
+    },
+    {
+        id: "standard",
+        title: "Standard auto flow",
+        fileName: "auto-common.json",
+        kind: "auto-flow",
+        version: 1,
+        description: "End-to-end resumable pipeline without language-specific checks. Runs: task source collection -> task source normalization -> plan -> design-review loop -> implement -> review loop.",
+        blocks: [
+            { blockId: "source.jira", slot: "source", locked: true, defaultEnabled: true },
+            { blockId: "normalize.task-source", slot: "normalize", locked: true, defaultEnabled: true },
+            { blockId: "planning.plan", slot: "planning", locked: true, defaultEnabled: true },
+            { blockId: "review.design-loop", slot: "designReview", defaultEnabled: true },
+            { blockId: "implementation.default", slot: "implementation", locked: true, defaultEnabled: true },
+            { blockId: "review.loop", slot: "review", defaultEnabled: true },
+        ],
+    },
+];
+const presetById = new Map(BUILT_IN_AUTO_FLOW_PRESETS.map((preset) => [preset.id, preset]));
+const presetByFileName = new Map(BUILT_IN_AUTO_FLOW_PRESETS.map((preset) => [preset.fileName, preset]));
+export function listBuiltInAutoFlowPresets() {
+    return [...BUILT_IN_AUTO_FLOW_PRESETS];
+}
+export function getBuiltInAutoFlowPreset(presetId) {
+    const preset = presetById.get(presetId);
+    if (!preset) {
+        throw new Error(`Unknown built-in auto-flow preset '${presetId}'.`);
+    }
+    return preset;
+}
+export function getBuiltInAutoFlowPresetByFileName(fileName) {
+    return presetByFileName.get(fileName) ?? null;
+}
+export function isVirtualBuiltInAutoFlowFileName(fileName) {
+    return VIRTUAL_BUILT_IN_AUTO_FLOW_FILE_NAMES.includes(fileName);
+}