agentweaver 0.1.16 → 0.1.18

package/dist/pipeline/nodes/flow-run-node.js

@@ -1,4 +1,5 @@
 import { printInfo } from "../../tui.js";
+import { nextArtifactIteration } from "../../artifacts.js";
 import { resolveDesignReviewInputContract } from "../../runtime/design-review-input-contract.js";
 import { resolvePlanReviseInputContract } from "../../runtime/plan-revise-input-contract.js";
 import { inspectReviewInputContract } from "../../runtime/review-input-contract.js";
@@ -20,6 +21,195 @@ function withArtifactLineageRefPaths(params, lineageRefs) {
         [ARTIFACT_LINEAGE_REF_PATHS_PARAM]: merged,
     };
 }
+function parsePositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+export function resolveNestedFlowParams(flowKind, flowParams) {
+    let resolvedFlowParams = withCanonicalReviewLoopParams(flowKind, flowParams);
+    if (flowKind === "design-review-flow") {
+        const taskKey = String(flowParams["taskKey"] ?? "");
+        if (!taskKey) {
+            return resolvedFlowParams;
+        }
+        const contract = resolveDesignReviewInputContract(taskKey);
+        const iteration = parsePositiveInteger(flowParams["iteration"]) ?? nextArtifactIteration(taskKey, "design-review");
+        return withArtifactLineageRefPaths({
+            ...flowParams,
+            iteration,
+            planningIteration: contract.planningIteration,
+            designFile: contract.designFile,
+            designJsonFile: contract.designJsonFile,
+            planFile: contract.planFile,
+            planJsonFile: contract.planJsonFile,
+            hasQaArtifacts: contract.hasQaArtifacts,
+            qaFilePath: contract.qaFilePath,
+            qaJsonFilePath: contract.qaJsonFilePath,
+            qaFile: contract.qaFile,
+            qaJsonFile: contract.qaJsonFile,
+            hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
+            taskContextJsonFilePath: contract.taskContextJsonFilePath,
+            taskContextJsonFile: contract.taskContextJsonFile,
+            hasJiraTaskFile: contract.hasJiraTaskFile,
+            jiraTaskFilePath: contract.jiraTaskFilePath,
+            jiraTaskFile: contract.jiraTaskFile,
+            hasJiraAttachmentsManifestFile: contract.hasJiraAttachmentsManifestFile,
+            jiraAttachmentsManifestFilePath: contract.jiraAttachmentsManifestFilePath,
+            jiraAttachmentsManifestFile: contract.jiraAttachmentsManifestFile,
+            hasJiraAttachmentsContextFile: contract.hasJiraAttachmentsContextFile,
+            jiraAttachmentsContextFilePath: contract.jiraAttachmentsContextFilePath,
+            jiraAttachmentsContextFile: contract.jiraAttachmentsContextFile,
+            hasPlanningAnswersJsonFile: contract.hasPlanningAnswersJsonFile,
+            planningAnswersJsonFilePath: contract.planningAnswersJsonFilePath,
+            planningAnswersJsonFile: contract.planningAnswersJsonFile,
+            hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
+            taskInputJsonFilePath: contract.taskInputJsonFilePath,
+            taskInputJsonFile: contract.taskInputJsonFile,
+            projectGuidanceFile: flowParams["projectGuidanceFile"] ?? "not provided",
+            projectGuidanceJsonFile: flowParams["projectGuidanceJsonFile"] ?? "not provided",
+        }, {
+            "params.designFile": contract.designFile,
+            "params.designJsonFile": contract.designJsonFile,
+            "params.planFile": contract.planFile,
+            "params.planJsonFile": contract.planJsonFile,
+            ...(contract.qaFilePath ? { "params.qaFile": contract.qaFilePath } : {}),
+            ...(contract.qaJsonFilePath ? { "params.qaJsonFile": contract.qaJsonFilePath } : {}),
+            ...(contract.taskContextJsonFilePath
+                ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
+                : {}),
+            ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
+            ...(contract.jiraAttachmentsManifestFilePath
+                ? { "params.jiraAttachmentsManifestFile": contract.jiraAttachmentsManifestFilePath }
+                : {}),
+            ...(contract.jiraAttachmentsContextFilePath
+                ? { "params.jiraAttachmentsContextFile": contract.jiraAttachmentsContextFilePath }
+                : {}),
+            ...(contract.planningAnswersJsonFilePath
+                ? { "params.planningAnswersJsonFile": contract.planningAnswersJsonFilePath }
+                : {}),
+            ...(contract.taskInputJsonFilePath
+                ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
+                : {}),
+        });
+    }
+    if (flowKind === "plan-revise-flow") {
+        const taskKey = String(flowParams["taskKey"] ?? "");
+        if (!taskKey) {
+            return resolvedFlowParams;
+        }
+        const contract = resolvePlanReviseInputContract(taskKey);
+        return withArtifactLineageRefPaths({
+            ...flowParams,
+            reviewIteration: contract.reviewIteration,
+            reviewFile: contract.reviewFile,
+            reviewJsonFile: contract.reviewJsonFile,
+            sourcePlanningIteration: contract.sourcePlanningIteration,
+            outputIteration: contract.outputIteration,
+            designFile: contract.designFile,
+            designJsonFile: contract.designJsonFile,
+            planFile: contract.planFile,
+            planJsonFile: contract.planJsonFile,
+            hasQaArtifacts: contract.hasQaArtifacts,
+            qaFilePath: contract.qaFilePath,
+            qaJsonFilePath: contract.qaJsonFilePath,
+            qaFile: contract.qaFile,
+            qaJsonFile: contract.qaJsonFile,
+            revisedDesignFile: contract.revisedDesignFile,
+            revisedDesignJsonFile: contract.revisedDesignJsonFile,
+            revisedPlanFile: contract.revisedPlanFile,
+            revisedPlanJsonFile: contract.revisedPlanJsonFile,
+            revisedQaFile: contract.revisedQaFile,
+            revisedQaJsonFile: contract.revisedQaJsonFile,
+            hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
+            taskContextJsonFilePath: contract.taskContextJsonFilePath,
+            taskContextJsonFile: contract.taskContextJsonFile,
+            hasJiraTaskFile: contract.hasJiraTaskFile,
+            jiraTaskFilePath: contract.jiraTaskFilePath,
+            jiraTaskFile: contract.jiraTaskFile,
+            hasJiraAttachmentsManifestFile: contract.hasJiraAttachmentsManifestFile,
+            jiraAttachmentsManifestFilePath: contract.jiraAttachmentsManifestFilePath,
+            jiraAttachmentsManifestFile: contract.jiraAttachmentsManifestFile,
+            hasJiraAttachmentsContextFile: contract.hasJiraAttachmentsContextFile,
+            jiraAttachmentsContextFilePath: contract.jiraAttachmentsContextFilePath,
+            jiraAttachmentsContextFile: contract.jiraAttachmentsContextFile,
+            hasPlanningAnswersJsonFile: contract.hasPlanningAnswersJsonFile,
+            planningAnswersJsonFilePath: contract.planningAnswersJsonFilePath,
+            planningAnswersJsonFile: contract.planningAnswersJsonFile,
+            hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
+            taskInputJsonFilePath: contract.taskInputJsonFilePath,
+            taskInputJsonFile: contract.taskInputJsonFile,
+            projectGuidanceFile: flowParams["projectGuidanceFile"] ?? "not provided",
+            projectGuidanceJsonFile: flowParams["projectGuidanceJsonFile"] ?? "not provided",
+        }, {
+            "params.reviewFile": contract.reviewFile,
+            "params.reviewJsonFile": contract.reviewJsonFile,
+            "params.designFile": contract.designFile,
+            "params.designJsonFile": contract.designJsonFile,
+            "params.planFile": contract.planFile,
+            "params.planJsonFile": contract.planJsonFile,
+            ...(contract.qaFilePath ? { "params.qaFile": contract.qaFilePath } : {}),
+            ...(contract.qaJsonFilePath ? { "params.qaJsonFile": contract.qaJsonFilePath } : {}),
+            ...(contract.taskContextJsonFilePath
+                ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
+                : {}),
+            ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
+            ...(contract.jiraAttachmentsManifestFilePath
+                ? { "params.jiraAttachmentsManifestFile": contract.jiraAttachmentsManifestFilePath }
+                : {}),
+            ...(contract.jiraAttachmentsContextFilePath
+                ? { "params.jiraAttachmentsContextFile": contract.jiraAttachmentsContextFilePath }
+                : {}),
+            ...(contract.planningAnswersJsonFilePath
+                ? { "params.planningAnswersJsonFile": contract.planningAnswersJsonFilePath }
+                : {}),
+            ...(contract.taskInputJsonFilePath
+                ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
+                : {}),
+        });
+    }
+    if (flowKind === "review-flow") {
+        const taskKey = String(flowParams["taskKey"] ?? "");
+        if (!taskKey) {
+            return resolvedFlowParams;
+        }
+        const inspection = inspectReviewInputContract(taskKey);
+        if (inspection.status !== "ready") {
+            return resolvedFlowParams;
+        }
+        const { contract } = inspection;
+        return withArtifactLineageRefPaths({
+            ...flowParams,
+            planningIteration: contract.planningIteration,
+            designFile: contract.designFile,
+            designJsonFile: contract.designJsonFile,
+            planFile: contract.planFile,
+            planJsonFile: contract.planJsonFile,
+            hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
+            taskContextJsonFilePath: contract.taskContextJsonFilePath,
+            taskContextJsonFile: contract.taskContextJsonFile,
+            hasJiraTaskFile: contract.hasJiraTaskFile,
+            jiraTaskFilePath: contract.jiraTaskFilePath,
+            jiraTaskFile: contract.jiraTaskFile,
+            hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
+            taskInputJsonFilePath: contract.taskInputJsonFilePath,
+            taskInputJsonFile: contract.taskInputJsonFile,
+            projectGuidanceFile: flowParams["projectGuidanceFile"] ?? "not provided",
+            projectGuidanceJsonFile: flowParams["projectGuidanceJsonFile"] ?? "not provided",
+        }, {
+            "params.designFile": contract.designFile,
+            "params.designJsonFile": contract.designJsonFile,
+            "params.planFile": contract.planFile,
+            "params.planJsonFile": contract.planJsonFile,
+            ...(contract.taskContextJsonFilePath
+                ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
+                : {}),
+            ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
+            ...(contract.taskInputJsonFilePath
+                ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
+                : {}),
+        });
+    }
+    return resolvedFlowParams;
+}
 export const flowRunNode = {
     kind: "flow-run",
     version: 1,
@@ -31,179 +221,16 @@ export const flowRunNode = {
         if (labelText) {
             printInfo(String(labelText));
         }
-        const flow = loadNamedDeclarativeFlow(fileName, context.cwd);
-        let resolvedFlowParams = withCanonicalReviewLoopParams(flow.kind, flowParams);
-        if (flow.kind === "design-review-flow") {
-            const taskKey = String(flowParams["taskKey"] ?? "");
-            if (taskKey) {
-                const contract = resolveDesignReviewInputContract(taskKey);
-                resolvedFlowParams = withArtifactLineageRefPaths({
-                    ...flowParams,
-                    iteration: contract.planningIteration,
-                    planningIteration: contract.planningIteration,
-                    designFile: contract.designFile,
-                    designJsonFile: contract.designJsonFile,
-                    planFile: contract.planFile,
-                    planJsonFile: contract.planJsonFile,
-                    hasQaArtifacts: contract.hasQaArtifacts,
-                    qaFilePath: contract.qaFilePath,
-                    qaJsonFilePath: contract.qaJsonFilePath,
-                    qaFile: contract.qaFile,
-                    qaJsonFile: contract.qaJsonFile,
-                    hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
-                    taskContextJsonFilePath: contract.taskContextJsonFilePath,
-                    taskContextJsonFile: contract.taskContextJsonFile,
-                    hasJiraTaskFile: contract.hasJiraTaskFile,
-                    jiraTaskFilePath: contract.jiraTaskFilePath,
-                    jiraTaskFile: contract.jiraTaskFile,
-                    hasJiraAttachmentsManifestFile: contract.hasJiraAttachmentsManifestFile,
-                    jiraAttachmentsManifestFilePath: contract.jiraAttachmentsManifestFilePath,
-                    jiraAttachmentsManifestFile: contract.jiraAttachmentsManifestFile,
-                    hasJiraAttachmentsContextFile: contract.hasJiraAttachmentsContextFile,
-                    jiraAttachmentsContextFilePath: contract.jiraAttachmentsContextFilePath,
-                    jiraAttachmentsContextFile: contract.jiraAttachmentsContextFile,
-                    hasPlanningAnswersJsonFile: contract.hasPlanningAnswersJsonFile,
-                    planningAnswersJsonFilePath: contract.planningAnswersJsonFilePath,
-                    planningAnswersJsonFile: contract.planningAnswersJsonFile,
-                    hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
-                    taskInputJsonFilePath: contract.taskInputJsonFilePath,
-                    taskInputJsonFile: contract.taskInputJsonFile,
-                }, {
-                    "params.designFile": contract.designFile,
-                    "params.designJsonFile": contract.designJsonFile,
-                    "params.planFile": contract.planFile,
-                    "params.planJsonFile": contract.planJsonFile,
-                    ...(contract.qaFilePath ? { "params.qaFile": contract.qaFilePath } : {}),
-                    ...(contract.qaJsonFilePath ? { "params.qaJsonFile": contract.qaJsonFilePath } : {}),
-                    ...(contract.taskContextJsonFilePath
-                        ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
-                        : {}),
-                    ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
-                    ...(contract.jiraAttachmentsManifestFilePath
-                        ? { "params.jiraAttachmentsManifestFile": contract.jiraAttachmentsManifestFilePath }
-                        : {}),
-                    ...(contract.jiraAttachmentsContextFilePath
-                        ? { "params.jiraAttachmentsContextFile": contract.jiraAttachmentsContextFilePath }
-                        : {}),
-                    ...(contract.planningAnswersJsonFilePath
-                        ? { "params.planningAnswersJsonFile": contract.planningAnswersJsonFilePath }
-                        : {}),
-                    ...(contract.taskInputJsonFilePath
-                        ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
-                        : {}),
-                });
-            }
-        }
-        else if (flow.kind === "plan-revise-flow") {
-            const taskKey = String(flowParams["taskKey"] ?? "");
-            if (taskKey) {
-                const contract = resolvePlanReviseInputContract(taskKey);
-                resolvedFlowParams = withArtifactLineageRefPaths({
-                    ...flowParams,
-                    reviewIteration: contract.reviewIteration,
-                    reviewFile: contract.reviewFile,
-                    reviewJsonFile: contract.reviewJsonFile,
-                    sourcePlanningIteration: contract.sourcePlanningIteration,
-                    outputIteration: contract.outputIteration,
-                    designFile: contract.designFile,
-                    designJsonFile: contract.designJsonFile,
-                    planFile: contract.planFile,
-                    planJsonFile: contract.planJsonFile,
-                    hasQaArtifacts: contract.hasQaArtifacts,
-                    qaFilePath: contract.qaFilePath,
-                    qaJsonFilePath: contract.qaJsonFilePath,
-                    qaFile: contract.qaFile,
-                    qaJsonFile: contract.qaJsonFile,
-                    revisedDesignFile: contract.revisedDesignFile,
-                    revisedDesignJsonFile: contract.revisedDesignJsonFile,
-                    revisedPlanFile: contract.revisedPlanFile,
-                    revisedPlanJsonFile: contract.revisedPlanJsonFile,
-                    revisedQaFile: contract.revisedQaFile,
-                    revisedQaJsonFile: contract.revisedQaJsonFile,
-                    hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
-                    taskContextJsonFilePath: contract.taskContextJsonFilePath,
-                    taskContextJsonFile: contract.taskContextJsonFile,
-                    hasJiraTaskFile: contract.hasJiraTaskFile,
-                    jiraTaskFilePath: contract.jiraTaskFilePath,
-                    jiraTaskFile: contract.jiraTaskFile,
-                    hasJiraAttachmentsManifestFile: contract.hasJiraAttachmentsManifestFile,
-                    jiraAttachmentsManifestFilePath: contract.jiraAttachmentsManifestFilePath,
-                    jiraAttachmentsManifestFile: contract.jiraAttachmentsManifestFile,
-                    hasJiraAttachmentsContextFile: contract.hasJiraAttachmentsContextFile,
-                    jiraAttachmentsContextFilePath: contract.jiraAttachmentsContextFilePath,
-                    jiraAttachmentsContextFile: contract.jiraAttachmentsContextFile,
-                    hasPlanningAnswersJsonFile: contract.hasPlanningAnswersJsonFile,
-                    planningAnswersJsonFilePath: contract.planningAnswersJsonFilePath,
-                    planningAnswersJsonFile: contract.planningAnswersJsonFile,
-                    hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
-                    taskInputJsonFilePath: contract.taskInputJsonFilePath,
-                    taskInputJsonFile: contract.taskInputJsonFile,
-                }, {
-                    "params.reviewFile": contract.reviewFile,
-                    "params.reviewJsonFile": contract.reviewJsonFile,
-                    "params.designFile": contract.designFile,
-                    "params.designJsonFile": contract.designJsonFile,
-                    "params.planFile": contract.planFile,
-                    "params.planJsonFile": contract.planJsonFile,
-                    ...(contract.qaFilePath ? { "params.qaFile": contract.qaFilePath } : {}),
-                    ...(contract.qaJsonFilePath ? { "params.qaJsonFile": contract.qaJsonFilePath } : {}),
-                    ...(contract.taskContextJsonFilePath
-                        ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
-                        : {}),
-                    ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
-                    ...(contract.jiraAttachmentsManifestFilePath
-                        ? { "params.jiraAttachmentsManifestFile": contract.jiraAttachmentsManifestFilePath }
-                        : {}),
-                    ...(contract.jiraAttachmentsContextFilePath
-                        ? { "params.jiraAttachmentsContextFile": contract.jiraAttachmentsContextFilePath }
-                        : {}),
-                    ...(contract.planningAnswersJsonFilePath
-                        ? { "params.planningAnswersJsonFile": contract.planningAnswersJsonFilePath }
-                        : {}),
-                    ...(contract.taskInputJsonFilePath
-                        ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
-                        : {}),
-                });
-            }
-        }
-        else if (flow.kind === "review-flow") {
-            const taskKey = String(flowParams["taskKey"] ?? "");
-            if (taskKey) {
-                const inspection = inspectReviewInputContract(taskKey);
-                if (inspection.status === "ready") {
-                    const { contract } = inspection;
-                    resolvedFlowParams = withArtifactLineageRefPaths({
-                        ...flowParams,
-                        planningIteration: contract.planningIteration,
-                        designFile: contract.designFile,
-                        designJsonFile: contract.designJsonFile,
-                        planFile: contract.planFile,
-                        planJsonFile: contract.planJsonFile,
-                        hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
-                        taskContextJsonFilePath: contract.taskContextJsonFilePath,
-                        taskContextJsonFile: contract.taskContextJsonFile,
-                        hasJiraTaskFile: contract.hasJiraTaskFile,
-                        jiraTaskFilePath: contract.jiraTaskFilePath,
-                        jiraTaskFile: contract.jiraTaskFile,
-                        hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
-                        taskInputJsonFilePath: contract.taskInputJsonFilePath,
-                        taskInputJsonFile: contract.taskInputJsonFile,
-                    }, {
-                        "params.designFile": contract.designFile,
-                        "params.designJsonFile": contract.designJsonFile,
-                        "params.planFile": contract.planFile,
-                        "params.planJsonFile": contract.planJsonFile,
-                        ...(contract.taskContextJsonFilePath
-                            ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
-                            : {}),
-                        ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
-                        ...(contract.taskInputJsonFilePath
-                            ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
-                            : {}),
-                    });
-                }
-            }
-        }
+        const flow = await loadNamedDeclarativeFlow(fileName, context.cwd, {
+            ...(context.registryContext ? { registryContext: context.registryContext } : {}),
+        });
+        const resolvedFlowParams = resolveNestedFlowParams(flow.kind, {
+            projectGuidanceFile: "not provided",
+            projectGuidanceJsonFile: "not provided",
+            repairProjectGuidanceFile: "not provided",
+            repairProjectGuidanceJsonFile: "not provided",
+            ...flowParams,
+        });
         const resumeValue = isFlowRunResumeEnvelope(context.resumeStepValue)
             && context.resumeStepValue.flowKind === flow.kind
             && context.resumeStepValue.flowVersion === flow.version

package/dist/pipeline/nodes/llm-prompt-node.js

@@ -26,46 +26,28 @@ export const llmPromptNode = {
         const model = params.routingGroup
             ? routedProfile?.model ?? params.model ?? fallbackProfile?.model
             : params.model ?? fallbackProfile?.model;
-        if (!executor || !isLlmExecutorId(executor)) {
+        if (!executor || !isLlmExecutorId(executor, context.executors)) {
             throw new TaskRunnerError(`Unsupported llm executor '${String(executor ?? params.executor ?? "undefined")}'.`);
         }
-        if (model && !isAllowedModelForExecutor(executor, model)) {
+        if (model && !isAllowedModelForExecutor(executor, model, context.executors)) {
             throw new TaskRunnerError(`Model '${model}' is not allowed for executor '${executor}'.`);
         }
         printInfo(params.labelText);
         printPrompt(`LLM:${executor}`, params.prompt);
         const executorContext = toExecutorContext(context);
-        if (executor === "codex") {
-            const executor = context.executors.get("codex");
-            const value = await executor.execute(executorContext, {
-                prompt: params.prompt,
-                ...(model ? { model } : {}),
-                env: { ...context.env },
-            }, executor.defaultConfig);
-            return {
-                value: {
-                    ...value,
-                    executor: "codex",
-                },
-                outputs: outputsForArtifacts(params.requiredArtifacts),
-            };
-        }
-        if (executor === "opencode") {
-            const executor = context.executors.get("opencode");
-            const value = await executor.execute(executorContext, {
-                prompt: params.prompt,
-                ...(model ? { model } : {}),
-                env: { ...context.env },
-            }, executor.defaultConfig);
-            return {
-                value: {
-                    ...value,
-                    executor: "opencode",
-                },
-                outputs: outputsForArtifacts(params.requiredArtifacts),
-            };
-        }
-        throw new TaskRunnerError(`Unsupported llm executor '${executor}'.`);
+        const resolvedExecutor = context.executors.get(executor);
+        const value = await resolvedExecutor.execute(executorContext, {
+            prompt: params.prompt,
+            ...(model ? { model } : {}),
+            env: { ...context.env },
+        }, resolvedExecutor.defaultConfig);
+        return {
+            value: {
+                ...value,
+                executor,
+            },
+            outputs: outputsForArtifacts(params.requiredArtifacts),
+        };
     },
     checks(_context, params) {
         if (!params.requiredArtifacts || params.requiredArtifacts.length === 0) {

package/dist/pipeline/nodes/playbook-ensure-node.js

@@ -0,0 +1,115 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
+import { loadProjectPlaybook, PLAYBOOK_DIR, PLAYBOOK_MANIFEST } from "../../runtime/playbook.js";
+import { validateStructuredArtifactValue } from "../../structured-artifacts.js";
+function readWriteStatus(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        return typeof parsed.status === "string" ? parsed.status : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeResult(scopeKey, filePath, result) {
+    const artifact = {
+        status: result.status,
+        message: result.message,
+        written_files: result.written_files,
+        skipped_files: result.skipped_files,
+        existing_playbook_path: result.existing_playbook_path,
+        intended_files: result.intended_files,
+        blocked_paths: result.blocked_paths,
+    };
+    validateStructuredArtifactValue(artifact, "playbook-write-result/v1", filePath);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
+    return [
+        {
+            kind: "artifact",
+            path: filePath,
+            required: true,
+            manifest: {
+                publish: true,
+                logicalKey: buildLogicalKeyForPayload(scopeKey, filePath),
+                payloadFamily: "structured-json",
+                schemaId: "playbook-write-result/v1",
+                schemaVersion: 1,
+            },
+        },
+    ];
+}
+export const playbookEnsureNode = {
+    kind: "playbook-ensure",
+    version: 1,
+    async run(context, params) {
+        const playbookRoot = path.join(context.cwd, PLAYBOOK_DIR);
+        const manifestPath = path.join(playbookRoot, PLAYBOOK_MANIFEST);
+        const intendedFiles = [manifestPath];
+        const priorStatus = params.verifyAfterInit ? readWriteStatus(params.writeResultJsonFile) : null;
+        if (!existsSync(manifestPath)) {
+            if (params.verifyAfterInit && priorStatus === "dry_run_written") {
+                const result = {
+                    status: "dry_run_written",
+                    message: "Dry-run playbook generation was accepted; manifest.yaml was not written in dry-run mode.",
+                    written_files: [],
+                    skipped_files: [],
+                    existing_playbook_path: "",
+                    intended_files: intendedFiles,
+                    blocked_paths: [],
+                    shouldRunPlaybookInit: false,
+                    manifestPath,
+                };
+                return { value: result, outputs: writeResult(context.issueKey, params.writeResultJsonFile, result) };
+            }
+            const accepted = params.acceptPlaybookDraft === true;
+            const result = {
+                status: accepted ? "missing_playbook" : "blocked",
+                message: accepted
+                    ? `Playbook manifest is missing: ${manifestPath}. Running playbook-init because acceptPlaybookDraft is true.`
+                    : `Playbook manifest is missing: ${manifestPath}. Run 'agentweaver playbook-init --accept-playbook-draft' first, or rerun 'agentweaver auto-common-guided --accept-playbook-draft <jira>' to explicitly accept generated playbook content before planning.`,
+                written_files: [],
+                skipped_files: [],
+                existing_playbook_path: "",
+                intended_files: intendedFiles,
+                blocked_paths: accepted ? [] : [manifestPath],
+                shouldRunPlaybookInit: accepted,
+                manifestPath,
+            };
+            return { value: result, outputs: writeResult(context.issueKey, params.writeResultJsonFile, result) };
+        }
+        try {
+            loadProjectPlaybook(context.cwd);
+        }
+        catch (error) {
+            const result = {
+                status: "invalid_manifest",
+                message: `Invalid project playbook ${manifestPath}: ${error.message}`,
+                written_files: [],
+                skipped_files: [],
+                existing_playbook_path: "",
+                intended_files: intendedFiles,
+                blocked_paths: [manifestPath],
+                shouldRunPlaybookInit: false,
+                manifestPath,
+            };
+            return { value: result, outputs: writeResult(context.issueKey, params.writeResultJsonFile, result) };
+        }
+        const result = {
+            status: "skipped_valid_existing",
+            message: `Valid project playbook manifest exists: ${manifestPath}.`,
+            written_files: [],
+            skipped_files: [manifestPath],
+            existing_playbook_path: manifestPath,
+            intended_files: intendedFiles,
+            blocked_paths: [],
+            shouldRunPlaybookInit: false,
+            manifestPath,
+        };
+        return { value: result, outputs: writeResult(context.issueKey, params.writeResultJsonFile, result) };
+    },
+};

package/dist/pipeline/nodes/playbook-inventory-node.js

@@ -0,0 +1,51 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
+import { validateStructuredArtifactValue } from "../../structured-artifacts.js";
+import { collectRepoInventory, renderRepoInventoryMarkdown } from "../../playbook/repo-inventory.js";
+export const playbookInventoryNode = {
+    kind: "playbook-inventory",
+    version: 1,
+    async run(context, params) {
+        const inventory = collectRepoInventory(context.cwd);
+        validateStructuredArtifactValue(inventory, "repo-inventory/v1", params.outputJsonFile);
+        mkdirSync(path.dirname(params.outputJsonFile), { recursive: true });
+        mkdirSync(path.dirname(params.outputFile), { recursive: true });
+        writeFileSync(params.outputJsonFile, `${JSON.stringify(inventory, null, 2)}\n`, "utf8");
+        writeFileSync(params.outputFile, renderRepoInventoryMarkdown(inventory), "utf8");
+        return {
+            value: {
+                summary: inventory.summary,
+                outputJsonFile: params.outputJsonFile,
+                outputFile: params.outputFile,
+                evidenceCount: inventory.evidence.length,
+            },
+            outputs: [
+                {
+                    kind: "artifact",
+                    path: params.outputJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputJsonFile),
+                        payloadFamily: "structured-json",
+                        schemaId: "repo-inventory/v1",
+                        schemaVersion: 1,
+                    },
+                },
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                        payloadFamily: "markdown",
+                        schemaId: "markdown/v1",
+                        schemaVersion: 1,
+                    },
+                },
+            ],
+        };
+    },
+};