agentweaver 0.1.15 → 0.1.17

package/dist/pipeline/node-runner.js

@@ -1,11 +1,12 @@
 import { setCurrentNode } from "../tui.js";
 import { runNodeChecks } from "./checks.js";
 export async function runNode(node, context, params, options = {}) {
+    const effectiveContext = options.contextOverrides ? { ...context, ...options.contextOverrides } : context;
     setCurrentNode(node.kind);
     try {
-        const result = await node.run(context, params);
+        const result = await node.run(effectiveContext, params);
         if (!options.skipChecks) {
-            const checks = node.checks?.(context, params, result) ?? [];
+            const checks = node.checks?.(effectiveContext, params, result) ?? [];
             runNodeChecks(checks);
         }
         return result;

package/dist/pipeline/nodes/build-review-fix-prompt-node.js

@@ -22,7 +22,11 @@ export const buildReviewFixPromptNode = {
             "Use the user selection below as source of truth for the current review-fix scope.",
             `Selection file: ${params.selectionFile}`,
             `apply_all: ${applyAll ? "true" : "false"}`,
-            applyAll ? "Fix all findings in the current iteration." : `Fix only selected findings:\n- ${selectedFindings.join("\n- ")}`,
+            applyAll
+                ? "Fix all findings in the current iteration."
+                : selectedFindings.length > 0
+                    ? `Fix only selected findings:\n- ${selectedFindings.join("\n- ")}`
+                    : "No findings were selected for this review-fix iteration. Do not modify code; report the no-op outcome after validation.",
         ].join("\n\n");
         return {
             value: {

package/dist/pipeline/nodes/clear-ready-to-merge-node.js

@@ -0,0 +1,11 @@
+import { clearReadyToMergeFile } from "../../runtime/ready-to-merge.js";
+export const clearReadyToMergeNode = {
+    kind: "clear-ready-to-merge",
+    version: 1,
+    async run(_context, params) {
+        const cleared = clearReadyToMergeFile(params.taskKey);
+        return {
+            value: { cleared },
+        };
+    },
+};

package/dist/pipeline/nodes/commit-message-form-node.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { TaskRunnerError } from "../../errors.js";
 import { validateUserInputValues } from "../../user-input.js";
 function parseCommitMessage(content) {
@@ -72,6 +73,13 @@ export const commitMessageFormNode = {
                     kind: "artifact",
                     path: params.outputFile,
                     required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                        payloadFamily: "structured-json",
+                        schemaId: "user-input/v1",
+                        schemaVersion: 1,
+                    },
                 },
             ],
         };

package/dist/pipeline/nodes/design-review-verdict-node.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from "node:fs";
+import { TaskRunnerError } from "../../errors.js";
+import { validateStructuredArtifacts } from "../../structured-artifacts.js";
+import { designReviewJsonFile, latestArtifactIteration } from "../../artifacts.js";
+function readVerdictFile(path) {
+    if (!existsSync(path)) {
+        throw new TaskRunnerError(`Design review verdict file not found: ${path}`);
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new TaskRunnerError(`Failed to parse design review verdict JSON: ${path}`);
+    }
+}
+export const designReviewVerdictNode = {
+    kind: "design-review-verdict",
+    version: 1,
+    async run(_context, params) {
+        const iteration = params.iteration ?? latestArtifactIteration(params.taskKey, "design-review", "json") ?? 1;
+        const jsonPath = designReviewJsonFile(params.taskKey, iteration);
+        validateStructuredArtifacts([{ path: jsonPath, schemaId: "design-review/v1" }], "Design review verdict is invalid or missing.");
+        const verdict = readVerdictFile(jsonPath);
+        const status = (verdict?.status ?? "needs_revision");
+        const canProceed = status === "approved" || status === "approved_with_warnings";
+        const needsRevision = status === "needs_revision";
+        return {
+            value: {
+                status,
+                canProceed,
+                needsRevision,
+                verdict: verdict?.summary ?? `Design review status: ${status}`,
+            },
+        };
+    },
+};

package/dist/pipeline/nodes/ensure-summary-json-node.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { TaskRunnerError } from "../../errors.js";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 function toSummaryText(markdown) {
     return markdown
         .replace(/\r\n/g, "\n")
@@ -27,7 +28,7 @@ function hasValidSummaryArtifact(outputFile) {
 export const ensureSummaryJsonNode = {
     kind: "ensure-summary-json",
     version: 1,
-    async run(_context, params) {
+    async run(context, params) {
         if (hasValidSummaryArtifact(params.outputFile)) {
             return {
                 value: {
@@ -53,7 +54,17 @@ export const ensureSummaryJsonNode = {
                 created: !repaired,
                 repaired,
             },
-            outputs: [{ kind: "artifact", path: params.outputFile, required: true }],
+            outputs: [
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                    },
+                },
+            ],
         };
     },
 };

package/dist/pipeline/nodes/fetch-gitlab-diff-node.js

@@ -1,3 +1,4 @@
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { toExecutorContext } from "../types.js";
 export const fetchGitLabDiffNode = {
     kind: "fetch-gitlab-diff",
@@ -12,8 +13,24 @@ export const fetchGitLabDiffNode = {
         return {
             value,
             outputs: [
-                { kind: "artifact", path: params.outputFile, required: true },
-                { kind: "artifact", path: params.outputJsonFile, required: true },
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                    },
+                },
+                {
+                    kind: "artifact",
+                    path: params.outputJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputJsonFile),
+                    },
+                },
             ],
         };
     },

package/dist/pipeline/nodes/fetch-gitlab-review-node.js

@@ -1,3 +1,4 @@
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { toExecutorContext } from "../types.js";
 export const fetchGitLabReviewNode = {
     kind: "fetch-gitlab-review",
@@ -12,8 +13,24 @@ export const fetchGitLabReviewNode = {
         return {
             value,
             outputs: [
-                { kind: "artifact", path: params.outputFile, required: true },
-                { kind: "artifact", path: params.outputJsonFile, required: true },
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                    },
+                },
+                {
+                    kind: "artifact",
+                    path: params.outputJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputJsonFile),
+                    },
+                },
             ],
         };
     },

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

