@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

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

@@ -0,0 +1,370 @@
+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";
+        enabled: "enabled";
+        restricted: "restricted";
+    }>>;
+    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";
+            enabled: "enabled";
+            restricted: "restricted";
+        }>>;
+        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";
+            enabled: "enabled";
+            restricted: "restricted";
+        }>>;
+        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>>>;
+    change_safety: z.ZodOptional<z.ZodObject<{
+        explicit_modification_intent: z.ZodObject<{
+            operation: z.ZodEnum<{
+                replace: "replace";
+                add: "add";
+                modify: "modify";
+                remove: "remove";
+                refactor: "refactor";
+                optimize: "optimize";
+            }>;
+        }, z.core.$strip>;
+        context_lock: z.ZodDefault<z.ZodObject<{
+            allowed_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            forbidden_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            protected_core: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        change_budget: z.ZodDefault<z.ZodObject<{
+            max_files_changed: z.ZodOptional<z.ZodNumber>;
+            max_new_files: z.ZodOptional<z.ZodNumber>;
+            max_deleted_files: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        governed_override: z.ZodOptional<z.ZodObject<{
+            feature_id: z.ZodString;
+            intent: z.ZodEnum<{
+                replace: "replace";
+                add: "add";
+                modify: "modify";
+                remove: "remove";
+                refactor: "refactor";
+                optimize: "optimize";
+            }>;
+            rationale: z.ZodString;
+            write_scope: z.ZodArray<z.ZodString>;
+            expected_deletions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            rollback_plan: z.ZodString;
+            compensating_control: z.ZodString;
+            approver: z.ZodString;
+            expires_at: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    planned_file_changes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            replace: "replace";
+            rename: "rename";
+            create: "create";
+            delete: "delete";
+            modify: "modify";
+        }>;
+        previous_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    capability_inventory_before: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            event: "event";
+            schema: "schema";
+            route: "route";
+            page: "page";
+            cli_command: "cli_command";
+            public_contract: "public_contract";
+            core_flow: "core_flow";
+            governance_state: "governance_state";
+        }>;
+        id: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    capability_inventory_after: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            event: "event";
+            schema: "schema";
+            route: "route";
+            page: "page";
+            cli_command: "cli_command";
+            public_contract: "public_contract";
+            core_flow: "core_flow";
+            governance_state: "governance_state";
+        }>;
+        id: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    capability_inventory_required: z.ZodDefault<z.ZodBoolean>;
+    capability_required_kinds: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        event: "event";
+        schema: "schema";
+        route: "route";
+        page: "page";
+        cli_command: "cli_command";
+        public_contract: "public_contract";
+        core_flow: "core_flow";
+        governance_state: "governance_state";
+    }>>>;
+    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<{
+        none: "none";
+        edit: "edit";
+        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,235 @@
+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 changeSafetyOperationSchema = z.enum(['add', 'modify', 'remove', 'replace', 'refactor', 'optimize']);
+const plannedFileOperationSchema = z.enum(['create', 'modify', 'delete', 'rename', 'replace']);
+const capabilityKindSchema = z.enum([
+    'route',
+    'page',
+    'cli_command',
+    'public_contract',
+    'schema',
+    'event',
+    'core_flow',
+    'governance_state',
+]);
+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 changeSafetyContractSchema = z.object({
+    explicit_modification_intent: z.object({
+        operation: changeSafetyOperationSchema,
+    }),
+    context_lock: z
+        .object({
+        allowed_paths: z.array(z.string().min(1)).default([]),
+        forbidden_paths: z.array(z.string().min(1)).default([]),
+        protected_core: z.array(z.string().min(1)).default([]),
+    })
+        .default({ allowed_paths: [], forbidden_paths: [], protected_core: [] }),
+    change_budget: z
+        .object({
+        max_files_changed: z.number().int().nonnegative().optional(),
+        max_new_files: z.number().int().nonnegative().optional(),
+        max_deleted_files: z.number().int().nonnegative().optional(),
+    })
+        .default({}),
+    governed_override: z
+        .object({
+        feature_id: z.string().regex(FEATURE_REF_PATTERN),
+        intent: changeSafetyOperationSchema,
+        rationale: z.string().min(1),
+        write_scope: z.array(z.string().min(1)).min(1),
+        expected_deletions: z.array(z.string().min(1)).default([]),
+        rollback_plan: z.string().min(1),
+        compensating_control: z.string().min(1),
+        approver: z.string().min(1),
+        expires_at: z.string().datetime(),
+    })
+        .optional(),
+});
+const plannedFileChangeSchema = z.object({
+    path: z.string().min(1),
+    operation: plannedFileOperationSchema,
+    previous_path: z.string().min(1).optional(),
+});
+const capabilityInventoryItemSchema = z.object({
+    kind: capabilityKindSchema,
+    id: z.string().min(1),
+    path: z.string().min(1).optional(),
+    fingerprint: z.string().min(1).optional(),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+});
+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([]),
+    change_safety: changeSafetyContractSchema.optional(),
+    planned_file_changes: z.array(plannedFileChangeSchema).default([]),
+    capability_inventory_before: z.array(capabilityInventoryItemSchema).default([]),
+    capability_inventory_after: z.array(capabilityInventoryItemSchema).default([]),
+    capability_inventory_required: z.boolean().default(false),
+    capability_required_kinds: z.array(capabilityKindSchema).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