@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/sdd/coordination/coordination-adapters.js

@@ -1,4 +1,8 @@
 import { withStateLock } from '../state-lock.js';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { createProjectFingerprint, ensureGlobalCacheLayout, getGlobalCacheDir } from '../../global-config.js';
 export class FileSystemLockAdapter {
     stateDir;
     constructor(stateDir) {
@@ -31,6 +35,131 @@ export class InMemoryCoordinationCache {
         this.entries.clear();
     }
 }
+export class MultiTierCoordinationCache {
+    l1Cache = new InMemoryCoordinationCache();
+    projectFingerprint;
+    configFingerprint;
+    namespace;
+    l2Root;
+    constructor(options) {
+        this.projectFingerprint = createProjectFingerprint(options.projectRoot);
+        this.configFingerprint = options.configFingerprint ?? 'default';
+        this.namespace = options.namespace ?? 'coordination';
+        this.l2Root = path.join(options.cacheRootDir ?? getGlobalCacheDir(), 'projects', this.projectFingerprint, this.namespace);
+    }
+    async get(key) {
+        const l1Value = await this.l1Cache.get(key);
+        if (typeof l1Value !== 'undefined') {
+            return l1Value;
+        }
+        const filePath = this.toEntryPath(key);
+        const diskEntry = await this.readEntry(filePath);
+        if (!diskEntry) {
+            return undefined;
+        }
+        const ttlMs = this.remainingTtlMs(diskEntry.expires_at);
+        if (ttlMs === 0) {
+            await this.safeUnlink(filePath);
+            return undefined;
+        }
+        await this.l1Cache.set(key, diskEntry.value, ttlMs > 0 ? { ttlMs } : {});
+        return diskEntry.value;
+    }
+    async set(key, value, options = {}) {
+        await this.l1Cache.set(key, value, options);
+        await fs.mkdir(this.l2Root, { recursive: true });
+        const entry = {
+            schema_version: 1,
+            key,
+            value,
+            created_at: new Date().toISOString(),
+            expires_at: options.ttlMs ? new Date(Date.now() + options.ttlMs).toISOString() : undefined,
+            project_fingerprint: this.projectFingerprint,
+            config_fingerprint: this.configFingerprint,
+            namespace: this.namespace,
+        };
+        await fs.writeFile(this.toEntryPath(key), JSON.stringify(entry), 'utf-8');
+    }
+    async delete(key) {
+        await this.l1Cache.delete(key);
+        await this.safeUnlink(this.toEntryPath(key));
+    }
+    async clear() {
+        await this.l1Cache.clear();
+        await fs.rm(this.l2Root, { recursive: true, force: true });
+    }
+    async pruneExpired() {
+        const files = await this.listEntryFiles();
+        let pruned = 0;
+        for (const filePath of files) {
+            const entry = await this.readEntry(filePath);
+            if (!entry) {
+                continue;
+            }
+            if (this.remainingTtlMs(entry.expires_at) === 0) {
+                await this.safeUnlink(filePath);
+                pruned += 1;
+            }
+        }
+        return pruned;
+    }
+    describeTierState() {
+        return {
+            root: this.l2Root,
+            projectFingerprint: this.projectFingerprint,
+            namespace: this.namespace,
+        };
+    }
+    toEntryPath(key) {
+        const hashedKey = createHash('sha256').update(key).digest('hex');
+        return path.join(this.l2Root, `${hashedKey}.json`);
+    }
+    remainingTtlMs(expiresAtIso) {
+        if (!expiresAtIso) {
+            return -1;
+        }
+        const expiresAt = Date.parse(expiresAtIso);
+        if (Number.isNaN(expiresAt)) {
+            return 0;
+        }
+        const remaining = expiresAt - Date.now();
+        return remaining > 0 ? remaining : 0;
+    }
+    async listEntryFiles() {
+        try {
+            const files = await fs.readdir(this.l2Root);
+            return files
+                .filter((fileName) => fileName.endsWith('.json'))
+                .map((fileName) => path.join(this.l2Root, fileName));
+        }
+        catch {
+            return [];
+        }
+    }
+    async readEntry(filePath) {
+        try {
+            const raw = await fs.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (parsed.schema_version !== 1 ||
+                parsed.project_fingerprint !== this.projectFingerprint ||
+                parsed.config_fingerprint !== this.configFingerprint) {
+                return undefined;
+            }
+            return parsed;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async safeUnlink(filePath) {
+        try {
+            await fs.unlink(filePath);
+        }
+        catch {
+            // best effort cleanup
+        }
+    }
+}
 export class InMemoryCoordinationQueue {
     topics = new Map();
     async enqueue(topic, item) {
@@ -68,9 +197,18 @@ export function resolveRedisBoundaryConfig(env = process.env) {
     };
 }
 export function createFilesystemFirstCoordinationAdapters(options) {
+    if (!options.cacheRootDir) {
+        ensureGlobalCacheLayout();
+    }
     const redis = resolveRedisBoundaryConfig(options.env);
+    const cache = new MultiTierCoordinationCache({
+        projectRoot: options.projectRoot ?? process.cwd(),
+        configFingerprint: options.configFingerprint,
+        cacheRootDir: options.cacheRootDir,
+    });
     return {
         mode: 'filesystem',
+        cacheTier: cache.describeTierState(),
         redis: {
             ...redis,
             status: redis.requested ? 'requested-unavailable' : 'disabled',
@@ -79,7 +217,7 @@ export function createFilesystemFirstCoordinationAdapters(options) {
                 : 'Redis is optional and disabled; filesystem-first defaults are authoritative.',
         },
         locks: new FileSystemLockAdapter(options.stateDir),
-        cache: new InMemoryCoordinationCache(),
+        cache,
         queues: new InMemoryCoordinationQueue(),
         events: new InMemoryCoordinationEventBus(),
     };

package/dist/core/sdd/deepagent-contracts.d.ts

@@ -0,0 +1,276 @@
+import { z } from 'zod';
+export declare const deepagentEnvContractSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"deepagent-env-contract/v1">;
+    runtime_mode: z.ZodDefault<z.ZodEnum<{
+        disabled: "disabled";
+        fake: "fake";
+        "deepagents-js": "deepagents-js";
+    }>>;
+    model_ref: z.ZodOptional<z.ZodString>;
+    planner_model_ref: z.ZodOptional<z.ZodString>;
+    reviewer_model_ref: z.ZodOptional<z.ZodString>;
+    coder_model_ref: z.ZodOptional<z.ZodString>;
+    execution_limits: z.ZodDefault<z.ZodObject<{
+        max_iterations: z.ZodOptional<z.ZodNumber>;
+        max_subagents: z.ZodOptional<z.ZodNumber>;
+        max_parallel: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    provider_profile: z.ZodOptional<z.ZodString>;
+    env_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    secret_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    credential_env_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    endpoint_env_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    sandbox_passthrough_rules: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    network_mode: z.ZodDefault<z.ZodEnum<{
+        disabled: "disabled";
+        restricted: "restricted";
+        enabled: "enabled";
+    }>>;
+    blocked_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    masked_config_fingerprint: z.ZodString;
+}, z.core.$strip>;
+export declare const deepagentRunRequestSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"deepagent-run-request/v1">;
+    provider: z.ZodLiteral<"deepagents">;
+    feature_ref: z.ZodString;
+    mode: z.ZodEnum<{
+        validate: "validate";
+        "read-only": "read-only";
+        plan: "plan";
+        "apply-sandbox": "apply-sandbox";
+        "apply-approved": "apply-approved";
+    }>;
+    objective: z.ZodString;
+    allowed_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    write_scope: z.ZodObject<{
+        allow_project_writes: z.ZodDefault<z.ZodBoolean>;
+        allowed_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    network_policy: z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            disabled: "disabled";
+            restricted: "restricted";
+            enabled: "enabled";
+        }>>;
+        allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    env_contract: z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        contract: z.ZodLiteral<"deepagent-env-contract/v1">;
+        runtime_mode: z.ZodDefault<z.ZodEnum<{
+            disabled: "disabled";
+            fake: "fake";
+            "deepagents-js": "deepagents-js";
+        }>>;
+        model_ref: z.ZodOptional<z.ZodString>;
+        planner_model_ref: z.ZodOptional<z.ZodString>;
+        reviewer_model_ref: z.ZodOptional<z.ZodString>;
+        coder_model_ref: z.ZodOptional<z.ZodString>;
+        execution_limits: z.ZodDefault<z.ZodObject<{
+            max_iterations: z.ZodOptional<z.ZodNumber>;
+            max_subagents: z.ZodOptional<z.ZodNumber>;
+            max_parallel: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        provider_profile: z.ZodOptional<z.ZodString>;
+        env_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        secret_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        credential_env_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        endpoint_env_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        sandbox_passthrough_rules: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        network_mode: z.ZodDefault<z.ZodEnum<{
+            disabled: "disabled";
+            restricted: "restricted";
+            enabled: "enabled";
+        }>>;
+        blocked_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        masked_config_fingerprint: z.ZodString;
+    }, z.core.$strip>;
+    skill_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    plugin_envelopes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        plugin_id: z.ZodString;
+        capability: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>>;
+    reversa_scope: z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        objective: z.ZodOptional<z.ZodString>;
+        targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    expected_evidence: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const deepagentRunPlanSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"deepagent-run-plan/v1">;
+    run_id: z.ZodString;
+    feature_ref: z.ZodString;
+    mode: z.ZodEnum<{
+        validate: "validate";
+        "read-only": "read-only";
+        plan: "plan";
+        "apply-sandbox": "apply-sandbox";
+        "apply-approved": "apply-approved";
+    }>;
+    tactical_steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        objective: z.ZodString;
+        subagent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    subagent_routing: z.ZodArray<z.ZodObject<{
+        subagent: z.ZodString;
+        purpose: z.ZodString;
+        task_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    required_approvals: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    expected_tool_calls: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    write_manifest_preview: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    validation_matrix: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        requirement: z.ZodString;
+        validation: z.ZodString;
+        evidence_kind: z.ZodString;
+    }, z.core.$strip>>>;
+    residual_risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        summary: z.ZodString;
+        mitigation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const deepagentToolCallEvidenceSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"deepagent-tool-call-evidence/v1">;
+    tool_name: z.ZodString;
+    input_hash: z.ZodString;
+    output_hash: z.ZodString;
+    state_access_class: z.ZodEnum<{
+        read: "read";
+        write: "write";
+        execute: "execute";
+        network: "network";
+    }>;
+    policy_gate: z.ZodString;
+    hitl_decision: z.ZodDefault<z.ZodEnum<{
+        edit: "edit";
+        none: "none";
+        approve: "approve";
+        reject: "reject";
+        respond: "respond";
+    }>>;
+    duration_ms: z.ZodNumber;
+    result: z.ZodEnum<{
+        error: "error";
+        blocked: "blocked";
+        ok: "ok";
+    }>;
+}, z.core.$strip>;
+export declare const deepagentSubagentEvidenceSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"deepagent-subagent-evidence/v1">;
+    subagent_name: z.ZodString;
+    prompt_purpose: z.ZodString;
+    tools_used: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    skills_used: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    structured_output: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    confidence: z.ZodNumber;
+    risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        summary: z.ZodString;
+        mitigation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const deepagentDecisionEvidenceSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"deepagent-decision-evidence/v1">;
+    decision_point: z.ZodString;
+    alternatives: z.ZodArray<z.ZodString>;
+    selected_option: z.ZodString;
+    adr_required: z.ZodBoolean;
+    rationale: z.ZodString;
+    approvals: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const deepagentQualityEvidenceSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"deepagent-quality-evidence/v1">;
+    matrix: z.ZodArray<z.ZodObject<{
+        requirement_id: z.ZodString;
+        validation_id: z.ZodString;
+        evidence_refs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            ref: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        residual_risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            severity: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                critical: "critical";
+            }>;
+            summary: z.ZodString;
+            mitigation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const deepagentRunEvidenceSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    contract: z.ZodLiteral<"deepagent-run-evidence/v1">;
+    run_id: z.ZodString;
+    feature_ref: z.ZodString;
+    mode: z.ZodEnum<{
+        validate: "validate";
+        "read-only": "read-only";
+        plan: "plan";
+        "apply-sandbox": "apply-sandbox";
+        "apply-approved": "apply-approved";
+    }>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        blocked: "blocked";
+        failed: "failed";
+        running: "running";
+        allowed: "allowed";
+    }>;
+    model_metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    config_fingerprint: z.ZodString;
+    plan_ref: z.ZodString;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    decisions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        contract: z.ZodLiteral<"deepagent-decision-evidence/v1">;
+        decision_point: z.ZodString;
+        alternatives: z.ZodArray<z.ZodString>;
+        selected_option: z.ZodString;
+        adr_required: z.ZodBoolean;
+        rationale: z.ZodString;
+        approvals: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        summary: z.ZodString;
+        mitigation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    finalize_intent: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+//# sourceMappingURL=deepagent-contracts.d.ts.map

package/dist/core/sdd/deepagent-contracts.js

@@ -0,0 +1,173 @@
+import { z } from 'zod';
+const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
+const deepagentModeSchema = z.enum([
+    'read-only',
+    'plan',
+    'validate',
+    'apply-sandbox',
+    'apply-approved',
+]);
+const deepagentStatusSchema = z.enum(['allowed', 'blocked', 'running', 'completed', 'failed']);
+const deepagentNetworkModeSchema = z.enum(['disabled', 'restricted', 'enabled']);
+const deepagentRuntimeModeSchema = z.enum(['disabled', 'fake', 'deepagents-js']);
+const deepagentExecutionLimitsSchema = z.object({
+    max_iterations: z.number().int().positive().optional(),
+    max_subagents: z.number().int().positive().optional(),
+    max_parallel: z.number().int().positive().optional(),
+});
+const deepagentEvidenceRefSchema = z.object({
+    kind: z.string().min(1),
+    ref: z.string().min(1),
+    path: z.string().min(1).optional(),
+});
+const deepagentRiskSchema = z.object({
+    id: z.string().min(1),
+    severity: z.enum(['low', 'medium', 'high', 'critical']),
+    summary: z.string().min(1),
+    mitigation: z.string().min(1).optional(),
+});
+export const deepagentEnvContractSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('deepagent-env-contract/v1'),
+    runtime_mode: deepagentRuntimeModeSchema.default('disabled'),
+    model_ref: z.string().min(1).optional(),
+    planner_model_ref: z.string().min(1).optional(),
+    reviewer_model_ref: z.string().min(1).optional(),
+    coder_model_ref: z.string().min(1).optional(),
+    execution_limits: deepagentExecutionLimitsSchema.default({}),
+    provider_profile: z.string().min(1).optional(),
+    env_allowlist: z.array(z.string().min(1)).default([]),
+    secret_refs: z.array(z.string().min(1)).default([]),
+    credential_env_refs: z.array(z.string().min(1)).default([]),
+    endpoint_env_refs: z.array(z.string().min(1)).default([]),
+    sandbox_passthrough_rules: z.array(z.string().min(1)).default([]),
+    network_mode: deepagentNetworkModeSchema.default('disabled'),
+    blocked_paths: z.array(z.string().min(1)).default([]),
+    masked_config_fingerprint: z.string().min(1),
+});
+export const deepagentRunRequestSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('deepagent-run-request/v1'),
+    provider: z.literal('deepagents'),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    mode: deepagentModeSchema,
+    objective: z.string().min(1),
+    allowed_tools: z.array(z.string().min(1)).default([]),
+    write_scope: z.object({
+        allow_project_writes: z.boolean().default(false),
+        allowed_paths: z.array(z.string().min(1)).default([]),
+    }),
+    network_policy: z.object({
+        mode: deepagentNetworkModeSchema.default('disabled'),
+        allowlist: z.array(z.string().min(1)).default([]),
+    }),
+    env_contract: deepagentEnvContractSchema,
+    skill_ids: z.array(z.string().min(1)).default([]),
+    plugin_envelopes: z
+        .array(z.object({
+        plugin_id: z.string().min(1),
+        capability: z.string().min(1),
+        version: z.string().min(1),
+    }))
+        .default([]),
+    reversa_scope: z.object({
+        enabled: z.boolean().default(false),
+        objective: z.string().min(1).optional(),
+        targets: z.array(z.string().min(1)).default([]),
+    }),
+    expected_evidence: z.array(z.string().min(1)).min(1),
+});
+export const deepagentRunPlanSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('deepagent-run-plan/v1'),
+    run_id: z.string().min(1),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    mode: deepagentModeSchema,
+    tactical_steps: z
+        .array(z.object({
+        id: z.string().min(1),
+        title: z.string().min(1),
+        objective: z.string().min(1),
+        subagent: z.string().min(1).optional(),
+    }))
+        .min(1),
+    subagent_routing: z.array(z.object({
+        subagent: z.string().min(1),
+        purpose: z.string().min(1),
+        task_ids: z.array(z.string().min(1)).default([]),
+    })),
+    required_approvals: z.array(z.string().min(1)).default([]),
+    expected_tool_calls: z.array(z.string().min(1)).default([]),
+    write_manifest_preview: z.array(z.string().min(1)).default([]),
+    validation_matrix: z
+        .array(z.object({
+        requirement: z.string().min(1),
+        validation: z.string().min(1),
+        evidence_kind: z.string().min(1),
+    }))
+        .default([]),
+    residual_risks: z.array(deepagentRiskSchema).default([]),
+});
+export const deepagentToolCallEvidenceSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('deepagent-tool-call-evidence/v1'),
+    tool_name: z.string().min(1),
+    input_hash: z.string().min(1),
+    output_hash: z.string().min(1),
+    state_access_class: z.enum(['read', 'write', 'execute', 'network']),
+    policy_gate: z.string().min(1),
+    hitl_decision: z.enum(['none', 'approve', 'reject', 'edit', 'respond']).default('none'),
+    duration_ms: z.number().int().nonnegative(),
+    result: z.enum(['ok', 'error', 'blocked']),
+});
+export const deepagentSubagentEvidenceSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('deepagent-subagent-evidence/v1'),
+    subagent_name: z.string().min(1),
+    prompt_purpose: z.string().min(1),
+    tools_used: z.array(z.string().min(1)).default([]),
+    skills_used: z.array(z.string().min(1)).default([]),
+    inputs: z.record(z.string(), z.unknown()).default({}),
+    structured_output: z.record(z.string(), z.unknown()).default({}),
+    confidence: z.number().min(0).max(1),
+    risks: z.array(deepagentRiskSchema).default([]),
+});
+export const deepagentDecisionEvidenceSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('deepagent-decision-evidence/v1'),
+    decision_point: z.string().min(1),
+    alternatives: z.array(z.string().min(1)).min(1),
+    selected_option: z.string().min(1),
+    adr_required: z.boolean(),
+    rationale: z.string().min(1),
+    approvals: z.array(z.string().min(1)).default([]),
+});
+export const deepagentQualityEvidenceSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('deepagent-quality-evidence/v1'),
+    matrix: z
+        .array(z.object({
+        requirement_id: z.string().min(1),
+        validation_id: z.string().min(1),
+        evidence_refs: z.array(deepagentEvidenceRefSchema).default([]),
+        residual_risks: z.array(deepagentRiskSchema).default([]),
+    }))
+        .min(1),
+});
+export const deepagentRunEvidenceSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('deepagent-run-evidence/v1'),
+    run_id: z.string().min(1),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    mode: deepagentModeSchema,
+    status: deepagentStatusSchema,
+    model_metadata: z.record(z.string(), z.unknown()).default({}),
+    config_fingerprint: z.string().min(1),
+    plan_ref: z.string().min(1),
+    artifacts: z.array(z.string().min(1)).default([]),
+    validations: z.array(z.string().min(1)).default([]),
+    decisions: z.array(deepagentDecisionEvidenceSchema).default([]),
+    risks: z.array(deepagentRiskSchema).default([]),
+    finalize_intent: z.boolean().default(false),
+});
+//# sourceMappingURL=deepagent-contracts.js.map

