@devtrack-solution/codesdd 1.2.4-rc3 → 1.2.4

package/dist/core/sdd/enterprise-provenance-gates.js

@@ -0,0 +1,63 @@
+export function evaluateEnterpriseAllocatorProvenance(state) {
+    const findings = [];
+    for (const reservation of state.reservations) {
+        const hasAudit = state.audit_log.some((event) => event.idempotency_key === reservation.idempotency_key &&
+            (event.event_type === 'reservation_created' || event.event_type === 'reservation_replayed'));
+        if (!hasAudit) {
+            findings.push({
+                severity: 'blocker',
+                code: 'reservation-missing-audit',
+                message: `Reservation ${reservation.artifact_id} has no allocator audit event.`,
+                ref: reservation.artifact_id,
+            });
+        }
+    }
+    for (const lease of state.leases) {
+        const hasAudit = state.audit_log.some((event) => event.lease_id === lease.lease_id && event.event_type === 'lease_acquired');
+        if (!hasAudit) {
+            findings.push({
+                severity: 'blocker',
+                code: 'lease-missing-audit',
+                message: `Lease ${lease.lease_id} has no acquisition audit event.`,
+                ref: lease.lease_id,
+            });
+        }
+    }
+    for (const write of state.canonical_writes) {
+        const hasAudit = state.audit_log.some((event) => event.idempotency_key === write.idempotency_key &&
+            (event.event_type === 'canonical_write_committed' || event.event_type === 'canonical_write_replayed'));
+        if (!hasAudit) {
+            findings.push({
+                severity: 'blocker',
+                code: 'canonical-write-missing-audit',
+                message: `Canonical write ${write.artifact_id}@${write.revision} has no write audit event.`,
+                ref: write.artifact_id,
+            });
+        }
+    }
+    for (const draft of state.drafts) {
+        if (draft.converted_artifact_id) {
+            const reservation = state.reservations.find((candidate) => candidate.artifact_id === draft.converted_artifact_id);
+            if (!reservation) {
+                findings.push({
+                    severity: 'blocker',
+                    code: 'draft-conversion-missing-reservation',
+                    message: `Draft ${draft.draft_id} converted to ${draft.converted_artifact_id} without a reservation record.`,
+                    ref: draft.draft_id,
+                });
+            }
+        }
+    }
+    return {
+        valid: findings.every((finding) => finding.severity !== 'blocker'),
+        findings,
+        counters: {
+            reservations: state.reservations.length,
+            leases: state.leases.length,
+            canonical_writes: state.canonical_writes.length,
+            drafts: state.drafts.length,
+            audit_events: state.audit_log.length,
+        },
+    };
+}
+//# sourceMappingURL=enterprise-provenance-gates.js.map

package/dist/core/sdd/enterprise-provisioning-policy.d.ts

@@ -0,0 +1,26 @@
+import type { GlobalConfig } from '../global-config.js';
+export type EnterpriseProvisioningStatus = 'disabled' | 'ready' | 'blocked';
+export interface EnterpriseProvisioningPolicyReport {
+    schema_version: 1;
+    mode: 'local' | 'enterprise';
+    requested_mode?: 'local' | 'enterprise';
+    effective_mode?: 'local' | 'enterprise';
+    local_mode_exception_accepted?: boolean;
+    requested: boolean;
+    required_for_numbered_artifacts: boolean;
+    status: EnterpriseProvisioningStatus;
+    project_id?: string;
+    tenant_id?: string;
+    authority_url_env?: string;
+    redacted_authority_url?: string;
+    reason: string;
+    next_action: string;
+    validation_errors: string[];
+    rules: {
+        canonical_numbered_artifacts: string;
+        offline_enterprise: string;
+        local_mode: string;
+    };
+}
+export declare function buildEnterpriseProvisioningPolicyReport(config: GlobalConfig, env?: NodeJS.ProcessEnv): EnterpriseProvisioningPolicyReport;
+//# sourceMappingURL=enterprise-provisioning-policy.d.ts.map

