@codapult/guard 0.2.0 → 0.4.0

package/dist/core/history/runs.d.ts

@@ -0,0 +1,28 @@
+export declare const GUARD_RUNS_DIR: string;
+export interface GuardRunStage {
+    durationMs: number;
+    status: 'ok' | 'fail' | 'skipped';
+    detail?: string | undefined;
+}
+export interface GuardRunManifest {
+    version: 1;
+    runId: string;
+    command: string;
+    startedAt: string;
+    completedAt: string;
+    durationMs: number;
+    outcome: 'pass' | 'fail' | 'warning' | 'needs-review' | 'not-configured';
+    gate: string;
+    stages: Record<string, GuardRunStage>;
+    commit?: string | undefined;
+}
+export interface GuardRunContext {
+    runId: string;
+    startedAt: string;
+    startedAtMs: number;
+    stages: Record<string, GuardRunStage>;
+}
+export declare function startGuardRun(): GuardRunContext;
+export declare function recordGuardRunStage(context: GuardRunContext, name: string, status: GuardRunStage['status'], startedAtMs: number, detail?: string): void;
+export declare function writeGuardRun(root: string, manifest: GuardRunManifest): void;
+export declare function finishGuardRun(root: string, context: GuardRunContext, outcome: GuardRunManifest['outcome'], gate: string, command?: string): GuardRunManifest;

package/dist/core/history/runs.js

@@ -0,0 +1,59 @@
+import { randomUUID } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, renameSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { config } from '../config.js';
+export const GUARD_RUNS_DIR = `.${config.appName}/guard/history/runs`;
+export function startGuardRun() {
+    return {
+        runId: `guard-${randomUUID()}`,
+        startedAt: new Date().toISOString(),
+        startedAtMs: Date.now(),
+        stages: {},
+    };
+}
+export function recordGuardRunStage(context, name, status, startedAtMs, detail) {
+    context.stages[name] = {
+        durationMs: Math.max(0, Date.now() - startedAtMs),
+        status,
+        ...(detail ? { detail } : {}),
+    };
+}
+export function writeGuardRun(root, manifest) {
+    const directory = resolve(root, GUARD_RUNS_DIR);
+    mkdirSync(directory, { recursive: true });
+    const path = resolve(directory, `${manifest.runId}.json`);
+    const temporaryPath = `${path}.tmp-${process.pid}-${manifest.runId}`;
+    writeFileSync(temporaryPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    renameSync(temporaryPath, path);
+}
+export function finishGuardRun(root, context, outcome, gate, command = 'verify') {
+    let commit;
+    try {
+        commit = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: root, stdio: 'pipe' })
+            .toString()
+            .trim();
+    }
+    catch {
+        commit = undefined;
+    }
+    const manifest = {
+        version: 1,
+        runId: context.runId,
+        command,
+        startedAt: context.startedAt,
+        completedAt: new Date().toISOString(),
+        durationMs: Math.max(0, Date.now() - context.startedAtMs),
+        outcome,
+        gate,
+        stages: context.stages,
+        ...(commit ? { commit } : {}),
+    };
+    try {
+        writeGuardRun(root, manifest);
+    }
+    catch {
+        // Verification must not fail because its local diagnostic record cannot be written.
+    }
+    return manifest;
+}

package/dist/core/model/types.d.ts

@@ -0,0 +1,10 @@
+/** Shared domain vocabulary used by Guard core and its adapters. */
+export type GuardSeverity = 'error' | 'warning' | 'info';
+export type GuardRuleKind = 'forbidden-import' | 'client-forbidden-import';
+export type GuardRuleStatus = 'active' | 'proposed';
+export type GuardContractKind = 'guidance' | 'import-boundary' | 'required-call' | 'package-boundary';
+export type GuardBudgetMetric = 'lines' | 'bytes' | 'imports';
+export type GuardToolMode = 'auto' | 'on' | 'off';
+export type GuardApprovalMode = 'local' | 'protected';
+export type GuardAdapterName = 'dependency-graph' | 'security' | 'dependency-hygiene';
+export type ProjectCheck = 'lint' | 'typecheck' | 'test' | 'build';

package/dist/core/model/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/policy/schemas.d.ts