package/dist/core/sdd/deepagents/adr-governor.d.ts

@@ -0,0 +1,2 @@
+export declare function evaluateAdrGovernorDocument(content: string): string[];
+//# sourceMappingURL=adr-governor.d.ts.map

package/dist/core/sdd/deepagents/adr-governor.js

@@ -0,0 +1,30 @@
+import { LENSES, extractSectionContent, validateDocumentAgainstLens } from '../lenses.js';
+const ADR_TEMPLATE_SENTINELS = [
+    'Describe the context that motivated this architecture decision, including constraints and trade-offs.',
+    'Document the decision, the change scope, and the alternatives rejected.',
+    'List positive impacts, residual risks, and mitigation actions.',
+];
+export function evaluateAdrGovernorDocument(content) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        return ['ADR content is empty'];
+    }
+    const reasons = [];
+    const lensViolations = validateDocumentAgainstLens(trimmed, LENSES.adr);
+    if (lensViolations.length > 0) {
+        reasons.push(...lensViolations.map((violation) => `ADR lens violation: ${violation}`));
+    }
+    for (const sentinel of ADR_TEMPLATE_SENTINELS) {
+        if (trimmed.includes(sentinel)) {
+            reasons.push(`ADR still contains template placeholder text: ${sentinel}`);
+        }
+    }
+    for (const section of ['## Context', '## Decision', '## Consequences']) {
+        const sectionContent = extractSectionContent(trimmed, section);
+        if (sectionContent.trim().length < 20) {
+            reasons.push(`${section} must contain concrete decision content`);
+        }
+    }
+    return Array.from(new Set(reasons));
+}
+//# sourceMappingURL=adr-governor.js.map