package/dist/core/sdd/enterprise-provisioning-policy.js

@@ -0,0 +1,104 @@
+const DEFAULT_RULES = {
+    canonical_numbered_artifacts: 'Enterprise multi-agent mode must reserve DEB, INS, EPIC, FEAT, and other numbered artifacts through the online provisioning authority before canonical writes.',
+    offline_enterprise: 'When the authority is unavailable, Enterprise agents may create noncanonical drafts only; conversion to canonical artifacts requires a later online reservation.',
+    local_mode: 'Local/single-agent mode may keep using repository-local CodeSDD state and is not required to contact the provisioning authority.',
+};
+export function buildEnterpriseProvisioningPolicyReport(config, env = process.env) {
+    const provisioning = config.enterprise?.provisioning ?? {};
+    const mode = provisioning.mode ?? 'local';
+    const required = Boolean(provisioning.required_for_numbered_artifacts || mode === 'enterprise');
+    const requestedMode = mode;
+    const effectiveMode = required ? 'enterprise' : 'local';
+    const localModeExceptionAccepted = !required;
+    const authorityUrl = resolveAuthorityUrl(provisioning.authority_url, provisioning.authority_url_env, env);
+    const validationErrors = [];
+    if (required && !provisioning.project_id) {
+        validationErrors.push('enterprise.provisioning.project_id is required in Enterprise provisioning mode.');
+    }
+    if (required && !authorityUrl) {
+        validationErrors.push('enterprise.provisioning.authority_url or authority_url_env is required in Enterprise provisioning mode.');
+    }
+    if (authorityUrl && !isValidAuthorityUrl(authorityUrl)) {
+        validationErrors.push('enterprise.provisioning authority URL must be http(s) and include a hostname.');
+    }
+    if (mode === 'local' && !required) {
+        return {
+            schema_version: 1,
+            mode,
+            requested_mode: requestedMode,
+            effective_mode: effectiveMode,
+            local_mode_exception_accepted: localModeExceptionAccepted,
+            requested: false,
+            required_for_numbered_artifacts: false,
+            status: 'disabled',
+            project_id: provisioning.project_id,
+            tenant_id: provisioning.tenant_id,
+            authority_url_env: provisioning.authority_url_env,
+            redacted_authority_url: authorityUrl ? redactUrl(authorityUrl) : undefined,
+            reason: 'Enterprise provisioning requested mode is local and no Enterprise reservation request is active; local mode exception is accepted.',
+            next_action: 'none',
+            validation_errors: validationErrors,
+            rules: DEFAULT_RULES,
+        };
+    }
+    const status = validationErrors.length === 0 ? 'ready' : 'blocked';
+    return {
+        schema_version: 1,
+        mode,
+        requested_mode: requestedMode,
+        effective_mode: effectiveMode,
+        local_mode_exception_accepted: localModeExceptionAccepted,
+        requested: true,
+        required_for_numbered_artifacts: required,
+        status,
+        project_id: provisioning.project_id,
+        tenant_id: provisioning.tenant_id,
+        authority_url_env: provisioning.authority_url_env,
+        redacted_authority_url: authorityUrl ? redactUrl(authorityUrl) : undefined,
+        reason: status === 'ready'
+            ? requestedMode === 'enterprise'
+                ? 'Enterprise provisioning policy is configured for canonical numbered artifact reservations.'
+                : 'Enterprise provisioning is requested by required_for_numbered_artifacts despite local requested mode and is configured for canonical numbered artifact reservations.'
+            : 'Enterprise provisioning policy is requested but missing required project identity or authority configuration.',
+        next_action: status === 'ready'
+            ? 'none'
+            : 'Configure enterprise.provisioning.project_id and enterprise.provisioning.authority_url or authority_url_env in ~/.codesdd/config.toml, or keep enterprise.provisioning.mode=local with required_for_numbered_artifacts=false when Enterprise reservations are not intended.',
+        validation_errors: validationErrors,
+        rules: DEFAULT_RULES,
+    };
+}
+function resolveAuthorityUrl(explicitUrl, authorityUrlEnv, env) {
+    if (explicitUrl)
+        return explicitUrl;
+    if (authorityUrlEnv)
+        return env[authorityUrlEnv];
+    return undefined;
+}
+function isValidAuthorityUrl(value) {
+    try {
+        const parsed = new URL(value);
+        return (parsed.protocol === 'https:' || parsed.protocol === 'http:') && parsed.hostname.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function redactUrl(value) {
+    try {
+        const parsed = new URL(value);
+        if (parsed.username)
+            parsed.username = '[REDACTED]';
+        if (parsed.password)
+            parsed.password = '[REDACTED]';
+        for (const key of [...parsed.searchParams.keys()]) {
+            if (/key|secret|token|password|credential|private|auth/i.test(key)) {
+                parsed.searchParams.set(key, '[REDACTED]');
+            }
+        }
+        return parsed.toString();
+    }
+    catch {
+        return '[REDACTED]';
+    }
+}
+//# sourceMappingURL=enterprise-provisioning-policy.js.map

package/dist/core/sdd/governance-schemas.d.ts

@@ -91,10 +91,10 @@ export declare const debateFrontmatterSchema: z.ZodObject<{
         mediator: z.ZodObject<{
             choice: z.ZodString;
             rationale: z.ZodString;
-            accepted_risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            accepted_risks: z.ZodDefault<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
                 risk: z.ZodString;
                 mitigation: z.ZodString;
-            }, z.core.$strict>>>;
+            }, z.core.$strict>>>>;
             reversal_conditions: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>;
         output: z.ZodEnum<{

package/dist/core/sdd/governance-schemas.js

@@ -59,12 +59,21 @@ const debateScoringSchema = z
     scores: z.record(z.string().regex(/^[A-Z]$/), z.number()),
 })
     .strict();
-const debateAcceptedRiskSchema = z
+const DEFAULT_ACCEPTED_RISK_MITIGATION = 'Mitigation not provided by the source artifact; preserve this risk and require explicit mitigation before finalize.';
+const debateAcceptedRiskSchema = z.preprocess((value) => {
+    if (typeof value !== 'string')
+        return value;
+    const risk = value.trim();
+    return {
+        risk,
+        mitigation: DEFAULT_ACCEPTED_RISK_MITIGATION,
+    };
+}, z
     .object({
     risk: z.string().min(1),
     mitigation: z.string().min(1),
 })
-    .strict();
+    .strict());
 const debateDecisionSchema = z
     .object({
     question: z.string().min(1),

package/dist/core/sdd/json-schema.js

@@ -13,6 +13,7 @@ import { buildAgentRuntimeJsonSchemas } from './agent-runtime-contract.js';
 import { parallelFeatAutomationPlanSchema, parallelFeatAutomationRequestSchema, parallelFeatSchedulerRequestSchema, parallelFeatSchedulerResultSchema, } from './parallel-feat-automation.js';
 import { backlogProjectionPlanSchema, backlogProviderContractSchema, } from './backlog-provider-contract.js';
 import { qualityArchitectureSchema, qualityEvidenceBundleSchema, qualityRunSchema, qualityScenarioSchema, } from './quality-validation.js';
+import { reversaEvidenceBundleSchema } from './reversa-evidence.js';
 import { buildSdkAgentPluginQualityGateJsonSchemas } from './sdk-agent-plugin-quality-gates.js';
 import { deepagentDecisionEvidenceSchema, deepagentEnvContractSchema, deepagentQualityEvidenceSchema, deepagentRunEvidenceSchema, deepagentRunPlanSchema, deepagentRunRequestSchema, deepagentSubagentEvidenceSchema, deepagentToolCallEvidenceSchema, } from './deepagent-contracts.js';
 import { adrFrontmatterSchema, debateFrontmatterSchema, discardedFrontmatterSchema, epicFrontmatterSchema, insightFrontmatterSchema, } from './governance-schemas.js';
@@ -137,6 +138,9 @@ export function buildWorkspaceJsonSchemaCatalog() {
             'quality-evidence-bundle.yaml': normalizeJsonSchemaDocument(toJSONSchema(qualityEvidenceBundleSchema), 'CodeSDD Quality Evidence Bundle', 'Machine-readable evidence bundle contract tying scenario, run, artifacts, checksums, findings, and exceptions together.'),
             ...buildSdkAgentPluginQualityGateJsonSchemas(),
         },
+        reversa_contracts: {
+            'reversa-evidence-bundle.yaml': normalizeJsonSchemaDocument(toJSONSchema(reversaEvidenceBundleSchema), 'CodeSDD Reversa Evidence Bundle', 'Machine-readable evidence bundle contract for Reversa intake, extraction, generation, migration, reconstruction, and equivalence phases.'),
+        },
         deepagent_execution: {
             'deepagent-run-request.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentRunRequestSchema), 'CodeSDD DeepAgent Run Request', 'Machine-readable request contract for governed DeepAgents execution with scoped tools, write policy, env contract, and expected evidence.'),
             'deepagent-run-plan.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentRunPlanSchema), 'CodeSDD DeepAgent Run Plan', 'Machine-readable tactical plan contract for DeepAgents runs with subagent routing, approvals, validation matrix, and residual risks.'),

package/dist/core/sdd/legacy-operations.js

@@ -136,16 +136,19 @@ Decide ____ instead of ____ to solve ____.
 
 ## 3) Options Considered (Minimum 2)
 ### Option A
+- Status (selected/discarded):
 - Proposal:
 - Pros:
 - Cons:
 
 ### Option B
+- Status (selected/discarded):
 - Proposal:
 - Pros:
 - Cons:
 
 ### Option C (Optional)
+- Status (selected/discarded):
 - Proposal:
 - Pros:
 - Cons:
@@ -194,7 +197,15 @@ Decide ____ instead of ____ to solve ____.
 - APPROVED -> EPIC-####
 - DISCARDED -> Record in discarded
 
-## Metadata
+## 10) Planning Completeness Gate (Required before promotion)
+- Measurable acceptance:
+- Non-scope:
+- Definition of Done:
+- Validation commands:
+  -
+- Residual risk:
+
+## 11) Metadata
 - Source insight: ${insight.id}
 - Insight title: ${insight.title}
 - Created at: ${insight.created_at || now}
@@ -745,19 +756,92 @@ export async function findDebateFile(paths, debateId) {
         return null;
     return path.join(debateDir, found.name);
 }
+const GENERIC_DECISION_QUESTION_PATTERNS = [
+    /^decide\s+____\s+instead\s+of\s+____\s+to\s+solve\s+____\.?$/i,
+    /^decidir\s+____\s+em\s+vez\s+de\s+____\s+para\s+resolver\s+____\.?$/i,
+    /which option should we choose\??$/i,
+    /qual opcao devemos escolher\??$/i,
+    /decide between option [a-z] and option [a-z]\.?$/i,
+    /decidir entre opcao [a-z] e opcao [a-z]\.?$/i,
+];
+function isPlaceholderLike(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return true;
+    const placeholderTokens = ['____', '(fill in', '(preencher', 'todo', 'tbd', 'n/a'];
+    return placeholderTokens.some((token) => normalized.includes(token));
+}
+function isGenericDecisionQuestion(question) {
+    const normalized = question.trim().replace(/\s+/g, ' ').toLowerCase();
+    if (normalized.length < 30)
+        return true;
+    return GENERIC_DECISION_QUESTION_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function extractNamedListValue(content, labels) {
+    const escaped = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+    const match = content.match(new RegExp(`-\\s*(?:${escaped}):\\s*(.+)`, 'i'));
+    if (!match)
+        return '';
+    return match[1].trim();
+}
+function hasValidationCommand(content) {
+    const sectionMatch = content.match(/-\s*Validation commands:\s*([\s\S]*?)(?=\n-\s*Residual risk:|\n##\s+\d+\)|$)/i);
+    if (!sectionMatch)
+        return false;
+    const lines = sectionMatch[1]
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('-'))
+        .map((line) => line.replace(/^-\s*/, '').replace(/`/g, '').trim())
+        .filter((line) => line.length > 0);
+    if (lines.length === 0)
+        return false;
+    return lines.some((line) => line.includes('pnpm') || line.includes('npm') || line.includes('vitest'));
+}
+function collectPlanningGateMissing(content, selectedOption, optionIds) {
+    const missing = [];
+    const nonSelectedOptionIds = optionIds.filter((optionId) => optionId !== selectedOption);
+    if (nonSelectedOptionIds.length === 0) {
+        missing.push('Provide at least one discarded alternative option different from mediator choice');
+    }
+    const measurableAcceptance = extractNamedListValue(content, ['Measurable acceptance']);
+    if (isPlaceholderLike(measurableAcceptance) || !/\d|%|<=|>=|\bwithin\b|\bunder\b|\bmax\b/i.test(measurableAcceptance)) {
+        missing.push('Define measurable acceptance criteria in the planning completeness gate');
+    }
+    const nonScope = extractNamedListValue(content, ['Non-scope', 'Nao-escopo']);
+    if (isPlaceholderLike(nonScope)) {
+        missing.push('Document non-scope in the planning completeness gate');
+    }
+    const definitionOfDone = extractNamedListValue(content, ['Definition of Done', 'DoD']);
+    if (isPlaceholderLike(definitionOfDone)) {
+        missing.push('Document Definition of Done (DoD) in the planning completeness gate');
+    }
+    if (!hasValidationCommand(content)) {
+        missing.push('Document executable validation commands in the planning completeness gate');
+    }
+    const residualRisk = extractNamedListValue(content, ['Residual risk', 'Risco residual']);
+    if (isPlaceholderLike(residualRisk)) {
+        missing.push('Document residual risk in the planning completeness gate');
+    }
+    return missing;
+}
 export function validateDebateDocument(content) {
     try {
         const parsed = parseGovernanceFile('inline-content', content, debateFrontmatterSchema);
         if (parsed.hasFrontmatter && parsed.frontmatter) {
             const missing = [];
             const question = parsed.frontmatter.decision.question.trim().toLowerCase();
-            if (!question || question.includes('____')) {
+            if (isGenericDecisionQuestion(question) || question.includes('____')) {
                 missing.push('Fill the decision question with real context');
             }
+            if (parsed.frontmatter.decision.options.length < 2) {
+                missing.push('Provide at least two options in the decision matrix');
+            }
             const rationale = parsed.frontmatter.decision.mediator.rationale.trim().toLowerCase();
             if (!rationale || rationale.includes('____') || rationale.includes('(fill in') || rationale.includes('(preencher')) {
                 missing.push('Inform the mediator decision rationale');
             }
+            missing.push(...collectPlanningGateMissing(parsed.body, parsed.frontmatter.decision.mediator.choice.trim().toUpperCase(), parsed.frontmatter.decision.options.map((option) => option.id.trim().toUpperCase())));
             if (/\- Unit coverage:\s*$/m.test(parsed.body)) {
                 missing.push('Inform required unit coverage evidence in the quality contract');
             }
@@ -770,7 +854,7 @@ export function validateDebateDocument(content) {
             if (/\- Exceptions:\s*\n\s+- None, or formal exception/m.test(parsed.body)) {
                 missing.push('Confirm there is no quality exception or document the formal exception');
             }
-            return missing;
+            return Array.from(new Set(missing));
         }
     }
     catch (error) {
@@ -782,6 +866,11 @@ export function validateDebateDocument(content) {
         content.includes('Decide ____ instead of ____ to solve ____.')) {
         missing.push('Fill the decision question with real context');
     }
+    const selectedChoice = content.match(/-\s+(?:Escolha|Choice)(?:\s+\(A\/B\/C\))?:\s*(?:op(?:c|ç)[aã]o\s*)?([ABC])\b/i)?.[1] ||
+        content.match(/-\s+Op(?:c|ç)[aã]o\s+escolhida:\s*([ABC])\b/i)?.[1] ||
+        'A';
+    const optionIds = Array.from(content.matchAll(/###\s+Option\s+([A-Z])/gi)).map((match) => match[1]);
+    missing.push(...collectPlanningGateMissing(content, selectedChoice.toUpperCase(), optionIds));
     if (/\- (?:Escolha|Choice) \(A\/B\/C\):\s*$/m.test(content)) {
         missing.push('Inform the mediator choice in "Choice (A/B/C)"');
     }
@@ -800,7 +889,7 @@ export function validateDebateDocument(content) {
     if (/\- Exceptions:\s*\n\s+- None, or formal exception/m.test(content)) {
         missing.push('Confirm there is no quality exception or document the formal exception');
     }
-    return missing;
+    return Array.from(new Set(missing));
 }
 export function pickTopSkills(catalogSkills, ids, max = 3) {
     if (!ids || ids.length === 0)

package/dist/core/sdd/package-security-gates.js

@@ -23,9 +23,11 @@ const SECRET_SIGNATURES = [
 ];
 const SECRET_SCAN_IGNORE = [
     'node_modules/**',
+    '**/node_modules/**',
     'dist/**',
     'coverage/**',
     '.git/**',
+    '.temp/**',
     '.sdd/state/**',
     '.sdd/archived/**',
     '.sdd/active/**',

package/dist/core/sdd/package-structure-gate.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const DerivationProfileSchema: z.ZodEnum<{
-    prototype: "prototype";
     "foundation-compatible": "foundation-compatible";
+    prototype: "prototype";
     "enterprise-strict": "enterprise-strict";
 }>;
 export declare const PreviewGateStatusSchema: z.ZodEnum<{
@@ -14,20 +14,92 @@ export declare const PackageStructureNodeKindSchema: z.ZodEnum<{
     file: "file";
     dir: "dir";
 }>;
+export declare const PreviewContextPatternSchema: z.ZodEnum<{
+    "bo-pattern": "bo-pattern";
+    "entity-pattern": "entity-pattern";
+    "application-only": "application-only";
+}>;
+export declare const PreviewDiagnosticSeveritySchema: z.ZodEnum<{
+    block: "block";
+    warn: "warn";
+}>;
 export declare const PackageStructureNodeSchema: z.ZodSchema<PackageStructureNode>;
+export declare const ApplicationOnlyContextSchema: z.ZodObject<{
+    context: z.ZodString;
+    path: z.ZodString;
+    reason: z.ZodString;
+    adr_required: z.ZodDefault<z.ZodBoolean>;
+    contract_rule_ref: z.ZodLiteral<"DTAPI-P1-APPONLY-001">;
+}, z.core.$strip>;
+export declare const PreviewContextClassificationSchema: z.ZodObject<{
+    context: z.ZodString;
+    pattern: z.ZodEnum<{
+        "bo-pattern": "bo-pattern";
+        "entity-pattern": "entity-pattern";
+        "application-only": "application-only";
+    }>;
+    source_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    decision_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const PreviewDiagnosticSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<{
+        block: "block";
+        warn: "warn";
+    }>;
+    message: z.ZodString;
+    remediation: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const PackageStructurePreviewSchema: z.ZodObject<{
     schema_version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     project_name: z.ZodString;
     profile: z.ZodEnum<{
-        prototype: "prototype";
         "foundation-compatible": "foundation-compatible";
+        prototype: "prototype";
         "enterprise-strict": "enterprise-strict";
     }>;
+    source: z.ZodDefault<z.ZodEnum<{
+        template: "template";
+        "artifact-map": "artifact-map";
+    }>>;
     contexts: z.ZodArray<z.ZodString>;
     subsystems: z.ZodArray<z.ZodString>;
     transports: z.ZodArray<z.ZodString>;
     tree: z.ZodType<PackageStructureNode, unknown, z.core.$ZodTypeInternals<PackageStructureNode, unknown>>;
+    foundation_tests_projection: z.ZodOptional<z.ZodType<PackageStructureNode, unknown, z.core.$ZodTypeInternals<PackageStructureNode, unknown>>>;
+    runtime_scripts_projection: z.ZodOptional<z.ZodType<PackageStructureNode, unknown, z.core.$ZodTypeInternals<PackageStructureNode, unknown>>>;
+    application_only_contexts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        context: z.ZodString;
+        path: z.ZodString;
+        reason: z.ZodString;
+        adr_required: z.ZodDefault<z.ZodBoolean>;
+        contract_rule_ref: z.ZodLiteral<"DTAPI-P1-APPONLY-001">;
+    }, z.core.$strip>>>;
+    context_classification: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        context: z.ZodString;
+        pattern: z.ZodEnum<{
+            "bo-pattern": "bo-pattern";
+            "entity-pattern": "entity-pattern";
+            "application-only": "application-only";
+        }>;
+        source_paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        decision_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    contract_pack_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            block: "block";
+            warn: "warn";
+        }>;
+        message: z.ZodString;
+        remediation: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    artifact_languages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    material_signature: z.ZodString;
 }, z.core.$strip>;
 export declare const HumanValidationGateSchema: z.ZodObject<{
     gate_id: z.ZodString;
@@ -43,6 +115,9 @@ export declare const HumanValidationGateSchema: z.ZodObject<{
     approved_by: z.ZodOptional<z.ZodString>;
     correction_notes: z.ZodOptional<z.ZodString>;
     exception_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    contract_pack_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    material_signature: z.ZodString;
+    serialized_at: z.ZodString;
 }, z.core.$strip>;
 export interface HumanValidationGateData {
     selected_profile: z.infer<typeof DerivationProfileSchema>;
@@ -62,16 +137,23 @@ export interface DebGateInput {
     subsystems?: string[];
     transports?: string[];
     generated_at?: string;
+    artifact_map?: unknown;
+    previous_human_validation_gate?: z.infer<typeof HumanValidationGateSchema>;
+    contract_pack_refs?: string[];
 }
 export declare function generatePackageStructurePreview(input: DebGateInput): z.infer<typeof PackageStructurePreviewSchema>;
 export declare function formatPreviewAsTree(node: z.infer<typeof PackageStructureNodeSchema>, prefix?: string): string;
-export declare function buildHumanValidationGate(preview: z.infer<typeof PackageStructurePreviewSchema>): z.infer<typeof HumanValidationGateSchema>;
+export declare function buildHumanValidationGate(preview: z.infer<typeof PackageStructurePreviewSchema>, options?: {
+    previous_gate?: z.infer<typeof HumanValidationGateSchema>;
+    exception_refs?: string[];
+}): z.infer<typeof HumanValidationGateSchema>;
 export declare function generateDevtrackApiDebGate(input: DebGateInput): HumanValidationGateData;
 export declare function isGatePending(gate: z.infer<typeof HumanValidationGateSchema>): boolean;
 export declare function isGateApproved(gate: z.infer<typeof HumanValidationGateSchema>): boolean;
 export type DerivationProfile = z.infer<typeof DerivationProfileSchema>;
 export type PreviewGateStatus = z.infer<typeof PreviewGateStatusSchema>;
 export type PackageStructureNodeKind = z.infer<typeof PackageStructureNodeKindSchema>;
+export type PreviewContextPattern = z.infer<typeof PreviewContextPatternSchema>;
 export type PackageStructureNode = {
     name: string;
     kind: PackageStructureNodeKind;