@@ -1,4 +1,26 @@
 import { z } from 'zod';
+export declare const guardBudgetSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    metric: z.ZodEnum<{
+        bytes: "bytes";
+        imports: "imports";
+        lines: "lines";
+    }>;
+    scope: z.ZodArray<z.ZodString>;
+    limit: z.ZodNumber;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    reason: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        proposed: "proposed";
+    }>>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare const guardRuleSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
@@ -30,6 +52,7 @@ export declare const guardContractSchema: z.ZodObject<{
     kind: z.ZodOptional<z.ZodEnum<{
         guidance: "guidance";
         "import-boundary": "import-boundary";
+        "package-boundary": "package-boundary";
         "required-call": "required-call";
     }>>;
     severity: z.ZodOptional<z.ZodEnum<{
@@ -45,6 +68,8 @@ export declare const guardContractSchema: z.ZodObject<{
     mustImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
     mustNotImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
     mustCall: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fromPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mustNotImportPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
     status: z.ZodOptional<z.ZodEnum<{
         active: "active";
         proposed: "proposed";
@@ -58,6 +83,8 @@ export declare const guardContractSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const guardConfigSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
+    revision: z.ZodOptional<z.ZodNumber>;
+    contentFingerprint: z.ZodOptional<z.ZodString>;
     rules: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
@@ -89,6 +116,7 @@ export declare const guardConfigSchema: z.ZodObject<{
         kind: z.ZodOptional<z.ZodEnum<{
             guidance: "guidance";
             "import-boundary": "import-boundary";
+            "package-boundary": "package-boundary";
             "required-call": "required-call";
         }>>;
         severity: z.ZodOptional<z.ZodEnum<{
@@ -104,6 +132,8 @@ export declare const guardConfigSchema: z.ZodObject<{
         mustImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mustNotImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mustCall: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fromPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustNotImportPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
         status: z.ZodOptional<z.ZodEnum<{
             active: "active";
             proposed: "proposed";
@@ -115,6 +145,36 @@ export declare const guardConfigSchema: z.ZodObject<{
         }>>;
         evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
+    budgets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        metric: z.ZodEnum<{
+            bytes: "bytes";
+            imports: "imports";
+            lines: "lines";
+        }>;
+        scope: z.ZodArray<z.ZodString>;
+        limit: z.ZodNumber;
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        reason: z.ZodString;
+        status: z.ZodOptional<z.ZodEnum<{
+            active: "active";
+            proposed: "proposed";
+        }>>;
+        evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            local: "local";
+            protected: "protected";
+        }>;
+        allowMcpApproval: z.ZodBoolean;
+        requireDistinctActor: z.ZodBoolean;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const guardContractsFileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -124,6 +184,7 @@ export declare const guardContractsFileSchema: z.ZodObject<{
         kind: z.ZodOptional<z.ZodEnum<{
             guidance: "guidance";
             "import-boundary": "import-boundary";
+            "package-boundary": "package-boundary";
             "required-call": "required-call";
         }>>;
         severity: z.ZodOptional<z.ZodEnum<{
@@ -139,6 +200,8 @@ export declare const guardContractsFileSchema: z.ZodObject<{
         mustImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mustNotImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mustCall: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fromPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustNotImportPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
         status: z.ZodOptional<z.ZodEnum<{
             active: "active";
             proposed: "proposed";
@@ -165,10 +228,18 @@ export declare const guardProposalDecisionSchema: z.ZodObject<{
     proposalId: z.ZodOptional<z.ZodString>;
     proposalFingerprint: z.ZodOptional<z.ZodString>;
     revision: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodEnum<{
+        cli: "cli";
+        external: "external";
+        mcp: "mcp";
+    }>>;
+    actor: z.ZodOptional<z.ZodString>;
+    commit: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const guardProposalSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     generatedAt: z.ZodString;
+    generatedBy: z.ZodOptional<z.ZodString>;
     proposalId: z.ZodOptional<z.ZodString>;
     projectFingerprint: z.ZodOptional<z.ZodString>;
     revision: z.ZodOptional<z.ZodNumber>;
@@ -204,6 +275,7 @@ export declare const guardProposalSchema: z.ZodObject<{
         kind: z.ZodOptional<z.ZodEnum<{
             guidance: "guidance";
             "import-boundary": "import-boundary";
+            "package-boundary": "package-boundary";
             "required-call": "required-call";
         }>>;
         severity: z.ZodOptional<z.ZodEnum<{
@@ -219,6 +291,8 @@ export declare const guardProposalSchema: z.ZodObject<{
         mustImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mustNotImport: z.ZodOptional<z.ZodArray<z.ZodString>>;
         mustCall: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fromPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mustNotImportPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
         status: z.ZodOptional<z.ZodEnum<{
             active: "active";
             proposed: "proposed";
@@ -245,6 +319,13 @@ export declare const guardProposalSchema: z.ZodObject<{
         proposalId: z.ZodOptional<z.ZodString>;
         proposalFingerprint: z.ZodOptional<z.ZodString>;
         revision: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodEnum<{
+            cli: "cli";
+            external: "external";
+            mcp: "mcp";
+        }>>;
+        actor: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export declare const guardAgentConfigSchema: z.ZodObject<{

package/dist/core/policy/schemas.js

@@ -1,55 +1,82 @@
 import { z } from 'zod';
 const severity = z.enum(['error', 'warning', 'info']);
 const status = z.enum(['active', 'proposed']);
+export const guardBudgetSchema = z.object({
+    id: z.string().trim().min(1),
+    description: z.string().trim().min(1),
+    metric: z.enum(['lines', 'bytes', 'imports']),
+    scope: z.array(z.string().trim().min(1)).min(1),
+    limit: z.number().int().positive(),
+    severity,
+    reason: z.string().trim().min(1),
+    status: status.optional(),
+    evidence: z.array(z.string()).optional(),
+});
 export const guardRuleSchema = z.object({
-    id: z.string(),
-    description: z.string(),
+    id: z.string().trim().min(1),
+    description: z.string().trim().min(1),
     severity,
     kind: z.enum(['forbidden-import', 'client-forbidden-import']),
-    patterns: z.array(z.string()),
-    files: z.array(z.string()).optional(),
+    patterns: z.array(z.string().trim().min(1)).min(1),
+    files: z.array(z.string().trim().min(1)).optional(),
     status: status.optional(),
     confidence: z.enum(['high', 'medium', 'low']).optional(),
     evidence: z.array(z.string()).optional(),
 });
 export const guardContractSchema = z.object({
-    id: z.string(),
-    statement: z.string(),
-    kind: z.enum(['guidance', 'import-boundary', 'required-call']).optional(),
+    id: z.string().trim().min(1),
+    statement: z.string().trim().min(1),
+    kind: z.enum(['guidance', 'import-boundary', 'required-call', 'package-boundary']).optional(),
     severity: severity.optional(),
-    scope: z.array(z.string()).optional(),
-    entrypoints: z.array(z.string()).optional(),
-    exclude: z.array(z.string()).optional(),
-    guidance: z.array(z.string()).optional(),
-    references: z.array(z.string()).optional(),
-    mustImport: z.array(z.string()).optional(),
-    mustNotImport: z.array(z.string()).optional(),
-    mustCall: z.array(z.string()).optional(),
+    scope: z.array(z.string().trim().min(1)).optional(),
+    entrypoints: z.array(z.string().trim().min(1)).optional(),
+    exclude: z.array(z.string().trim().min(1)).optional(),
+    guidance: z.array(z.string().trim().min(1)).optional(),
+    references: z.array(z.string().trim().min(1)).optional(),
+    mustImport: z.array(z.string().trim().min(1)).optional(),
+    mustNotImport: z.array(z.string().trim().min(1)).optional(),
+    mustCall: z.array(z.string().trim().min(1)).optional(),
+    fromPackages: z.array(z.string().trim().min(1)).optional(),
+    mustNotImportPackages: z.array(z.string().trim().min(1)).optional(),
     status: status.optional(),
     confidence: z.enum(['high', 'medium', 'low']).optional(),
     evidence: z.array(z.string()).optional(),
 });
 export const guardConfigSchema = z.object({
     version: z.literal(1),
+    revision: z.number().int().nonnegative().optional(),
+    contentFingerprint: z.string().optional(),
     rules: z.array(guardRuleSchema),
     contracts: z.array(guardContractSchema).optional(),
+    budgets: z.array(guardBudgetSchema).optional(),
+    approval: z
+        .object({
+        mode: z.enum(['local', 'protected']),
+        allowMcpApproval: z.boolean(),
+        requireDistinctActor: z.boolean(),
+    })
+        .optional(),
 });
 export const guardContractsFileSchema = z.object({
     version: z.literal(1),
     contracts: z.array(guardContractSchema),
 });
 export const guardProposalDecisionSchema = z.object({
-    id: z.string(),
+    id: z.string().trim().min(1),
     type: z.enum(['rule', 'contract']),
     decision: z.enum(['approved', 'rejected']),
     decidedAt: z.string(),
     proposalId: z.string().optional(),
     proposalFingerprint: z.string().optional(),
     revision: z.number().optional(),
+    source: z.enum(['cli', 'mcp', 'external']).optional(),
+    actor: z.string().optional(),
+    commit: z.string().optional(),
 });
 export const guardProposalSchema = z.object({
     version: z.literal(1),
     generatedAt: z.string(),
+    generatedBy: z.string().trim().min(1).optional(),
     proposalId: z.string().optional(),
     projectFingerprint: z.string().optional(),
     revision: z.number().int().positive().optional(),
@@ -62,7 +89,9 @@ export const guardProposalSchema = z.object({
 export const guardAgentConfigSchema = z.object({
     version: z.literal(1),
     tools: z.enum(['auto', 'on', 'off']),
-    tooling: z.record(z.string(), z.object({ script: z.string(), enabled: z.boolean() })).default({}),
+    tooling: z
+        .record(z.string().trim().min(1), z.object({ script: z.string().trim().min(1), enabled: z.boolean() }))
+        .default({}),
     completionGate: z.object({
         enabled: z.boolean(),
         maxIterations: z.number().int().min(1).max(10),

package/dist/core/verification/verify.d.ts

@@ -1,29 +1,38 @@
 import { type CommandResult } from '../../adapters/command.js';
-import { type GuardAdapter, type ProjectCheck, type ProjectCheckResults, type ProjectRuntimeDiagnostics } from '../../adapters/project-checks.js';
+import type { ProjectCheck } from '../model/types.js';
+import { type GuardAdapter, type ProjectCheckResults, type ProjectRuntimeDiagnostics } from '../../adapters/project-checks.js';
 import { type GuardToolMode, type GuardContractIssue, type GuardReport } from '../guard.js';
+import { type GuardImpactAnalysis } from '../analysis/impact.js';
+import { type GuardRunManifest } from '../history/runs.js';
 export type GuardVerificationCheck = ProjectCheck;
+export interface GuardVerificationOptions {
+    checks?: GuardVerificationCheck[] | undefined;
+    changedOnly?: boolean | undefined;
+    timeout?: number | undefined;
+    requirement?: string | undefined;
+    tools?: GuardToolMode | undefined;
+    strict?: boolean | undefined;
+    projectChecks?: boolean | undefined;
+}
 export interface GuardVerificationResult {
     status: 'ok' | 'fail' | 'not-configured';
     outcome: 'pass' | 'fail' | 'warning' | 'needs-review' | 'not-configured';
-    tools?: GuardToolMode;
+    errorCode?: 'GUARD_NOT_CONFIGURED' | 'GUARD_CONFIG_INVALID' | undefined;
+    recoverable?: boolean | undefined;
+    tools?: GuardToolMode | undefined;
     checks: ProjectCheckResults;
     workspaceChecks: Record<string, ProjectCheckResults>;
     adapters: Partial<Record<GuardAdapter, CommandResult>>;
     runtime: ProjectRuntimeDiagnostics;
-    architecture?: GuardReport;
+    configError?: string | undefined;
+    architecture?: GuardReport | undefined;
+    impact?: GuardImpactAnalysis | undefined;
     contractIssues: GuardContractIssue[];
     requirement: {
         status: 'delegated-to-review';
         provided: boolean;
         message: string;
     };
+    run: GuardRunManifest;
 }
-export declare function runGuardVerification(root: string, options?: {
-    checks?: GuardVerificationCheck[];
-    changedOnly?: boolean;
-    timeout?: number;
-    requirement?: string;
-    tools?: GuardToolMode;
-    strict?: boolean;
-    projectChecks?: boolean;
-}): GuardVerificationResult;
+export declare function runGuardVerification(root: string, options?: GuardVerificationOptions): GuardVerificationResult;

package/dist/core/verification/verify.js

@@ -1,8 +1,11 @@
+import {} from '../../adapters/command.js';
 import { runProjectAdapters, runProjectChecks, runWorkspaceProjectChecks, inspectProjectRuntime, } from '../../adapters/project-checks.js';
-import { loadBaseline, loadGuardAgentConfig, loadGuardConfig, scanGuard, classifyGuardOutcome, validateGuardContracts, } from '../guard.js';
+import { loadBaseline, loadGuardAgentConfig, loadGuardConfig, scanGuard, classifyGuardOutcome, validateGuardPolicy, } from '../guard.js';
+import { analyzeProjectImpact } from '../analysis/impact.js';
 import { discoverProject } from '../discovery/discovery.js';
+import { finishGuardRun, recordGuardRunStage, startGuardRun, } from '../history/runs.js';
 export function runGuardVerification(root, options = {}) {
-    const config = loadGuardConfig(root);
+    const runContext = startGuardRun();
     const requirement = {
         status: 'delegated-to-review',
         provided: Boolean(options.requirement?.trim()),
@@ -10,28 +13,64 @@ export function runGuardVerification(root, options = {}) {
             ? 'Requirement text is included in semantic review input; deterministic verify does not judge natural-language acceptance criteria.'
             : 'Requirement satisfaction is evaluated by guard review using the task and diff.',
     };
+    const runtimeStartedAt = Date.now();
     const runtime = inspectProjectRuntime(root);
-    if (!config)
+    recordGuardRunStage(runContext, 'runtime', 'ok', runtimeStartedAt);
+    let config;
+    try {
+        config = loadGuardConfig(root);
+    }
+    catch (error) {
+        const run = finishGuardRun(root, runContext, 'fail', 'configuration');
+        return {
+            status: 'fail',
+            outcome: 'fail',
+            errorCode: 'GUARD_CONFIG_INVALID',
+            recoverable: true,
+            checks: {},
+            workspaceChecks: {},
+            adapters: {},
+            runtime,
+            configError: error instanceof Error ? error.message : String(error),
+            contractIssues: [],
+            requirement,
+            run,
+        };
+    }
+    if (!config) {
+        const run = finishGuardRun(root, runContext, 'not-configured', 'configuration');
         return {
             status: 'not-configured',
             outcome: 'not-configured',
+            errorCode: 'GUARD_NOT_CONFIGURED',
+            recoverable: true,
             checks: {},
             workspaceChecks: {},
             adapters: {},
             runtime,
             contractIssues: [],
             requirement,
+            run,
         };
+    }
     const agentConfig = loadGuardAgentConfig(root);
     const projectChecks = options.projectChecks ?? agentConfig.completionGate.projectChecks;
     const checks = projectChecks ? (options.checks ?? agentConfig.completionGate.checks) : [];
+    const checksStartedAt = Date.now();
     const results = runProjectChecks(root, checks, { timeout: options.timeout });
+    recordGuardRunStage(runContext, 'project-checks', projectChecks ? 'ok' : 'skipped', checksStartedAt);
+    const discoveryStartedAt = Date.now();
     const workspaceModel = discoverProject(root);
+    const impact = analyzeProjectImpact(workspaceModel, options.changedOnly === false
+        ? workspaceModel.modules.map((module) => module.path)
+        : workspaceModel.git.changedFiles, config.contracts ?? []);
     const workspaceChecks = runWorkspaceProjectChecks(root, workspaceModel.project.workspacePackages ?? [], checks, {
         timeout: options.timeout,
         rootResults: results,
     });
+    recordGuardRunStage(runContext, 'discovery-impact', 'ok', discoveryStartedAt);
     const toolMode = options.tools ?? agentConfig.tools;
+    const adaptersStartedAt = Date.now();
     const adapters = toolMode === 'off'
         ? {}
         : runProjectAdapters(root, {
@@ -39,12 +78,15 @@ export function runGuardVerification(root, options = {}) {
             timeout: options.timeout,
             tooling: agentConfig.tooling,
         });
+    recordGuardRunStage(runContext, 'adapters', toolMode === 'off' ? 'skipped' : 'ok', adaptersStartedAt);
+    const architectureStartedAt = Date.now();
     const architecture = scanGuard(root, config, {
         changedOnly: options.changedOnly,
         baseline: loadBaseline(root),
         includeArchitectureInsights: true,
     });
-    const contractIssues = validateGuardContracts(root, config.contracts ?? []);
+    const contractIssues = validateGuardPolicy(root, config);
+    recordGuardRunStage(runContext, 'architecture-policy', 'ok', architectureStartedAt);
     const commandFailed = Object.values(results).some((result) => result.status === 'failed');
     const workspaceCommandFailed = Object.values(workspaceChecks).some((packageResults) => Object.values(packageResults).some((result) => result.status === 'failed'));
     const adapterFailed = Object.values(adapters).some((result) => result.status === 'failed');
@@ -59,19 +101,50 @@ export function runGuardVerification(root, options = {}) {
         architectureFailed ||
         contractIssues.length > 0 ||
         missingRequiredTools;
+    const projectChecksFailed = commandFailed || workspaceCommandFailed || (projectChecks && !runtime.compatible);
+    const adaptersFailed = adapterFailed || missingRequiredTools;
+    runContext.stages['project-checks'] = {
+        ...runContext.stages['project-checks'],
+        status: projectChecks ? (projectChecksFailed ? 'fail' : 'ok') : 'skipped',
+    };
+    runContext.stages.adapters = {
+        ...runContext.stages.adapters,
+        status: toolMode === 'off' ? 'skipped' : adaptersFailed ? 'fail' : 'ok',
+    };
+    runContext.stages['architecture-policy'] = {
+        ...runContext.stages['architecture-policy'],
+        status: architectureFailed || contractIssues.length > 0 ? 'fail' : 'ok',
+    };
+    const outcome = classifyGuardOutcome({
+        errors: failed ? 1 : 0,
+        warnings: architectureWarnings ? 1 : 0,
+    });
+    const gate = architectureFailed
+        ? 'architecture'
+        : contractIssues.length > 0
+            ? 'contracts'
+            : commandFailed || workspaceCommandFailed
+                ? 'project-checks'
+                : adapterFailed
+                    ? 'adapters'
+                    : missingRequiredTools
+                        ? 'required-tools'
+                        : !runtime.compatible && projectChecks
+                            ? 'runtime'
+                            : 'none';
+    const run = finishGuardRun(root, runContext, outcome, gate);
     return {
         status: failed ? 'fail' : 'ok',
-        outcome: classifyGuardOutcome({
-            errors: failed ? 1 : 0,
-            warnings: architectureWarnings ? 1 : 0,
-        }),
+        outcome,
         tools: toolMode,
         checks: results,
         workspaceChecks,
         adapters,
         runtime,
         architecture,
+        impact,
         contractIssues,
         requirement,
+        run,
     };
 }

package/dist/index.d.ts

@@ -1,9 +1,12 @@
 /** Public, framework-agnostic Guard API. */
+export * from './core/model/types.js';
 export * from './core/guard.js';
+export * from './core/errors.js';
 export * from './core/discovery/discovery.js';
 export { runGuardVerification } from './core/verification/verify.js';
 export type { GuardVerificationCheck, GuardVerificationResult, } from './core/verification/verify.js';
 export * from './core/history/history.js';
+export * from './core/history/runs.js';
 export * from './core/output/sarif.js';
 export * from './core/analysis/doctor.js';
 export * from './core/analysis/packs.js';

package/dist/index.js

@@ -1,8 +1,11 @@
 /** Public, framework-agnostic Guard API. */
+export * from './core/model/types.js';
 export * from './core/guard.js';
+export * from './core/errors.js';
 export * from './core/discovery/discovery.js';
 export { runGuardVerification } from './core/verification/verify.js';
 export * from './core/history/history.js';
+export * from './core/history/runs.js';
 export * from './core/output/sarif.js';
 export * from './core/analysis/doctor.js';
 export * from './core/analysis/packs.js';