@@ -1,6 +1,209 @@
 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";
 import { runExpandedPhase } from "../declarative-flow-runner.js";
 import { loadNamedDeclarativeFlow } from "../declarative-flows.js";
+import { isFlowRunResumeEnvelope } from "../flow-run-resume.js";
+import { withCanonicalReviewLoopParams } from "../review-iteration.js";
+import { ARTIFACT_LINEAGE_REF_PATHS_PARAM } from "../value-resolver.js";
+function withArtifactLineageRefPaths(params, lineageRefs) {
+    if (Object.keys(lineageRefs).length === 0) {
+        return params;
+    }
+    const existing = params[ARTIFACT_LINEAGE_REF_PATHS_PARAM];
+    const merged = existing && typeof existing === "object" && !Array.isArray(existing)
+        ? { ...existing, ...lineageRefs }
+        : lineageRefs;
+    return {
+        ...params,
+        [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,
+        }, {
+            "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,
+        }, {
+            "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,
+        }, {
+            "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,
@@ -12,29 +215,60 @@ export const flowRunNode = {
         if (labelText) {
             printInfo(String(labelText));
         }
-        const flow = loadNamedDeclarativeFlow(fileName, context.cwd);
-        const executionState = {
+        const flow = await loadNamedDeclarativeFlow(fileName, context.cwd, {
+            ...(context.registryContext ? { registryContext: context.registryContext } : {}),
+        });
+        const resolvedFlowParams = resolveNestedFlowParams(flow.kind, flowParams);
+        const resumeValue = isFlowRunResumeEnvelope(context.resumeStepValue)
+            && context.resumeStepValue.flowKind === flow.kind
+            && context.resumeStepValue.flowVersion === flow.version
+            ? context.resumeStepValue
+            : null;
+        const executionState = resumeValue?.executionState ?? {
             flowKind: flow.kind,
             flowVersion: flow.version,
             terminated: false,
+            terminationOutcome: "success",
             phases: [],
         };
+        const buildResumeEnvelope = (nextExecutionState) => ({
+            resumeKind: "flow-run",
+            flowKind: flow.kind,
+            flowVersion: flow.version,
+            executionState: nextExecutionState,
+            publishedArtifacts: collectPublishedArtifacts(nextExecutionState),
+        });
         for (const phase of flow.phases) {
-            await runExpandedPhase(phase, context, flowParams, flow.constants, {
+            await runExpandedPhase(phase, context, resolvedFlowParams, flow.constants, {
                 executionState,
                 flowKind: flow.kind,
                 flowVersion: flow.version,
+                onStateChange: async (nextExecutionState) => {
+                    await context.persistRunningStepValue?.(buildResumeEnvelope(nextExecutionState));
+                },
             });
             if (executionState.terminated) {
                 break;
             }
         }
         return {
-            value: {
-                flowKind: flow.kind,
-                flowVersion: flow.version,
-                executionState,
-            },
+            value: buildResumeEnvelope(executionState),
         };
     },
 };
+function collectPublishedArtifacts(executionState) {
+    const merged = [];
+    const seen = new Set();
+    for (const phase of executionState.phases) {
+        for (const step of phase.steps) {
+            for (const artifact of step.publishedArtifacts ?? []) {
+                if (seen.has(artifact.artifact_id)) {
+                    continue;
+                }
+                seen.add(artifact.artifact_id);
+                merged.push(artifact);
+            }
+        }
+    }
+    return merged;
+}

package/dist/pipeline/nodes/git-commit-form-node.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { TaskRunnerError } from "../../errors.js";
 import { validateUserInputValues } from "../../user-input.js";
 function parseCommitMessage(content) {
@@ -131,6 +132,13 @@ export const gitCommitFormNode = {
                     kind: "artifact",
                     path: params.outputFile,
                     required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                        payloadFamily: "structured-json",
+                        schemaId: "user-input/v1",
+                        schemaVersion: 1,
+                    },
                 },
             ],
         };

package/dist/pipeline/nodes/gitlab-review-artifacts-node.js

@@ -1,5 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { readFileSync } from "node:fs";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { TaskRunnerError } from "../../errors.js";
 function normalizeMarkdownLanguage(mdLang) {
     return mdLang === "en" ? "en" : "ru";
@@ -101,8 +102,24 @@ export const gitlabReviewArtifactsNode = {
                 readyToMerge: artifact.ready_to_merge,
             },
             outputs: [
-                { kind: "artifact", path: params.reviewFile, required: true },
-                { kind: "artifact", path: params.reviewJsonFile, required: true },
+                {
+                    kind: "artifact",
+                    path: params.reviewFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.reviewFile),
+                    },
+                },
+                {
+                    kind: "artifact",
+                    path: params.reviewJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.reviewJsonFile),
+                    },
+                },
             ],
         };
     },

