@multileaf/ai-workflow 0.1.4 → 0.2.0

package/dist/quality-gates.d.ts

@@ -1,2 +1,2 @@
-export type QualityGateStage = "specification" | "plan" | "verification";
+export type QualityGateStage = "brainstorming" | "specification" | "technical-design" | "plan" | "implementation" | "verification" | "review" | "traceability";
 export declare function evaluateQualityGate(stage: QualityGateStage, content: string): string[];

package/dist/quality-gates.js

@@ -1,3 +1,4 @@
+import { parseDocument } from "yaml";
 function section(content, heading) {
     const match = content.match(new RegExp(`^## ${heading}\\s*$([\\s\\S]*?)(?=^## |(?![\\s\\S]))`, "im"));
     return match?.[1].trim();
@@ -11,7 +12,7 @@ function requireSections(content, artifact, headings) {
     });
 }
 export function evaluateQualityGate(stage, content) {
-    if (stage === "specification")
+    if (stage === "brainstorming")
         return requireSections(content, "Brainstorm", [
             "Goal",
             "Users",
@@ -19,7 +20,7 @@ export function evaluateQualityGate(stage, content) {
             "Risks",
             "Non-goals",
         ]);
-    if (stage === "plan") {
+    if (stage === "specification") {
         const issues = [];
         if (!/REQ-\d+/.test(content))
             issues.push("Specification must define a stable REQ-### ID.");
@@ -29,12 +30,72 @@ export function evaluateQualityGate(stage, content) {
             issues.push("Requirement acceptance criteria must use Given, When, and Then.");
         return issues;
     }
-    const fields = ["Requirement", "Code", "Tests", "Validation", "Evidence"];
-    const issues = !/TASK-\d+/.test(content)
-        ? ["Implementation plan must define a TASK-### ID."]
-        : [];
-    for (const field of fields)
-        if (!new RegExp(`^[ \\t]*-?[ \\t]*${field}:[ \\t]*\\S+`, "im").test(content))
-            issues.push(`Implementation plan task must define ${field}.`);
-    return issues;
+    if (stage === "technical-design")
+        return requireSections(content, "Technical Design", [
+            "Context",
+            "Proposed Design",
+            "Alternatives",
+            "Interfaces",
+            "Risks",
+            "Validation",
+        ]);
+    if (stage === "plan") {
+        const fields = ["Requirement", "Code", "Tests", "Validation", "Evidence"];
+        const issues = !/TASK-\d+/.test(content)
+            ? ["Implementation plan must define a TASK-### ID."]
+            : [];
+        for (const field of fields)
+            if (!new RegExp(`^[ \\t]*-?[ \\t]*${field}:[ \\t]*\\S+`, "im").test(content))
+                issues.push(`Implementation plan task must define ${field}.`);
+        return issues;
+    }
+    if (stage === "implementation")
+        return requireSections(content, "Implementation Evidence", [
+            "Changed Files",
+            "Tests",
+            "Validation",
+            "Deviations",
+        ]);
+    if (stage === "verification")
+        return requireSections(content, "Verification Report", [
+            "Requirements Checked",
+            "Checks Passed",
+            "Missing Evidence",
+            "Residual Risks",
+            "Decision",
+        ]);
+    if (stage === "review")
+        return requireSections(content, "Code Review", [
+            "Scope",
+            "Findings",
+            "Checks",
+            "Residual Risks",
+            "Decision",
+        ]);
+    const document = parseDocument(content, { uniqueKeys: true, strict: true });
+    if (document.errors.length)
+        return ["Traceability evidence must be valid YAML."];
+    const value = document.toJS();
+    if (!isRecord(value) || value.schema !== 1 || !Array.isArray(value.links))
+        return ["Traceability evidence must define schema: 1 and a links list."];
+    if (value.links.length === 0)
+        return ["Traceability evidence must link at least one requirement."];
+    const fields = ["requirement", "tasks", "code", "tests", "evidence"];
+    return value.links.flatMap((link, index) => {
+        if (!isRecord(link))
+            return [`Traceability link ${index + 1} must be a mapping.`];
+        return fields.flatMap((field) => {
+            const fieldValue = link[field];
+            return field === "requirement"
+                ? typeof fieldValue === "string" && /^REQ-\d+$/.test(fieldValue)
+                    ? []
+                    : [`Traceability link ${index + 1} requires a valid requirement ID.`]
+                : Array.isArray(fieldValue) && fieldValue.length > 0
+                    ? []
+                    : [`Traceability link ${index + 1} requires non-empty ${field} evidence.`];
+        });
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/recommendations.d.ts

@@ -13,6 +13,7 @@ export type CapabilityRecommendation = {
     permissions: string[];
     conflicts: string[];
     resources: RecommendedResource[];
+    requires?: string[];
 };
 export declare function recommendCapabilities(profile: ProjectProfile): CapabilityRecommendation[];
 export declare function resourcesForCapabilities(ids: string[]): RecommendedResource[];

package/dist/recommendations.js

@@ -38,10 +38,26 @@ const CATALOG = [
             { type: "agents", id: "technical-architect" },
             { type: "templates", id: "implementation-plan" },
         ]),
+        requires: ["requirements-specification"],
         matches: (profile) => hasProjectSignals(profile)
             ? { evidence: projectEvidence(profile), confidence: 0.88 }
             : undefined,
     },
+    {
+        id: "technical-design",
+        provider: "multileaf",
+        rationale: "Architecture changes benefit from explicit alternatives, trade-offs, and decision records.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "technical-design" },
+            { type: "agents", id: "technical-architect" },
+            { type: "templates", id: "technical-design" },
+            { type: "templates", id: "decision-record" },
+        ]),
+        matches: (profile) => hasProjectSignals(profile)
+            ? { evidence: projectEvidence(profile), confidence: 0.82 }
+            : undefined,
+    },
     {
         id: "code-review",
         provider: "multileaf",
@@ -51,6 +67,7 @@ const CATALOG = [
             { type: "skills", id: "code-review" },
             { type: "agents", id: "quality-reviewer" },
         ]),
+        requires: ["verification"],
         matches: (profile) => profile.runtime.languages.length
             ? { evidence: projectEvidence(profile), confidence: 0.86 }
             : undefined,
@@ -68,9 +85,25 @@ const CATALOG = [
             { type: "hooks", id: "post-implementation" },
             { type: "templates", id: "test-plan" },
         ]),
-        matches: (profile) => profile.testing
-            ? { evidence: [`testing:${profile.testing.name}`], confidence: 1 }
-            : undefined,
+        requires: ["verification"],
+        matches: (profile) => {
+            const runners = [
+                ...(profile.testing ? [profile.testing] : []),
+                ...(profile.modules ?? []).flatMap((module) => module.testing ? [{ ...module.testing, module: module.path }] : []),
+            ];
+            return runners.length
+                ? {
+                    evidence: [
+                        ...new Set(runners.flatMap((runner) => [
+                            ...("module" in runner ? [`workspace:${runner.module}`] : []),
+                            `testing:${runner.name}`,
+                            ...(runner.command ? [`test-command:${runner.command}`] : []),
+                        ])),
+                    ],
+                    confidence: 1,
+                }
+                : undefined;
+        },
     },
     {
         id: "typescript-quality",
@@ -116,18 +149,19 @@ const CATALOG = [
             : undefined,
     },
     {
-        id: "vitest-testing",
+        id: "verification",
         provider: "multileaf",
-        rationale: "Vitest is configured and can be used by the verification skill and test specialist.",
+        rationale: "Verification guidance can use the project's detected test runner and quality commands.",
         permissions: [],
         resources: local([
             { type: "skills", id: "verification" },
-            { type: "agents", id: "test-engineer" },
+            { type: "agents", id: "quality-reviewer" },
             { type: "templates", id: "test-plan" },
             { type: "templates", id: "verification-report" },
         ]),
-        matches: (profile) => profile.testing?.name === "vitest"
-            ? { evidence: ["testing:vitest"], confidence: 1 }
+        requires: ["implementation-planning"],
+        matches: (profile) => hasProjectSignals(profile)
+            ? { evidence: projectEvidence(profile), confidence: profile.testing ? 1 : 0.84 }
             : undefined,
     },
     {
@@ -208,8 +242,9 @@ export function recommendCapabilities(profile) {
     });
 }
 export function resourcesForCapabilities(ids) {
-    const selectedCapabilities = new Set(CATALOG.filter(({ id }) => ids.includes(id)).map(({ id }) => id));
-    const selectedResources = new Set(ids.filter((id) => id.includes("/")));
+    const normalizedIds = ids.map((id) => (id === "vitest-testing" ? "verification" : id));
+    const selectedCapabilities = new Set(CATALOG.filter(({ id }) => normalizedIds.includes(id)).map(({ id }) => id));
+    const selectedResources = new Set(normalizedIds.filter((id) => id.includes("/")));
     const resources = CATALOG.flatMap(({ id, resources }) => selectedCapabilities.has(id)
         ? resources
         : resources.filter(({ type, id: resourceId }) => selectedResources.has(`${type}/${resourceId}`)));
@@ -219,7 +254,7 @@ export function resourcesForCapabilities(ids) {
 }
 export function serializeRecommendations(items, selected = []) {
     return `schema: 1\nrecommendations:\n${items
-        .map((item) => `  - id: ${item.id}\n    provider: ${item.provider}\n    confidence: ${item.confidence}\n    selected: ${selected.includes(item.id)}\n    resources: [${item.resources.map(({ type, id }) => `${type}/${id}`).join(", ")}]\n    selected_resources: [${item.resources
+        .map((item) => `  - id: ${item.id}\n    provider: ${item.provider}\n    confidence: ${item.confidence}\n    selected: ${selected.includes(item.id)}\n    requires: [${(item.requires ?? []).join(", ")}]\n    resources: [${item.resources.map(({ type, id }) => `${type}/${id}`).join(", ")}]\n    selected_resources: [${item.resources
         .filter(({ type, id }) => selected.includes(`${type}/${id}`))
         .map(({ type, id }) => `${type}/${id}`)
         .join(", ")}]\n    evidence: [${item.evidence.map((evidence) => `"${evidence}"`).join(", ")}]\n    rationale: ${item.rationale}`)

package/dist/selection.js

@@ -3,15 +3,45 @@ export async function selectRecommendations(items, answer, selectedIds) {
         item.id,
         ...(item.resources ?? []).map(({ type, id }) => `${type}/${id}`),
     ]));
+    available.add("vitest-testing");
     if (selectedIds?.includes("all"))
         return items.map(({ id }) => id);
     if (selectedIds)
-        return [...new Set(selectedIds.filter((id) => available.has(id)))];
+        return includeRequirements(items, selectedIds
+            .filter((id) => available.has(id))
+            .map((id) => (id === "vitest-testing" ? "verification" : id)));
     const selected = [];
     for (const item of items) {
         const response = (await answer(`Install ${item.id}? [Y/n] `)).trim().toLowerCase();
         if (response === "" || response === "y" || response === "yes")
             selected.push(item.id);
     }
-    return selected;
+    return includeRequirements(items, selected);
+}
+function includeRequirements(items, selectedIds) {
+    const selected = new Set(selectedIds);
+    const byId = new Map(items.map((item) => [item.id, item]));
+    const owners = new Map();
+    for (const item of items)
+        for (const resource of item.resources ?? [])
+            owners.set(`${resource.type}/${resource.id}`, item.id);
+    const visit = (capabilityId, visited) => {
+        if (visited.has(capabilityId))
+            return;
+        visited.add(capabilityId);
+        const capability = byId.get(capabilityId);
+        if (!capability)
+            return;
+        for (const requirement of capability.requires ?? []) {
+            if (!byId.has(requirement))
+                continue;
+            selected.add(requirement);
+            visit(requirement, visited);
+        }
+    };
+    const initial = [...selected];
+    const visited = new Set();
+    for (const id of initial)
+        visit(byId.has(id) ? id : (owners.get(id) ?? ""), visited);
+    return [...selected];
 }

package/dist/types.d.ts

@@ -1,5 +1,7 @@
 export declare const TARGETS: readonly ["codex", "claude", "cursor", "gemini", "copilot", "universal"];
 export type Target = (typeof TARGETS)[number];
+export declare const HUMAN_APPROVAL_STAGES: readonly ["brainstorming", "specification", "technical-design", "plan", "implementation", "verification", "review", "traceability"];
+export type HumanApprovalStage = (typeof HUMAN_APPROVAL_STAGES)[number];
 export type CommandResult = {
     exitCode: number;
     output?: string;

package/dist/types.js

@@ -1 +1,11 @@
 export const TARGETS = ["codex", "claude", "cursor", "gemini", "copilot", "universal"];
+export const HUMAN_APPROVAL_STAGES = [
+    "brainstorming",
+    "specification",
+    "technical-design",
+    "plan",
+    "implementation",
+    "verification",
+    "review",
+    "traceability",
+];