@h9-foundry/agentforge-cli 0.4.2 → 0.6.0

package/dist/internal/builtin-agents.js

@@ -1,4 +1,6 @@
-import { agentManifestSchema, agentOutputSchema } from "@h9-foundry/agentforge-schemas";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { agentManifestSchema, agentOutputSchema, designArtifactSchema, implementationArtifactSchema, implementationInventorySchema, qaRequestSchema, planningArtifactSchema } from "@h9-foundry/agentforge-schemas";
 const contextCollectorAgent = {
     manifest: agentManifestSchema.parse({
         version: 1,
@@ -22,6 +24,12 @@ const contextCollectorAgent = {
             sections: ["repo", "changes", "context"],
             minimalContext: true
         },
+        catalog: {
+            domain: "foundation",
+            supportLevel: "official",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
         trust: {
             tier: "core",
             source: "official",
@@ -49,6 +57,929 @@ const contextCollectorAgent = {
         });
     }
 };
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function parsePackageScripts(packageJsonPath) {
+    if (!existsSync(packageJsonPath)) {
+        return {};
+    }
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (!isRecord(parsed) || !isRecord(parsed.scripts)) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(parsed.scripts).filter((entry) => typeof entry[1] === "string"));
+}
+const allowedValidationScriptNames = new Set(["test", "lint", "typecheck", "build", "build:packages", "release:verify"]);
+function normalizeRequestedCommand(command) {
+    return command.trim().replace(/\s+/g, " ");
+}
+function buildValidationCommand(packageManager, scriptName, packageName) {
+    if (packageName) {
+        return `${packageManager} --filter ${packageName} ${scriptName}`;
+    }
+    return `${packageManager} ${scriptName}`;
+}
+function derivePackageScope(pathValue) {
+    const segments = pathValue.split("/").filter(Boolean);
+    if (segments.length < 2) {
+        return undefined;
+    }
+    const [topLevel, scope] = segments;
+    if (topLevel === "packages" || topLevel === "agents" || topLevel === "adapters") {
+        return `${topLevel}/${scope}`;
+    }
+    return undefined;
+}
+function getWorkflowInput(stateSlice, key) {
+    if (!isRecord(stateSlice.workflowInputs)) {
+        return undefined;
+    }
+    return stateSlice.workflowInputs[key];
+}
+function buildArtifactEnvelopeBase(state, summary, inputRefs, issueRefs) {
+    return {
+        schemaVersion: state.version,
+        workflow: {
+            name: state.workflow
+        },
+        source: {
+            sourceType: "workflow-run",
+            runId: state.runId,
+            inputRefs: [...inputRefs],
+            issueRefs: [...issueRefs]
+        },
+        status: "complete",
+        generatedAt: new Date().toISOString(),
+        repo: {
+            root: state.repo.root,
+            name: state.repo.name,
+            branch: state.repo.branch
+        },
+        provenance: {
+            generatedBy: "agentforge-runtime",
+            schemaVersion: state.version,
+            executionEnvironment: state.context.ciExecution ? "ci" : "local",
+            repoRoot: state.repo.root
+        },
+        redaction: {
+            applied: true,
+            strategyVersion: "1.0.0",
+            categories: ["github-token", "api-key", "aws-key", "bearer-token", "password", "private-key"]
+        },
+        auditLink: {
+            entryIds: [],
+            findingIds: [],
+            proposedActionIds: []
+        },
+        summary
+    };
+}
+const planningIntakeAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "planning-intake",
+        displayName: "Planning Intake",
+        category: "planning",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "context"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "plan",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const planningRequest = getWorkflowInput(stateSlice, "planningRequest");
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!planningRequest) {
+            throw new Error("planning-discovery requires a validated planning request before runtime execution.");
+        }
+        return agentOutputSchema.parse({
+            summary: `Loaded planning request from ${requestFile ?? ".agentops/requests/planning.yaml"}.`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: {
+                requestFile,
+                problemStatement: planningRequest.problemStatement,
+                goals: planningRequest.goals,
+                constraints: planningRequest.constraints,
+                issueRefs: planningRequest.issueRefs,
+                pathHints: planningRequest.pathHints
+            }
+        });
+    }
+};
+const planningAnalystAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "planning-analyst",
+        displayName: "Planning Analyst",
+        category: "planning",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "reasoning"
+        },
+        permissions: {
+            model: true,
+            network: false,
+            tools: [],
+            readPaths: ["**/*"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "changes", "agentResults"],
+        outputs: ["lifecycleArtifacts"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "changes", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "plan",
+            supportLevel: "official",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ state, stateSlice }) {
+        const planningRequest = getWorkflowInput(stateSlice, "planningRequest");
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!planningRequest) {
+            throw new Error("planning-discovery requires a validated planning request before planning analysis.");
+        }
+        const topLevelHints = [...new Set(planningRequest.pathHints.map((hint) => hint.split("/")[0] ?? hint).filter(Boolean))];
+        const objectives = planningRequest.goals.length > 0
+            ? planningRequest.goals
+            : [`Produce a bounded plan for: ${planningRequest.problemStatement}`];
+        const inScope = planningRequest.pathHints.length > 0
+            ? planningRequest.pathHints
+            : ["Repository discovery", "Planning brief synthesis", "Next-step recommendation"];
+        const outOfScope = ["Source-file mutation", "Network-backed intake", "Architecture/design decisions"];
+        const openQuestions = [
+            ...(planningRequest.issueRefs.length === 0 ? ["Should this planning work be linked to a tracked issue?"] : []),
+            ...(planningRequest.pathHints.length === 0 ? ["Which repository paths should be prioritized in follow-up design work?"] : [])
+        ];
+        const candidateWorkstreams = topLevelHints.length > 0 ? topLevelHints : state.changes.impactedPaths;
+        const risks = [
+            ...(planningRequest.pathHints.length === 0 ? ["Impact area is broad because no path hints were supplied."] : []),
+            ...(planningRequest.assumptions.length === 0 ? ["Planning assumptions were not supplied and may need confirmation."] : [])
+        ];
+        const summary = `Planning brief scoped ${objectives.length} objective(s) for ${state.repo.name}.`;
+        const planningBrief = planningArtifactSchema.parse({
+            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/planning.yaml"], planningRequest.issueRefs),
+            artifactKind: "planning-brief",
+            lifecycleDomain: "plan",
+            workflow: {
+                name: state.workflow,
+                displayName: "Planning And Discovery"
+            },
+            payload: {
+                problemStatement: planningRequest.problemStatement,
+                objectives,
+                constraints: planningRequest.constraints,
+                assumptions: planningRequest.assumptions,
+                inScope,
+                outOfScope,
+                recommendedNextSteps: [
+                    "Review the generated planning brief and refine missing constraints or path hints.",
+                    "Open or update follow-on implementation issues for the accepted planning scope.",
+                    "Use the planning brief as input to `architecture-design-review` for the next design slice."
+                ],
+                stakeholders: planningRequest.issueRefs.length > 0 ? ["Maintainers linked to the referenced issues"] : [],
+                risks,
+                openQuestions,
+                candidateWorkstreams,
+                linkedIssues: planningRequest.issueRefs
+            }
+        });
+        return agentOutputSchema.parse({
+            summary,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [planningBrief],
+            requestedTools: [],
+            blockedActionFlags: [],
+            confidence: 0.8,
+            metadata: {
+                deterministicContext: {
+                    pathHints: planningRequest.pathHints,
+                    impactedPaths: state.changes.impactedPaths,
+                    repository: state.repo.name
+                },
+                synthesizedPlanning: {
+                    recommendedNextSteps: planningBrief.payload.recommendedNextSteps,
+                    openQuestions
+                }
+            }
+        });
+    }
+};
+const designIntakeAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "design-intake",
+        displayName: "Design Intake",
+        category: "design",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "context"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "design",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const designRequest = getWorkflowInput(stateSlice, "designRequest");
+        const planningBrief = getWorkflowInput(stateSlice, "planningBrief");
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!designRequest || !planningBrief) {
+            throw new Error("architecture-design-review requires a validated design request and planning brief before runtime execution.");
+        }
+        return agentOutputSchema.parse({
+            summary: `Loaded design request from ${requestFile ?? ".agentops/requests/design.yaml"} with planning brief ${designRequest.planningBriefRef}.`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: {
+                requestFile,
+                planningBriefRef: designRequest.planningBriefRef,
+                decisionTarget: designRequest.decisionTarget,
+                planningObjectives: planningBrief.payload.objectives
+            }
+        });
+    }
+};
+const designInventoryAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "design-inventory",
+        displayName: "Design Inventory",
+        category: "design",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: ["filesystem.list-files"],
+            readPaths: ["**/*"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "changes"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "changes"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "design",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice, invokeTool }) {
+        const designRequest = getWorkflowInput(stateSlice, "designRequest");
+        const planningBrief = getWorkflowInput(stateSlice, "planningBrief");
+        if (!designRequest || !planningBrief) {
+            throw new Error("architecture-design-review requires deterministic inventory inputs before design analysis.");
+        }
+        const candidatePaths = [...new Set([...designRequest.pathHints, ...(stateSlice.changes?.impactedPaths ?? [])])];
+        const repoRoot = stateSlice.repo?.root;
+        const inspectedPaths = candidatePaths
+            .filter((pathHint) => {
+            if (!pathHint) {
+                return false;
+            }
+            const finalSegment = pathHint.split("/").at(-1) ?? pathHint;
+            if (pathHint !== ".agentops" && finalSegment.includes(".")) {
+                return false;
+            }
+            if (!repoRoot) {
+                return true;
+            }
+            return existsSync(join(repoRoot, pathHint));
+        })
+            .slice(0, 8);
+        const listedEntries = [];
+        for (const pathHint of inspectedPaths) {
+            const listed = await invokeTool({
+                tool: "filesystem.list-files",
+                input: { path: pathHint },
+                requestedBy: "design-inventory",
+                requestedAt: new Date().toISOString()
+            });
+            if (listed.status === "success" && isRecord(listed.output) && Array.isArray(listed.output.entries)) {
+                for (const entry of listed.output.entries) {
+                    if (typeof entry === "string") {
+                        listedEntries.push(`${pathHint}/${entry}`.replaceAll("//", "/"));
+                    }
+                }
+            }
+        }
+        const impactedInterfaces = [
+            ...new Set([...candidatePaths, ...listedEntries].filter((entry) => entry.endsWith("src/index.ts") || entry.endsWith("package.json") || entry.endsWith("agent.manifest.json")))
+        ];
+        const schemaSurfaces = [
+            ...new Set([...candidatePaths, ...listedEntries].filter((entry) => entry.includes("packages/schemas") || entry.includes("schema") || entry.endsWith(".yaml")))
+        ];
+        const policySurfaces = [
+            ...new Set([...candidatePaths, ...listedEntries].filter((entry) => entry.includes("policy") || entry.includes("packages/policy-engine") || entry.includes(".agentops/policy.yaml")))
+        ];
+        return agentOutputSchema.parse({
+            summary: `Collected deterministic design inventory across ${inspectedPaths.length} candidate path(s).`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: {
+                inspectedPaths,
+                impactedInterfaces,
+                schemaSurfaces,
+                policySurfaces,
+                planningScope: planningBrief.payload.inScope
+            }
+        });
+    }
+};
+const implementationIntakeAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "implementation-intake",
+        displayName: "Implementation Intake",
+        category: "implementation",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "context"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "build",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const implementationRequest = getWorkflowInput(stateSlice, "implementationRequest");
+        const designRecord = getWorkflowInput(stateSlice, "designRecord");
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!implementationRequest || !designRecord) {
+            throw new Error("implementation-proposal requires a validated implementation request and design record before runtime execution.");
+        }
+        return agentOutputSchema.parse({
+            summary: `Loaded implementation request from ${requestFile ?? ".agentops/requests/implementation.yaml"} with design record ${implementationRequest.designRecordRef}.`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: {
+                requestFile,
+                designRecordRef: implementationRequest.designRecordRef,
+                implementationGoal: implementationRequest.implementationGoal,
+                approvalMode: implementationRequest.approvalMode,
+                targetPaths: implementationRequest.targetPaths,
+                validationCommands: implementationRequest.validationCommands,
+                designDecisionSummary: designRecord.payload.decisionSummary
+            }
+        });
+    }
+};
+const qaIntakeAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "qa-intake",
+        displayName: "QA Intake",
+        category: "qa",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: [".agentops/requests/**", ".agentops/runs/**"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "context"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "test",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const qaRequest = getWorkflowInput(stateSlice, "qaRequest");
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!qaRequest) {
+            throw new Error("qa-review requires a validated QA request before runtime execution.");
+        }
+        const targetType = qaRequest.targetRef.endsWith("bundle.json")
+            ? "artifact-bundle"
+            : qaRequest.targetRef.endsWith(".xml") || qaRequest.targetRef.endsWith(".json") || qaRequest.targetRef.endsWith(".log")
+                ? "validation-output"
+                : "local-reference";
+        return agentOutputSchema.parse({
+            summary: `Loaded QA request from ${requestFile ?? ".agentops/requests/qa.yaml"} targeting ${qaRequest.targetRef}.`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: {
+                ...qaRequestSchema.parse({
+                    ...qaRequest,
+                    evidenceSources: [...new Set([qaRequest.targetRef, ...qaRequest.evidenceSources])]
+                }),
+                targetType
+            }
+        });
+    }
+};
+const implementationInventoryAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "implementation-inventory",
+        displayName: "Implementation Inventory",
+        category: "implementation",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "deterministic"
+        },
+        permissions: {
+            model: false,
+            network: false,
+            tools: [],
+            readPaths: ["**/*"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "changes"],
+        outputs: ["summary", "metadata"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "changes"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "build",
+            supportLevel: "internal",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ stateSlice }) {
+        const implementationRequest = getWorkflowInput(stateSlice, "implementationRequest");
+        const designRecord = getWorkflowInput(stateSlice, "designRecord");
+        if (!implementationRequest || !designRecord) {
+            throw new Error("implementation-proposal requires deterministic inventory inputs before proposal analysis.");
+        }
+        const repoRoot = stateSlice.repo?.root;
+        const packageManager = stateSlice.repo?.packageManager || "pnpm";
+        const candidatePaths = [
+            ...new Set([
+                ...implementationRequest.targetPaths,
+                ...designRecord.payload.interfacesImpacted,
+                ...designRecord.payload.schemaChangesNeeded,
+                ...designRecord.payload.policyChangesNeeded
+            ])
+        ];
+        const resolvedAffectedPaths = candidatePaths.filter((pathValue) => {
+            if (!pathValue) {
+                return false;
+            }
+            if (!repoRoot) {
+                return true;
+            }
+            return existsSync(join(repoRoot, pathValue));
+        });
+        const affectedPackages = [...new Set(resolvedAffectedPaths.map(derivePackageScope).filter((value) => Boolean(value)))];
+        const entrypoints = [
+            ...new Set(resolvedAffectedPaths.filter((pathValue) => pathValue.endsWith("src/index.ts") || pathValue.endsWith("package.json") || pathValue.endsWith("agent.manifest.json")))
+        ];
+        const schemaSurfaces = [...new Set(resolvedAffectedPaths.filter((pathValue) => pathValue.includes("schema")))];
+        const policySurfaces = [
+            ...new Set(resolvedAffectedPaths.filter((pathValue) => pathValue.includes("policy") || pathValue.includes(".agentops/policy.yaml")))
+        ];
+        const discoveredValidationCommands = [];
+        const registerScripts = (packageJsonPath, source, packageName) => {
+            const scripts = parsePackageScripts(packageJsonPath);
+            for (const scriptName of Object.keys(scripts)) {
+                const command = buildValidationCommand(packageManager, scriptName, packageName);
+                discoveredValidationCommands.push({
+                    command,
+                    source,
+                    classification: allowedValidationScriptNames.has(scriptName) ? "approval_required" : "deny",
+                    reason: allowedValidationScriptNames.has(scriptName)
+                        ? "Discovered from a bounded repository script; execution would still require approval."
+                        : "Command is not in the bounded allowlist for implementation validation."
+                });
+            }
+        };
+        if (repoRoot) {
+            registerScripts(join(repoRoot, "package.json"), "package-script");
+            for (const packageScope of affectedPackages) {
+                const packageJsonPath = join(repoRoot, packageScope, "package.json");
+                if (!existsSync(packageJsonPath)) {
+                    continue;
+                }
+                const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+                const packageName = isRecord(parsed) && typeof parsed.name === "string" ? parsed.name : packageScope;
+                registerScripts(packageJsonPath, "workspace-script", packageName);
+            }
+        }
+        const normalizedRequestedCommands = implementationRequest.validationCommands.map(normalizeRequestedCommand);
+        const allowlistedCommands = new Set(discoveredValidationCommands
+            .filter((entry) => entry.classification === "approval_required")
+            .map((entry) => entry.command));
+        for (const requestedCommand of normalizedRequestedCommands) {
+            if (!allowlistedCommands.has(requestedCommand)) {
+                throw new Error(`Implementation request contains non-allowlisted validation command: ${requestedCommand}`);
+            }
+            discoveredValidationCommands.push({
+                command: requestedCommand,
+                source: "request",
+                classification: "approval_required",
+                reason: "Requested command matches a discovered allowlisted validation script."
+            });
+        }
+        const inventory = implementationInventorySchema.parse({
+            requestedTargetPaths: implementationRequest.targetPaths,
+            resolvedAffectedPaths,
+            affectedPackages,
+            entrypoints,
+            schemaSurfaces,
+            policySurfaces,
+            discoveredValidationCommands
+        });
+        return agentOutputSchema.parse({
+            summary: `Collected deterministic implementation inventory across ${inventory.resolvedAffectedPaths.length} path(s) and ${inventory.discoveredValidationCommands.length} validation command(s).`,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [],
+            requestedTools: [],
+            blockedActionFlags: [],
+            metadata: inventory
+        });
+    }
+};
+const implementationPlannerAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "implementation-planner",
+        displayName: "Implementation Planner",
+        category: "implementation",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "reasoning"
+        },
+        permissions: {
+            model: true,
+            network: false,
+            tools: [],
+            readPaths: ["**/*"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "changes", "agentResults"],
+        outputs: ["lifecycleArtifacts"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "changes", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "build",
+            supportLevel: "official",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ state, stateSlice }) {
+        const implementationRequest = getWorkflowInput(stateSlice, "implementationRequest");
+        const designRecord = getWorkflowInput(stateSlice, "designRecord");
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!implementationRequest || !designRecord) {
+            throw new Error("implementation-proposal requires validated implementation inputs before proposal analysis.");
+        }
+        const inventoryMetadata = implementationInventorySchema.safeParse(stateSlice.agentResults?.inventory?.metadata);
+        const inventory = inventoryMetadata.success ? inventoryMetadata.data : undefined;
+        const normalizedAffectedPaths = inventory && inventory.resolvedAffectedPaths.length > 0
+            ? inventory.resolvedAffectedPaths
+            : [
+                ...new Set([
+                    ...implementationRequest.targetPaths,
+                    ...designRecord.payload.interfacesImpacted,
+                    ...designRecord.payload.schemaChangesNeeded,
+                    ...designRecord.payload.policyChangesNeeded
+                ])
+            ];
+        const finalAffectedPaths = normalizedAffectedPaths.length > 0
+            ? normalizedAffectedPaths
+            : ["Repository paths still need deterministic build-surface confirmation."];
+        const proposedChanges = [
+            `Prepare a bounded implementation plan for ${implementationRequest.implementationGoal}.`,
+            ...finalAffectedPaths.slice(0, 5).map((pathValue) => `Plan targeted edits for ${pathValue}.`)
+        ];
+        const selectedCommands = inventory
+            ? inventory.discoveredValidationCommands.filter((entry) => entry.classification === "approval_required" &&
+                (implementationRequest.validationCommands.length === 0 || entry.source === "request"))
+            : [];
+        const validationPlan = selectedCommands.length > 0
+            ? selectedCommands.map((entry) => `Command \`${entry.command}\` is available but approval-required before execution.`)
+            : ["Confirm allowlisted validation commands in the next deterministic implementation slice before execution."];
+        const approvalRequiredSteps = implementationRequest.approvalMode === "apply-capable"
+            ? [
+                "Any future patch application requires explicit approval before execution.",
+                "Any future build or validation execution requires approval after allowlist review."
+            ]
+            : ["The default path remains proposal-only; any patch or build execution requires a separate approved workflow."];
+        const risks = [
+            ...(implementationRequest.targetPaths.length === 0
+                ? ["Target paths were not supplied, so affected surfaces may still broaden after deterministic discovery."]
+                : []),
+            ...(implementationRequest.validationCommands.length === 0
+                ? ["Validation commands are not yet specified and will need deterministic allowlist confirmation later."]
+                : [])
+        ];
+        const openQuestions = [
+            ...(implementationRequest.constraints.length === 0
+                ? ["Which additional implementation constraints should be captured before execution work begins?"]
+                : []),
+            ...(designRecord.payload.policyChangesNeeded.length > 0
+                ? ["Do the policy surfaces identified in the design record require a separate approval review?"]
+                : [])
+        ];
+        const summary = `Implementation proposal prepared for ${implementationRequest.implementationGoal}.`;
+        const implementationProposal = implementationArtifactSchema.parse({
+            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/implementation.yaml", implementationRequest.designRecordRef], designRecord.source.issueRefs),
+            artifactKind: "implementation-proposal",
+            lifecycleDomain: "build",
+            workflow: {
+                name: state.workflow,
+                displayName: "Implementation Proposal"
+            },
+            payload: {
+                designRecordRef: implementationRequest.designRecordRef,
+                implementationGoal: implementationRequest.implementationGoal,
+                affectedPaths: finalAffectedPaths,
+                proposedChanges,
+                validationPlan,
+                approvalRequiredSteps,
+                risks,
+                openQuestions
+            }
+        });
+        return agentOutputSchema.parse({
+            summary,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [implementationProposal],
+            requestedTools: [],
+            blockedActionFlags: [],
+            confidence: 0.76,
+            metadata: {
+                deterministicInputs: {
+                    targetPaths: implementationRequest.targetPaths,
+                    validationCommands: implementationRequest.validationCommands,
+                    constraints: implementationRequest.constraints,
+                    designInterfaces: designRecord.payload.interfacesImpacted,
+                    inventory: inventory ?? null
+                },
+                synthesizedProposal: {
+                    affectedPaths: finalAffectedPaths,
+                    approvalRequiredSteps,
+                    openQuestions
+                }
+            }
+        });
+    }
+};
+const designAnalystAgent = {
+    manifest: agentManifestSchema.parse({
+        version: 1,
+        name: "design-analyst",
+        displayName: "Design Analyst",
+        category: "design",
+        runtime: {
+            minVersion: "0.1.0",
+            kind: "reasoning"
+        },
+        permissions: {
+            model: true,
+            network: false,
+            tools: [],
+            readPaths: ["**/*"],
+            writePaths: []
+        },
+        inputs: ["workflowInputs", "repo", "changes", "agentResults"],
+        outputs: ["lifecycleArtifacts"],
+        contextPolicy: {
+            sections: ["workflowInputs", "repo", "changes", "agentResults"],
+            minimalContext: true
+        },
+        catalog: {
+            domain: "design",
+            supportLevel: "official",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
+        trust: {
+            tier: "core",
+            source: "official",
+            reviewed: true
+        }
+    }),
+    outputSchema: agentOutputSchema,
+    async execute({ state, stateSlice }) {
+        const designRequest = getWorkflowInput(stateSlice, "designRequest");
+        const planningBrief = getWorkflowInput(stateSlice, "planningBrief");
+        const requestFile = getWorkflowInput(stateSlice, "requestFile");
+        if (!designRequest || !planningBrief) {
+            throw new Error("architecture-design-review requires validated design inputs before design analysis.");
+        }
+        const inventoryMetadata = isRecord(stateSlice.agentResults?.inventory?.metadata) ? stateSlice.agentResults.inventory.metadata : {};
+        const impactedInterfaces = asStringArray(inventoryMetadata.impactedInterfaces);
+        const schemaSurfaces = asStringArray(inventoryMetadata.schemaSurfaces);
+        const policySurfaces = asStringArray(inventoryMetadata.policySurfaces);
+        const optionsConsidered = designRequest.alternatives.length > 0
+            ? designRequest.alternatives.map((option) => ({
+                option,
+                summary: `Evaluate ${option} against the validated planning brief and bounded repository inventory.`
+            }))
+            : [
+                {
+                    option: "single-workflow-pass",
+                    summary: "Keep the workflow narrow by validating intake, inventory, and design analysis in one local pass."
+                },
+                {
+                    option: "split-manual-design-doc",
+                    summary: "Rely on ad hoc notes outside the workflow and treat design as manual-only."
+                }
+            ];
+        const chosenApproach = optionsConsidered[0]?.option ?? "single-workflow-pass";
+        const followUpWork = [
+            "Translate the accepted design into bounded implementation issues before coding begins.",
+            "Use the deterministic inventory to drive follow-up schema, policy, or interface validation.",
+            "Keep the planning brief and design record linked when implementation and QA workflows land."
+        ];
+        const summary = `Design record prepared for ${designRequest.decisionTarget}.`;
+        const designRecord = designArtifactSchema.parse({
+            ...buildArtifactEnvelopeBase(state, summary, [requestFile ?? ".agentops/requests/design.yaml", designRequest.planningBriefRef], planningBrief.source.issueRefs),
+            artifactKind: "design-record",
+            lifecycleDomain: "design",
+            workflow: {
+                name: state.workflow,
+                displayName: "Architecture And Design Review"
+            },
+            payload: {
+                decisionSummary: designRequest.decisionTarget,
+                context: `Planning brief summary: ${planningBrief.summary}`,
+                optionsConsidered,
+                chosenApproach,
+                tradeOffs: [
+                    "Keeping the workflow local-first limits external specification ingestion in the MVP.",
+                    "Deterministic inventory remains heuristic until deeper static-analysis surfaces land."
+                ],
+                risks: [
+                    ...(impactedInterfaces.length === 0 ? ["No impacted interfaces were identified from the provided path hints."] : []),
+                    ...(schemaSurfaces.length === 0 ? ["Schema touch points may still need manual confirmation."] : [])
+                ],
+                followUpWork,
+                interfacesImpacted: impactedInterfaces,
+                schemaChangesNeeded: schemaSurfaces,
+                policyChangesNeeded: policySurfaces,
+                migrationNotes: [],
+                compatibilityNotes: ["Requires a valid planning-brief bundle reference from planning-discovery."]
+            }
+        });
+        return agentOutputSchema.parse({
+            summary,
+            findings: [],
+            proposedActions: [],
+            lifecycleArtifacts: [designRecord],
+            requestedTools: [],
+            blockedActionFlags: [],
+            confidence: 0.78,
+            metadata: {
+                deterministicInventory: {
+                    impactedInterfaces,
+                    schemaSurfaces,
+                    policySurfaces
+                },
+                synthesizedDecision: {
+                    chosenApproach,
+                    followUpWork
+                }
+            }
+        });
+    }
+};
 const codeReviewAgent = {
     manifest: agentManifestSchema.parse({
         version: 1,
@@ -72,6 +1003,12 @@ const codeReviewAgent = {
             sections: ["repo", "changes", "agentResults"],
             minimalContext: true
         },
+        catalog: {
+            domain: "review",
+            supportLevel: "official",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
         trust: {
             tier: "core",
             source: "official",
@@ -158,6 +1095,12 @@ const securityAuditAgent = {
             sections: ["repo", "changes", "policy"],
             minimalContext: true
         },
+        catalog: {
+            domain: "security",
+            supportLevel: "official",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
         trust: {
             tier: "core",
             source: "official",
@@ -222,6 +1165,12 @@ const testGenerationAgent = {
             sections: ["changes"],
             minimalContext: true
         },
+        catalog: {
+            domain: "test",
+            supportLevel: "official",
+            maturity: "mvp",
+            trustScope: "official-core-only"
+        },
         trust: {
             tier: "core",
             source: "official",
@@ -263,6 +1212,15 @@ const testGenerationAgent = {
 export function createBuiltinAgentRegistry() {
     return new Map([
         ["context-collector", contextCollectorAgent],
+        ["planning-intake", planningIntakeAgent],
+        ["planning-analyst", planningAnalystAgent],
+        ["design-intake", designIntakeAgent],
+        ["design-inventory", designInventoryAgent],
+        ["implementation-intake", implementationIntakeAgent],
+        ["qa-intake", qaIntakeAgent],
+        ["implementation-inventory", implementationInventoryAgent],
+        ["implementation-planner", implementationPlannerAgent],
+        ["design-analyst", designAnalystAgent],
         ["code-review", codeReviewAgent],
         ["security-audit", securityAuditAgent],
         ["test-generation", testGenerationAgent]