agentweaver 0.1.15 → 0.1.16

package/dist/runtime/plan-revise-input-contract.js

@@ -1,9 +1,17 @@
 import { existsSync } from "node:fs";
-import { designFile, designJsonFile, designReviewFile, designReviewJsonFile, jiraAttachmentsContextFile, jiraAttachmentsManifestFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, planningAnswersJsonFile, qaFile, qaJsonFile, requireArtifacts, } from "../artifacts.js";
+import { designFile, designJsonFile, designReviewFile, designReviewJsonFile, instantTaskInputJsonFile, jiraAttachmentsContextFile, jiraAttachmentsManifestFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, planningAnswersJsonFile, qaFile, qaJsonFile, taskContextJsonFile, requireArtifacts, } from "../artifacts.js";
 import { TaskRunnerError } from "../errors.js";
 import { validateStructuredArtifacts } from "../structured-artifacts.js";
+import { resolveLatestCompletedPlanningIteration } from "./planning-bundle.js";
 const OPTIONAL_INPUT_NOT_PROVIDED = "not provided";
-function resolveLatestDesignReviewIteration(taskKey) {
+function resolveLatestDesignReviewIteration(taskKey, sourcePlanningIteration) {
+    if (sourcePlanningIteration !== undefined) {
+        const candidateMd = designReviewFile(taskKey, sourcePlanningIteration);
+        const candidateJson = designReviewJsonFile(taskKey, sourcePlanningIteration);
+        if (existsSync(candidateMd) && existsSync(candidateJson)) {
+            return sourcePlanningIteration;
+        }
+    }
     const latestMd = latestArtifactIteration(taskKey, "design-review", "md");
     const latestJson = latestArtifactIteration(taskKey, "design-review", "json");
     const maxIteration = Math.max(latestMd ?? 0, latestJson ?? 0);
@@ -22,33 +30,6 @@ function resolveLatestDesignReviewIteration(taskKey) {
     requireArtifacts([fallbackMd, fallbackJson], "Plan-revise requires design-review markdown and JSON artifacts from the latest completed design-review run.");
     throw new TaskRunnerError("Unreachable plan-revise design-review artifact resolution state.");
 }
-function resolveLatestCompletedPlanningIteration(taskKey) {
-    const latestDesignMd = latestArtifactIteration(taskKey, "design", "md") ?? 0;
-    const latestDesignJson = latestArtifactIteration(taskKey, "design", "json") ?? 0;
-    const latestPlanMd = latestArtifactIteration(taskKey, "plan", "md") ?? 0;
-    const latestPlanJson = latestArtifactIteration(taskKey, "plan", "json") ?? 0;
-    const maxIteration = Math.max(latestDesignMd, latestDesignJson, latestPlanMd, latestPlanJson);
-    for (let iteration = maxIteration; iteration >= 1; iteration -= 1) {
-        const paths = [
-            designFile(taskKey, iteration),
-            designJsonFile(taskKey, iteration),
-            planFile(taskKey, iteration),
-            planJsonFile(taskKey, iteration),
-        ];
-        if (paths.every((candidate) => existsSync(candidate))) {
-            return iteration;
-        }
-    }
-    const fallbackIteration = maxIteration || 1;
-    const fallbackPaths = [
-        designFile(taskKey, fallbackIteration),
-        designJsonFile(taskKey, fallbackIteration),
-        planFile(taskKey, fallbackIteration),
-        planJsonFile(taskKey, fallbackIteration),
-    ];
-    requireArtifacts(fallbackPaths, "Plan-revise requires design and plan markdown/JSON artifacts from the latest completed planning run.");
-    throw new TaskRunnerError("Unreachable plan-revise planning artifact resolution state.");
-}
 function resolveOptionalPromptFile(filePath) {
     if (!existsSync(filePath)) {
         return {
@@ -63,6 +44,14 @@ function resolveOptionalPromptFile(filePath) {
         promptValue: filePath,
     };
 }
+function resolveOptionalValidatedStructuredFile(filePath, schemaId, message) {
+    const resolved = resolveOptionalPromptFile(filePath);
+    if (!resolved.present) {
+        return resolved;
+    }
+    validateStructuredArtifacts([{ path: filePath, schemaId }], message);
+    return resolved;
+}
 function resolveOptionalQaPair(taskKey, iteration) {
     const markdownPath = qaFile(taskKey, iteration);
     const jsonPath = qaJsonFile(taskKey, iteration);
@@ -90,12 +79,15 @@ function resolveOptionalQaPair(taskKey, iteration) {
     };
 }
 export function resolvePlanReviseInputContract(taskKey) {
-    const reviewIteration = resolveLatestDesignReviewIteration(taskKey);
+    const sourcePlanningIteration = resolveLatestCompletedPlanningIteration(taskKey, {
+        requireQa: false,
+        missingMessage: "Plan-revise requires design and plan markdown/JSON artifacts from the latest completed planning run.",
+    });
+    const reviewIteration = resolveLatestDesignReviewIteration(taskKey, sourcePlanningIteration);
     const reviewMd = designReviewFile(taskKey, reviewIteration);
     const reviewJson = designReviewJsonFile(taskKey, reviewIteration);
     requireArtifacts([reviewMd, reviewJson], "Plan-revise requires design-review markdown and JSON artifacts.");
     validateStructuredArtifacts([{ path: reviewJson, schemaId: "design-review/v1" }], "Plan-revise design-review structured artifact is invalid.");
-    const sourcePlanningIteration = resolveLatestCompletedPlanningIteration(taskKey);
     const srcDesignMd = designFile(taskKey, sourcePlanningIteration);
     const srcDesignJson = designJsonFile(taskKey, sourcePlanningIteration);
     const srcPlanMd = planFile(taskKey, sourcePlanningIteration);
@@ -110,7 +102,12 @@ export function resolvePlanReviseInputContract(taskKey) {
     const jiraTask = resolveOptionalPromptFile(jiraTaskFile(taskKey));
     const jiraAttachmentsManifest = resolveOptionalPromptFile(jiraAttachmentsManifestFile(taskKey));
     const jiraAttachmentsContext = resolveOptionalPromptFile(jiraAttachmentsContextFile(taskKey));
-    const planningAnswers = resolveOptionalPromptFile(planningAnswersJsonFile(taskKey));
+    const planningAnswers = resolveOptionalValidatedStructuredFile(planningAnswersJsonFile(taskKey), "user-input/v1", "Plan-revise planning answers structured artifact is invalid.");
+    const taskContextIteration = latestArtifactIteration(taskKey, "task-context", "json");
+    const taskContext = taskContextIteration === null
+        ? { present: false, path: null, promptValue: OPTIONAL_INPUT_NOT_PROVIDED }
+        : resolveOptionalValidatedStructuredFile(taskContextJsonFile(taskKey, taskContextIteration), "task-context/v1", "Plan-revise task-context structured artifact is invalid.");
+    const taskInput = resolveOptionalValidatedStructuredFile(instantTaskInputJsonFile(taskKey), "user-input/v1", "Plan-revise instant-task input structured artifact is invalid.");
     return {
         reviewIteration,
         reviewFile: reviewMd,
@@ -140,5 +137,11 @@ export function resolvePlanReviseInputContract(taskKey) {
         hasPlanningAnswersJsonFile: planningAnswers.present,
         planningAnswersJsonFilePath: planningAnswers.path,
         planningAnswersJsonFile: planningAnswers.promptValue,
+        hasTaskContextJsonFile: taskContext.present,
+        taskContextJsonFilePath: taskContext.path,
+        taskContextJsonFile: taskContext.promptValue,
+        hasTaskInputJsonFile: taskInput.present,
+        taskInputJsonFilePath: taskInput.path,
+        taskInputJsonFile: taskInput.promptValue,
     };
 }

package/dist/runtime/planning-bundle.js

@@ -0,0 +1,123 @@
+import { existsSync } from "node:fs";
+import { designFile, designJsonFile, latestArtifactIteration, planFile, planJsonFile, qaFile, qaJsonFile, } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+import { validateStructuredArtifacts } from "../structured-artifacts.js";
+function planningPrefixes(options) {
+    return options.requireQa ? ["design", "plan", "qa"] : ["design", "plan"];
+}
+function maxPlanningIteration(taskKey, options) {
+    let maxIteration = null;
+    for (const prefix of planningPrefixes(options)) {
+        for (const extension of ["md", "json"]) {
+            const iteration = latestArtifactIteration(taskKey, prefix, extension);
+            if (iteration === null) {
+                continue;
+            }
+            maxIteration = maxIteration === null ? iteration : Math.max(maxIteration, iteration);
+        }
+    }
+    return maxIteration;
+}
+export function planningBundlePaths(taskKey, iteration) {
+    return {
+        designFile: designFile(taskKey, iteration),
+        designJsonFile: designJsonFile(taskKey, iteration),
+        planFile: planFile(taskKey, iteration),
+        planJsonFile: planJsonFile(taskKey, iteration),
+        qaFile: qaFile(taskKey, iteration),
+        qaJsonFile: qaJsonFile(taskKey, iteration),
+    };
+}
+function requiredPlanningPaths(bundle, options) {
+    const required = [
+        bundle.designFile,
+        bundle.designJsonFile,
+        bundle.planFile,
+        bundle.planJsonFile,
+    ];
+    if (options.requireQa) {
+        required.push(bundle.qaFile, bundle.qaJsonFile);
+    }
+    return required;
+}
+export function findLatestCompletedPlanningIteration(taskKey, options) {
+    const latestKnownIteration = maxPlanningIteration(taskKey, options);
+    if (latestKnownIteration === null) {
+        return null;
+    }
+    for (let iteration = latestKnownIteration; iteration >= 1; iteration -= 1) {
+        const bundle = planningBundlePaths(taskKey, iteration);
+        const requiredPaths = requiredPlanningPaths(bundle, options);
+        if (requiredPaths.every((candidate) => existsSync(candidate))) {
+            return iteration;
+        }
+    }
+    return null;
+}
+export function resolveLatestCompletedPlanningIteration(taskKey, options) {
+    const resolvedIteration = findLatestCompletedPlanningIteration(taskKey, options);
+    if (resolvedIteration !== null) {
+        return resolvedIteration;
+    }
+    const fallbackIteration = maxPlanningIteration(taskKey, options) ?? 1;
+    const fallbackBundle = planningBundlePaths(taskKey, fallbackIteration);
+    const requiredPaths = requiredPlanningPaths(fallbackBundle, options);
+    const missing = requiredPaths.filter((candidate) => !existsSync(candidate));
+    throw new TaskRunnerError(`${options.missingMessage}\nMissing files: ${missing.join(", ")}`);
+}
+export function inspectLatestPlanningBundle(taskKey) {
+    const latestKnownIteration = maxPlanningIteration(taskKey, { requireQa: true });
+    if (latestKnownIteration === null) {
+        return {
+            status: "missing",
+            planningIteration: null,
+            missingFiles: [],
+            bundle: null,
+            errorMessage: "Implement mode requires planning artifacts from the planning phase, but none were found.",
+        };
+    }
+    const bundle = planningBundlePaths(taskKey, latestKnownIteration);
+    const missingFiles = requiredPlanningPaths(bundle, { requireQa: true }).filter((candidate) => !existsSync(candidate));
+    if (missingFiles.length > 0) {
+        return {
+            status: "incomplete",
+            planningIteration: latestKnownIteration,
+            missingFiles,
+            bundle,
+            errorMessage: `Implement mode requires a complete planning bundle for iteration ${latestKnownIteration}.` +
+                `\nMissing files: ${missingFiles.join(", ")}`,
+        };
+    }
+    try {
+        validateStructuredArtifacts([
+            { path: bundle.designJsonFile, schemaId: "implementation-design/v1" },
+            { path: bundle.planJsonFile, schemaId: "implementation-plan/v1" },
+            { path: bundle.qaJsonFile, schemaId: "qa-plan/v1" },
+        ], `Implement mode requires a valid structured planning bundle for iteration ${latestKnownIteration}.`);
+    }
+    catch (error) {
+        return {
+            status: "invalid",
+            planningIteration: latestKnownIteration,
+            missingFiles: [],
+            bundle,
+            errorMessage: error.message,
+        };
+    }
+    return {
+        status: "valid",
+        planningIteration: latestKnownIteration,
+        missingFiles: [],
+        bundle,
+    };
+}
+export function resolveLatestPlanningBundle(taskKey) {
+    const inspection = inspectLatestPlanningBundle(taskKey);
+    if (inspection.status !== "valid") {
+        throw new TaskRunnerError(inspection.errorMessage);
+    }
+    return {
+        planningIteration: inspection.planningIteration,
+        ...inspection.bundle,
+    };
+}

package/dist/runtime/ready-to-merge.js

@@ -1,4 +1,5 @@
-import { existsSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
 import { readyToMergeFile } from "../artifacts.js";
 export function clearReadyToMergeFile(taskKey) {
     const filePath = readyToMergeFile(taskKey);
@@ -8,3 +9,23 @@ export function clearReadyToMergeFile(taskKey) {
     rmSync(filePath);
     return true;
 }
+export function writeReadyToMergeFile(taskKey, options = {}) {
+    const filePath = readyToMergeFile(taskKey);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const summary = options.summary?.trim();
+    const lines = options.mdLang === "ru"
+        ? [
+            "# Готово к слиянию",
+            "",
+            "Блокирующих замечаний не найдено по текущему порогу severity.",
+            ...(summary ? ["", "## Summary", "", summary] : []),
+        ]
+        : [
+            "# Ready to Merge",
+            "",
+            "No blocking findings were detected at the configured severity threshold.",
+            ...(summary ? ["", "## Summary", "", summary] : []),
+        ];
+    writeFileSync(filePath, `${lines.join("\n")}\n`, "utf8");
+    return filePath;
+}

package/dist/runtime/review-input-contract.js

@@ -0,0 +1,100 @@
+import { existsSync } from "node:fs";
+import { designFile, designJsonFile, instantTaskInputJsonFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, requireArtifacts, taskContextJsonFile, } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+import { validateStructuredArtifacts } from "../structured-artifacts.js";
+import { resolveLatestCompletedPlanningIteration } from "./planning-bundle.js";
+const OPTIONAL_INPUT_NOT_PROVIDED = "not provided";
+function resolveOptionalPromptFile(filePath) {
+    if (!existsSync(filePath)) {
+        return {
+            present: false,
+            path: null,
+            promptValue: OPTIONAL_INPUT_NOT_PROVIDED,
+        };
+    }
+    return {
+        present: true,
+        path: filePath,
+        promptValue: filePath,
+    };
+}
+function resolveOptionalValidatedStructuredFile(filePath, schemaId, message) {
+    const resolved = resolveOptionalPromptFile(filePath);
+    if (!resolved.present) {
+        return resolved;
+    }
+    validateStructuredArtifacts([{ path: filePath, schemaId }], message);
+    return resolved;
+}
+export function inspectReviewInputContract(taskKey) {
+    let planningIteration;
+    try {
+        planningIteration = resolveLatestCompletedPlanningIteration(taskKey, {
+            requireQa: false,
+            missingMessage: "Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.",
+        });
+    }
+    catch (error) {
+        if (error instanceof TaskRunnerError) {
+            return { status: "missing-planning" };
+        }
+        throw error;
+    }
+    const contract = {
+        planningIteration,
+        designFile: designFile(taskKey, planningIteration),
+        designJsonFile: designJsonFile(taskKey, planningIteration),
+        planFile: planFile(taskKey, planningIteration),
+        planJsonFile: planJsonFile(taskKey, planningIteration),
+        hasTaskContextJsonFile: false,
+        taskContextJsonFilePath: null,
+        taskContextJsonFile: OPTIONAL_INPUT_NOT_PROVIDED,
+        hasJiraTaskFile: false,
+        jiraTaskFilePath: null,
+        jiraTaskFile: OPTIONAL_INPUT_NOT_PROVIDED,
+        hasTaskInputJsonFile: false,
+        taskInputJsonFilePath: null,
+        taskInputJsonFile: OPTIONAL_INPUT_NOT_PROVIDED,
+    };
+    requireArtifacts([contract.designFile, contract.designJsonFile, contract.planFile, contract.planJsonFile], "Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
+    validateStructuredArtifacts([
+        { path: contract.designJsonFile, schemaId: "implementation-design/v1" },
+        { path: contract.planJsonFile, schemaId: "implementation-plan/v1" },
+    ], "Structured review requires valid design and plan structured artifacts.");
+    const taskContextIteration = latestArtifactIteration(taskKey, "task-context", "json");
+    const taskContext = taskContextIteration === null
+        ? { present: false, path: null, promptValue: OPTIONAL_INPUT_NOT_PROVIDED }
+        : resolveOptionalValidatedStructuredFile(taskContextJsonFile(taskKey, taskContextIteration), "task-context/v1", "Structured review task-context structured artifact is invalid.");
+    const jiraTask = resolveOptionalPromptFile(jiraTaskFile(taskKey));
+    const taskInput = resolveOptionalValidatedStructuredFile(instantTaskInputJsonFile(taskKey), "user-input/v1", "Structured review instant-task input structured artifact is invalid.");
+    if (!taskContext.present && !jiraTask.present && !taskInput.present) {
+        return {
+            status: "missing-task-context",
+            planningIteration,
+        };
+    }
+    contract.hasTaskContextJsonFile = taskContext.present;
+    contract.taskContextJsonFilePath = taskContext.path;
+    contract.taskContextJsonFile = taskContext.promptValue;
+    contract.hasJiraTaskFile = jiraTask.present;
+    contract.jiraTaskFilePath = jiraTask.path;
+    contract.jiraTaskFile = jiraTask.promptValue;
+    contract.hasTaskInputJsonFile = taskInput.present;
+    contract.taskInputJsonFilePath = taskInput.path;
+    contract.taskInputJsonFile = taskInput.promptValue;
+    return {
+        status: "ready",
+        contract,
+    };
+}
+export function resolveReviewInputContract(taskKey) {
+    const inspection = inspectReviewInputContract(taskKey);
+    if (inspection.status === "ready") {
+        return inspection.contract;
+    }
+    if (inspection.status === "missing-planning") {
+        throw new TaskRunnerError("Structured review requires design and plan markdown/JSON artifacts from the latest completed planning run.");
+    }
+    throw new TaskRunnerError(`Structured review requires a normalized task-context artifact, or legacy Jira/instant-task context, in scope '${taskKey}'.`);
+}
+export { OPTIONAL_INPUT_NOT_PROVIDED };

package/dist/structured-artifact-schema-registry.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { TaskRunnerError } from "./errors.js";
 export const STRUCTURED_ARTIFACT_SCHEMA_IDS = [
+    "artifact-manifest/v1",
     "bug-analysis/v1",
     "bug-fix-design/v1",
     "bug-fix-plan/v1",
@@ -18,9 +19,17 @@ export const STRUCTURED_ARTIFACT_SCHEMA_IDS = [
     "review-assessment/v1",
     "review-findings/v1",
     "review-fix-report/v1",
+    "task-context/v1",
     "task-summary/v1",
     "user-input/v1",
 ];
+export const ARTIFACT_PAYLOAD_SCHEMA_IDS = [
+    ...STRUCTURED_ARTIFACT_SCHEMA_IDS,
+    "helper-json/v1",
+    "markdown/v1",
+    "opaque-file/v1",
+    "plain-text/v1",
+];
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 export const SCHEMA_REGISTRY_PATH = path.join(MODULE_DIR, "structured-artifact-schemas.json");
 function isRecord(value) {

package/dist/structured-artifact-schemas.json

@@ -612,7 +612,7 @@
         "items": {
           "type": "object",
           "properties": {
-            "severity": { "type": "string", "nonEmpty": true },
+            "severity": { "type": "string", "enum": ["blocker", "critical", "high", "medium", "low", "info"] },
             "title": { "type": "string", "nonEmpty": true },
             "description": { "type": "string", "nonEmpty": true }
           },
@@ -660,6 +660,145 @@
     },
     "required": ["summary", "completed_actions", "validation_steps"]
   },
+  "helper-json/v1": {
+    "type": "json"
+  },
+  "markdown/v1": {
+    "type": "string",
+    "nonEmpty": true
+  },
+  "opaque-file/v1": {
+    "type": "bytes"
+  },
+  "plain-text/v1": {
+    "type": "string",
+    "nonEmpty": true
+  },
+  "artifact-manifest/v1": {
+    "type": "object",
+    "properties": {
+      "artifact_id": { "type": "string", "nonEmpty": true },
+      "logical_key": { "type": "string", "nonEmpty": true, "pattern": "^[a-z0-9][a-z0-9._/-]*$" },
+      "scope": { "type": "string", "nonEmpty": true },
+      "run_id": { "type": "string", "nonEmpty": true },
+      "flow_id": { "type": "string", "nonEmpty": true },
+      "phase_id": { "type": "string", "nonEmpty": true },
+      "step_id": { "type": "string", "nonEmpty": true },
+      "kind": { "type": "string", "enum": ["artifact", "file"] },
+      "version": { "type": "number" },
+      "payload_family": { "type": "string", "enum": ["structured-json", "markdown", "plain-text", "helper-json", "opaque-file"] },
+      "schema_id": { "type": "string", "nonEmpty": true },
+      "schema_version": { "type": "number" },
+      "created_at": { "type": "string", "nonEmpty": true },
+      "producer": {
+        "type": "object",
+        "properties": {
+          "node": { "type": "string", "nonEmpty": true },
+          "executor": { "type": "string", "nonEmpty": true },
+          "model": { "type": "string", "nonEmpty": true },
+          "summary": { "type": "string", "nonEmpty": true }
+        },
+        "required": ["node"]
+      },
+      "inputs": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "source": { "type": "string", "enum": ["manifest", "external-path"] },
+            "path": { "type": "string", "nonEmpty": true },
+            "artifact_id": { "type": "string", "nonEmpty": true },
+            "logical_key": { "type": "string", "nonEmpty": true, "pattern": "^[a-z0-9][a-z0-9._/-]*$" },
+            "schema_id": { "type": "string", "nonEmpty": true },
+            "schema_version": { "type": "number" }
+          },
+          "required": ["source", "path"]
+        }
+      },
+      "content_hash": { "type": "string", "nonEmpty": true, "pattern": "^sha256:[a-f0-9]{64}$" },
+      "status": { "type": "string", "enum": ["ready", "superseded", "stale"] },
+      "payload_path": { "type": "string", "nonEmpty": true },
+      "manifest_path": { "type": "string", "nonEmpty": true },
+      "publication_key": { "type": "string", "nonEmpty": true },
+      "supersedes": { "type": "string", "nonEmpty": true },
+      "status_reason": { "type": "string", "nonEmpty": true },
+      "diagnostics": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "code": { "type": "string", "nonEmpty": true },
+            "severity": { "type": "string", "enum": ["info", "warning", "error"] },
+            "message": { "type": "string", "nonEmpty": true }
+          },
+          "required": ["code", "severity", "message"]
+        }
+      }
+    },
+    "required": [
+      "artifact_id",
+      "logical_key",
+      "scope",
+      "run_id",
+      "flow_id",
+      "phase_id",
+      "step_id",
+      "kind",
+      "version",
+      "payload_family",
+      "schema_id",
+      "schema_version",
+      "created_at",
+      "producer",
+      "inputs",
+      "content_hash",
+      "status",
+      "payload_path",
+      "manifest_path",
+      "publication_key"
+    ]
+  },
+  "task-context/v1": {
+    "type": "object",
+    "properties": {
+      "source_type": {
+        "type": "string",
+        "nonEmpty": true,
+        "enum": ["jira", "manual"]
+      },
+      "title": { "type": "string", "nonEmpty": true },
+      "summary": { "type": "string", "nonEmpty": true },
+      "problem": { "type": "string", "nonEmpty": true },
+      "goal": { "type": "string", "nonEmpty": true },
+      "acceptance_criteria": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "constraints": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "references": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      },
+      "notes": {
+        "type": "array",
+        "items": { "type": "string", "nonEmpty": true }
+      }
+    },
+    "required": [
+      "source_type",
+      "title",
+      "summary",
+      "problem",
+      "goal",
+      "acceptance_criteria",
+      "constraints",
+      "references",
+      "notes"
+    ]
+  },
   "task-summary/v1": {
     "type": "object",
     "properties": {

package/dist/structured-artifacts.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { TaskRunnerError } from "./errors.js";
-import { STRUCTURED_ARTIFACT_SCHEMA_IDS, getStructuredArtifactSchema, } from "./structured-artifact-schema-registry.js";
-export { STRUCTURED_ARTIFACT_SCHEMA_IDS };
+import { ARTIFACT_PAYLOAD_SCHEMA_IDS, STRUCTURED_ARTIFACT_SCHEMA_IDS, getStructuredArtifactSchema, } from "./structured-artifact-schema-registry.js";
+export { ARTIFACT_PAYLOAD_SCHEMA_IDS, STRUCTURED_ARTIFACT_SCHEMA_IDS };
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -14,9 +14,16 @@ function schemaLabel(node) {
             if (node.enum && node.enum.length > 0) {
                 return `one of: ${node.enum.join(", ")}`;
             }
+            if (node.pattern) {
+                return "a string with the expected format";
+            }
             return node.nonEmpty ? "a non-empty string" : "a string";
         case "boolean":
             return "a boolean";
+        case "bytes":
+            return "a binary file";
+        case "json":
+            return "valid JSON";
         case "number":
             return "a number";
         case "null":
@@ -49,9 +56,24 @@ function validateNode(value, schema, currentPath) {
             if (schema.enum && !schema.enum.includes(value)) {
                 return [`${currentPath} must be ${schemaLabel(schema)}`];
             }
+            if (schema.pattern) {
+                try {
+                    const pattern = new RegExp(schema.pattern);
+                    if (!pattern.test(value)) {
+                        return [`${currentPath} must be ${schemaLabel(schema)}`];
+                    }
+                }
+                catch {
+                    return [`${currentPath} uses an invalid schema pattern`];
+                }
+            }
             return [];
         case "boolean":
             return typeof value === "boolean" ? [] : [`${currentPath} must be a boolean`];
+        case "bytes":
+            return value instanceof Uint8Array ? [] : [`${currentPath} must be a binary file`];
+        case "json":
+            return validateJsonValue(value, currentPath);
         case "number":
             return typeof value === "number" && !Number.isNaN(value) ? [] : [`${currentPath} must be a number`];
         case "null":
@@ -85,6 +107,28 @@ function validateNode(value, schema, currentPath) {
         }
     }
 }
+function validateJsonValue(value, currentPath) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item, index) => validateJsonValue(item, `${currentPath}[${index}]`));
+    }
+    if (!isRecord(value)) {
+        return [`${currentPath} must be valid JSON`];
+    }
+    return Object.entries(value).flatMap(([key, candidate]) => validateJsonValue(candidate, `${currentPath}.${key}`));
+}
+function validateArtifactPayloadValue(value, schemaId, label = "$") {
+    const schema = getStructuredArtifactSchema(schemaId);
+    const issues = validateNode(value, schema, label);
+    if (issues.length > 0) {
+        throw new TaskRunnerError(`Structured artifact ${label} failed schema ${schemaId} validation:\n${issues.join("\n")}`);
+    }
+}
 export function validateStructuredArtifact(path, schemaId) {
     if (!existsSync(path)) {
         throw new TaskRunnerError(`Structured artifact file not found: ${path}`);
@@ -96,11 +140,38 @@ export function validateStructuredArtifact(path, schemaId) {
     catch (error) {
         throw new TaskRunnerError(`Structured artifact ${path} is not valid JSON: ${error.message}`);
     }
-    const schema = getStructuredArtifactSchema(schemaId);
-    const issues = validateNode(parsed, schema, path);
-    if (issues.length > 0) {
-        throw new TaskRunnerError(`Structured artifact ${path} failed schema ${schemaId} validation:\n${issues.join("\n")}`);
+    validateArtifactPayloadValue(parsed, schemaId, path);
+}
+export function validateStructuredArtifactValue(value, schemaId, label = "$") {
+    validateArtifactPayloadValue(value, schemaId, label);
+}
+export function isArtifactPayloadSchemaId(schemaId) {
+    return ARTIFACT_PAYLOAD_SCHEMA_IDS.includes(schemaId);
+}
+export function validateArtifactPayload(path, schemaId) {
+    if (!existsSync(path)) {
+        throw new TaskRunnerError(`Structured artifact file not found: ${path}`);
+    }
+    if (schemaId === "markdown/v1" || schemaId === "plain-text/v1") {
+        validateArtifactPayloadValue(readFileSync(path, "utf8"), schemaId, path);
+        return;
+    }
+    if (schemaId === "helper-json/v1") {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch (error) {
+            throw new TaskRunnerError(`Structured artifact ${path} is not valid JSON: ${error.message}`);
+        }
+        validateArtifactPayloadValue(parsed, schemaId, path);
+        return;
+    }
+    if (schemaId === "opaque-file/v1") {
+        validateArtifactPayloadValue(readFileSync(path), schemaId, path);
+        return;
     }
+    validateStructuredArtifact(path, schemaId);
 }
 export function validateStructuredArtifacts(items, message) {
     try {