package/dist/pipeline/nodes/jira-fetch-node.js

@@ -10,15 +10,61 @@ export const jiraFetchNode = {
             ...(params.attachmentsManifestFile ? { attachmentsManifestFile: params.attachmentsManifestFile } : {}),
             ...(params.attachmentsContextFile ? { attachmentsContextFile: params.attachmentsContextFile } : {}),
         }, executor.defaultConfig);
-        const outputs = [{ kind: "file", path: params.outputFile, required: true }];
+        const outputs = [
+            {
+                kind: "file",
+                path: params.outputFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "artifacts/jira-task.json",
+                    payloadFamily: "helper-json",
+                    schemaId: "helper-json/v1",
+                    schemaVersion: 1,
+                },
+            },
+        ];
         if (params.attachmentsManifestFile) {
-            outputs.push({ kind: "artifact", path: params.attachmentsManifestFile, required: true });
+            outputs.push({
+                kind: "artifact",
+                path: params.attachmentsManifestFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "artifacts/jira-attachments.json",
+                    payloadFamily: "helper-json",
+                    schemaId: "helper-json/v1",
+                    schemaVersion: 1,
+                },
+            });
         }
         if (params.attachmentsContextFile) {
-            outputs.push({ kind: "artifact", path: params.attachmentsContextFile, required: true });
+            outputs.push({
+                kind: "artifact",
+                path: params.attachmentsContextFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "jira-attachments-context.txt",
+                    payloadFamily: "plain-text",
+                    schemaId: "plain-text/v1",
+                    schemaVersion: 1,
+                },
+            });
         }
         if (value.enrichedFile) {
-            outputs.push({ kind: "artifact", path: value.enrichedFile, required: false });
+            outputs.push({
+                kind: "artifact",
+                path: value.enrichedFile,
+                required: false,
+                manifest: {
+                    publish: true,
+                    logicalKey: "artifacts/jira-task-enriched.json",
+                    payloadFamily: "helper-json",
+                    schemaId: "helper-json/v1",
+                    schemaVersion: 1,
+                },
+            });
         }
         return {
             value,