intentdna 1.6.5 → 1.7.4

package/dist/schema/validate.js

@@ -7,7 +7,25 @@
  *   - Codon values in valid ranges
  *   - No circular inheritance
  */
+import { isAbsolute } from "node:path";
 import { validateController } from "./validators/controllers.js";
+const SAFE_GENERATED_IDENTIFIER = /^[A-Za-z0-9_-]+$/;
+const SAFE_GENERATED_DISPLAY_NAME = /^[A-Za-z0-9][A-Za-z0-9 _-]*$/;
+function isSafeGeneratedIdentifier(value) {
+    return SAFE_GENERATED_IDENTIFIER.test(value) && !value.includes("..") && !value.includes("/") && !value.includes("\\");
+}
+function isSafeGeneratedDisplayName(value) {
+    return SAFE_GENERATED_DISPLAY_NAME.test(value) && !value.includes("..");
+}
+function isSafeProjectTemplatePath(value) {
+    const withoutPlaceholders = value.replace(/\{\{[A-Za-z_][A-Za-z0-9_]*\}\}/g, "placeholder");
+    return value.trim().length > 0 &&
+        !isAbsolute(value) &&
+        !value.split(/[\\/]+/).includes("..") &&
+        !/[*?[\]{}]/.test(withoutPlaceholders) &&
+        !value.includes("${") &&
+        !value.includes("$(`");
+}
 function isLegibilityAssetArray(value) {
     return Array.isArray(value) && value.every((item) => typeof item === "object" && item !== null &&
         typeof item.type === "string" &&
@@ -72,6 +90,126 @@ function validateLegibilityAssets(dna, roleNamesSet, errors, warnings) {
         }
     }
 }
+function validateContextSources(dna, errors) {
+    const sources = dna.context_sources;
+    if (sources !== undefined) {
+        if (!Array.isArray(sources)) {
+            errors.push({ path: "context_sources", message: "must be an array" });
+        }
+        else {
+            const seen = new Set();
+            for (let i = 0; i < sources.length; i++) {
+                const path = `context_sources[${i}]`;
+                if (typeof sources[i] !== "object" || sources[i] === null || Array.isArray(sources[i])) {
+                    errors.push({ path, message: "context source must be an object" });
+                    continue;
+                }
+                const source = sources[i];
+                if (!source.id || typeof source.id !== "string") {
+                    errors.push({ path: `${path}.id`, message: "context source requires non-empty id" });
+                }
+                else if (seen.has(source.id)) {
+                    errors.push({ path: `${path}.id`, message: `duplicate context source id '${source.id}'` });
+                }
+                else {
+                    seen.add(source.id);
+                }
+                if (!["file", "url", "doc", "note"].includes(source.type)) {
+                    errors.push({ path: `${path}.type`, message: "must be one of: file, url, doc, note" });
+                }
+                if (source.type === "file" || source.type === "doc") {
+                    if (typeof source.path !== "string" || !source.path) {
+                        errors.push({ path: `${path}.path`, message: `${source.type} context source requires non-empty path` });
+                    }
+                    else if (isAbsolute(source.path) || source.path.split(/[\\/]+/).includes("..")) {
+                        errors.push({ path: `${path}.path`, message: "context source path must stay within the project" });
+                    }
+                }
+                if (source.type === "url" && (typeof source.url !== "string" || !source.url)) {
+                    errors.push({ path: `${path}.url`, message: "url context source requires non-empty url" });
+                }
+                if (source.tags !== undefined && (!Array.isArray(source.tags) || source.tags.some((tag) => typeof tag !== "string" || !tag))) {
+                    errors.push({ path: `${path}.tags`, message: "tags must be an array of non-empty strings" });
+                }
+            }
+        }
+    }
+    if (dna.planning_context) {
+        const pc = dna.planning_context;
+        if (!Array.isArray(pc.sources) || pc.sources.some((sourceId) => typeof sourceId !== "string" || !sourceId)) {
+            errors.push({ path: "planning_context.sources", message: "must be an array of non-empty context source ids" });
+        }
+        else {
+            const sourceList = Array.isArray(sources) ? sources : [];
+            const declared = new Set(sourceList.map((source) => source.id));
+            for (const sourceId of pc.sources) {
+                if (!declared.has(sourceId)) {
+                    errors.push({ path: "planning_context.sources", message: `references unknown context source '${sourceId}'` });
+                }
+            }
+        }
+        if (pc.instructions !== undefined && (!Array.isArray(pc.instructions) || pc.instructions.some((instruction) => typeof instruction !== "string" || !instruction))) {
+            errors.push({ path: "planning_context.instructions", message: "must be an array of non-empty strings" });
+        }
+        if (pc.require_quotes !== undefined && typeof pc.require_quotes !== "boolean") {
+            errors.push({ path: "planning_context.require_quotes", message: "must be a boolean" });
+        }
+        if (pc.require_attribution !== undefined && typeof pc.require_attribution !== "boolean") {
+            errors.push({ path: "planning_context.require_attribution", message: "must be a boolean" });
+        }
+    }
+}
+function contextSourceIdentities(source) {
+    const identities = [source.id];
+    if (source.type === "file" || source.type === "doc")
+        identities.push(source.path);
+    if (source.type === "url")
+        identities.push(source.url);
+    return identities.filter((identity) => typeof identity === "string" && identity.length > 0);
+}
+function handoffArtifactIdentities(artifact) {
+    return [artifact.artifact_id, artifact.name, artifact.path, artifact.type === "git_commit" ? "git_commit" : undefined]
+        .filter((identity) => typeof identity === "string" && identity.length > 0);
+}
+function validateContextSourceHandoffOverlap(dna, errors) {
+    const contextSources = Array.isArray(dna.context_sources) ? dna.context_sources : [];
+    if (contextSources.length === 0)
+        return;
+    const advisoryIdentities = new Set(contextSources.flatMap(contextSourceIdentities));
+    if (advisoryIdentities.size === 0)
+        return;
+    const checkArtifact = (artifact, path) => {
+        if (artifact.required === false)
+            return;
+        for (const identity of handoffArtifactIdentities(artifact)) {
+            if (!advisoryIdentities.has(identity))
+                continue;
+            errors.push({
+                path,
+                message: `planning-only context source '${identity}' cannot be used as a required handoff artifact`,
+            });
+            return;
+        }
+    };
+    const checkWorkflow = (workflow, path) => {
+        for (let i = 0; i < (workflow.steps ?? []).length; i++) {
+            const step = workflow.steps[i];
+            for (const direction of ["consumes", "produces"]) {
+                const artifacts = step.handoff?.[direction] ?? [];
+                for (let j = 0; j < artifacts.length; j++) {
+                    checkArtifact(artifacts[j], `${path}.steps[${i}].handoff.${direction}[${j}]`);
+                }
+            }
+        }
+    };
+    if (dna.workflow)
+        checkWorkflow(dna.workflow, "workflow");
+    if (dna.workflows) {
+        for (const [wfName, wfDef] of Object.entries(dna.workflows)) {
+            checkWorkflow(wfDef, `workflows.${wfName}`);
+        }
+    }
+}
 function validateCodon(codon, path) {
     const errors = [];
     switch (codon.type) {
@@ -150,6 +288,9 @@ function validateContext(name, ctx, geneNames) {
 function validateRole(name, role, geneNames) {
     const errors = [];
     const path = `roles.${name}`;
+    if (!isSafeGeneratedIdentifier(name)) {
+        errors.push({ path, message: "role name must contain only letters, digits, underscores, and hyphens" });
+    }
     // description required
     if (!role.description) {
         errors.push({ path: `${path}.description`, message: "role requires 'description'" });
@@ -245,8 +386,10 @@ function validateRole(name, role, geneNames) {
         if (os.converter !== undefined && (typeof os.converter !== "string" || !os.converter)) {
             errors.push({ path: `${osPath}.converter`, message: "must be a non-empty string" });
         }
-        if (os.path !== undefined && (typeof os.path !== "string" || !os.path)) {
-            errors.push({ path: `${osPath}.path`, message: "must be a non-empty string" });
+        if (os.path !== undefined) {
+            if (typeof os.path !== "string" || !isSafeProjectTemplatePath(os.path)) {
+                errors.push({ path: `${osPath}.path`, message: "must be a safe project-relative path template" });
+            }
         }
     }
     return errors;
@@ -307,6 +450,9 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
     if (!workflow.name) {
         errors.push({ path: `${path}.name`, message: "workflow requires 'name'" });
     }
+    else if (!isSafeGeneratedDisplayName(workflow.name)) {
+        errors.push({ path: `${path}.name`, message: "workflow name must contain only letters, digits, spaces, underscores, and hyphens" });
+    }
     // steps required and non-empty
     if (!workflow.steps || workflow.steps.length === 0) {
         errors.push({ path: `${path}.steps`, message: "workflow requires at least one step" });
@@ -322,6 +468,9 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
         if (!step.id) {
             errors.push({ path: `${stepPath}.id`, message: "step requires 'id'" });
         }
+        else if (!isSafeGeneratedIdentifier(step.id)) {
+            errors.push({ path: `${stepPath}.id`, message: "step id must contain only letters, digits, underscores, and hyphens" });
+        }
         else if (seenStepIds.has(step.id)) {
             errors.push({ path: `${stepPath}.id`, message: `duplicate step id '${step.id}'` });
         }
@@ -333,6 +482,9 @@ function validateWorkflow(workflow, roleNames, pathPrefix) {
         if (!step.role) {
             errors.push({ path: `${stepPath}.role`, message: "step requires 'role'" });
         }
+        else if (!isSafeGeneratedIdentifier(step.role)) {
+            errors.push({ path: `${stepPath}.role`, message: "step role must contain only letters, digits, underscores, and hyphens" });
+        }
         else if (roleNames.size > 0 && !roleNames.has(step.role)) {
             errors.push({
                 path: `${stepPath}.role`,
@@ -583,6 +735,7 @@ export function validateDNA(dna) {
             errors.push(...validateWorkflow(wfDef, roleNamesSet, `workflows.${wfName}`));
         }
     }
+    validateContextSourceHandoffOverlap(dna, errors);
     if (dna.controllers) {
         const workflowsForControllers = { ...(dna.workflows ?? {}) };
         if (dna.workflow)
@@ -621,6 +774,7 @@ export function validateDNA(dna) {
         }
     }
     validateLegibilityAssets(dna, roleNamesSet, errors, warnings);
+    validateContextSources(dna, errors);
     // Validate context_files
     if (dna.context_files) {
         const cf = dna.context_files;

package/dist/schema/validators/controllers.js

@@ -8,6 +8,12 @@ function isSafeControllerArtifactPath(path) {
         !path.includes("}}") &&
         path.includes("$ARGUMENTS");
 }
+function isSafeGeneratedIdentifier(value) {
+    return /^[A-Za-z0-9_-]+$/.test(value) && !value.includes("..") && !value.includes("/") && !value.includes("\\");
+}
+function isSafeGeneratedDisplayName(value) {
+    return /^[A-Za-z0-9][A-Za-z0-9 _-]*$/.test(value) && !value.includes("..");
+}
 function validateStringList(value, path, errors) {
     if (!Array.isArray(value)) {
         errors.push({ path, message: "must be an array of non-empty strings" });
@@ -69,6 +75,13 @@ export function validateController(controller, roleNames, workflows, path) {
     if (!controller.name) {
         errors.push({ path: `${path}.name`, message: "controller requires 'name'" });
     }
+    else if (!isSafeGeneratedDisplayName(controller.name)) {
+        errors.push({ path: `${path}.name`, message: "controller name must contain only letters, digits, spaces, underscores, and hyphens" });
+    }
+    const controllerKey = path.startsWith("controllers.") ? path.slice("controllers.".length) : "";
+    if (controllerKey && !isSafeGeneratedIdentifier(controllerKey)) {
+        errors.push({ path, message: "controller key must contain only letters, digits, underscores, and hyphens" });
+    }
     const kindMetadata = isSupportedControllerKind(controller.kind)
         ? getControllerKindMetadata(controller.kind)
         : undefined;
@@ -121,6 +134,9 @@ export function validateController(controller, roleNames, workflows, path) {
             if (typeof roleName !== "string" || !roleName) {
                 errors.push({ path: `${path}.roles.${roleKey}`, message: "must be a non-empty role name" });
             }
+            else if (!isSafeGeneratedIdentifier(roleName)) {
+                errors.push({ path: `${path}.roles.${roleKey}`, message: "role name must contain only letters, digits, underscores, and hyphens" });
+            }
             else if (!roleNames.has(roleName)) {
                 errors.push({ path: `${path}.roles.${roleKey}`, message: `references unknown role '${roleName}'` });
             }

package/dist/signals/index.d.ts

@@ -2,12 +2,14 @@ import type { TraceEntry, VerifierResultEntry } from "../hooks/state.js";
 import type { ExecutionOutcome } from "../evolution/types.js";
 export type SignalKind = "trace" | "verifier" | "external";
 export type SignalStatus = "positive" | "negative" | "neutral";
+export type ExternalSignalClassification = "protective" | "friction" | "unknown";
 export interface SignalEvidence {
     target?: string;
     evidence?: string;
     exit_code?: number;
     artifact?: string;
     message?: string;
+    evidence_ref?: string;
 }
 export interface SignalEnvelope {
     id: string;
@@ -19,6 +21,10 @@ export interface SignalEnvelope {
     detail?: string;
     adapter?: string;
     evidence_payload?: SignalEvidence;
+    classification?: ExternalSignalClassification;
+    confidence?: number;
+    mapping_policy?: string;
+    evolution_eligible?: boolean;
 }
 export interface ExternalSignalInput {
     id?: string;
@@ -32,6 +38,10 @@ export interface ExternalSignalInput {
     exit_code?: number;
     artifact?: string;
     message?: string;
+    evidence_ref?: string;
+    classification?: ExternalSignalClassification;
+    confidence?: number;
+    mapping_policy?: string;
 }
 export interface SignalSourceAdapter<T = unknown> {
     name: string;

package/dist/signals/index.js

@@ -1,4 +1,35 @@
 import { extractGeneFromReason } from "../evolution/trace-bridge.js";
+const SAFE_EXTERNAL_GENE = /^[A-Za-z0-9:_-]+$/;
+function hasSafeExternalGene(gene) {
+    return typeof gene === "string" && SAFE_EXTERNAL_GENE.test(gene);
+}
+function hasNonBlankText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isSignalStatus(value) {
+    return value === "positive" || value === "negative" || value === "neutral";
+}
+function isExternalSignalClassification(value) {
+    return value === undefined || value === "protective" || value === "friction" || value === "unknown";
+}
+function hasFiniteConfidence(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function hasExternalSignalShape(signal) {
+    return isSignalStatus(signal.status) &&
+        hasNonBlankText(signal.source) &&
+        isExternalSignalClassification(signal.classification) &&
+        (signal.confidence === undefined || hasFiniteConfidence(signal.confidence));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
 function toSignalEvidence(result) {
     const payload = {
         target: result.target,
@@ -6,23 +37,75 @@ function toSignalEvidence(result) {
         exit_code: result.exit_code,
         artifact: result.artifact,
         message: result.message,
+        evidence_ref: "evidence_ref" in result ? result.evidence_ref : undefined,
     };
     return Object.values(payload).some((value) => value !== undefined) ? payload : undefined;
 }
+function hasExternalSignalInputContract(signal) {
+    return (hasExternalSignalShape(signal) &&
+        hasFiniteConfidence(signal.confidence) &&
+        hasNonBlankText(signal.mapping_policy) &&
+        hasNonBlankText(signal.evidence_ref) &&
+        hasSafeExternalGene(signal.gene));
+}
+function hasExternalSignalEnvelopeContract(signal) {
+    return (isSignalStatus(signal.status) &&
+        hasNonBlankText(signal.source) &&
+        isExternalSignalClassification(signal.classification) &&
+        hasFiniteConfidence(signal.confidence) &&
+        hasNonBlankText(signal.mapping_policy) &&
+        hasNonBlankText(signal.evidence_payload?.evidence_ref) &&
+        hasSafeExternalGene(signal.gene));
+}
 function normalizeExternalSignals(adapterName, payload) {
     const items = Array.isArray(payload) ? payload : [payload];
-    return items.map((item, index) => {
-        const timestamp = item.timestamp ?? new Date().toISOString();
+    return items.map((raw, index) => {
+        const timestamp = isRecord(raw) ? asString(raw.timestamp) ?? new Date().toISOString() : new Date().toISOString();
+        if (!isRecord(raw)) {
+            return {
+                id: `${adapterName}:invalid:${timestamp}:${index}`,
+                kind: "external",
+                status: "neutral",
+                timestamp,
+                source: `${adapterName}.invalid`,
+                adapter: adapterName,
+                classification: "unknown",
+                evolution_eligible: false,
+            };
+        }
+        const item = {
+            id: asString(raw.id),
+            status: raw.status,
+            timestamp,
+            gene: asString(raw.gene),
+            source: asString(raw.source) ?? "",
+            detail: asString(raw.detail),
+            target: asString(raw.target),
+            evidence: asString(raw.evidence),
+            exit_code: asNumber(raw.exit_code),
+            artifact: asString(raw.artifact),
+            message: asString(raw.message),
+            evidence_ref: asString(raw.evidence_ref),
+            classification: raw.classification,
+            confidence: typeof raw.confidence === "number" ? raw.confidence : undefined,
+            mapping_policy: asString(raw.mapping_policy),
+        };
+        const shapeValid = hasExternalSignalShape(item);
+        const complete = hasExternalSignalInputContract(item);
         return {
-            id: item.id ?? `${adapterName}:${item.source}:${timestamp}:${index}`,
+            id: item.id ?? `${adapterName}:${shapeValid ? item.source : "invalid"}:${timestamp}:${index}`,
             kind: "external",
-            status: item.status,
+            status: shapeValid ? item.status : "neutral",
             timestamp,
             gene: item.gene,
-            source: item.source,
+            source: hasNonBlankText(item.source) ? item.source : `${adapterName}.invalid`,
             detail: item.detail ?? item.message ?? item.evidence,
             adapter: adapterName,
             evidence_payload: toSignalEvidence(item),
+            classification: isExternalSignalClassification(item.classification) ? (item.classification ?? "unknown") : "unknown",
+            confidence: hasFiniteConfidence(item.confidence) ? item.confidence : undefined,
+            mapping_policy: item.mapping_policy,
+            evolution_eligible: complete,
         };
     });
 }
@@ -85,6 +168,8 @@ export function signalsToOutcomes(signals, dnaId = "default") {
     for (const signal of signals) {
         if (!signal.gene)
             continue;
+        if (signal.kind === "external" && !hasExternalSignalEnvelopeContract(signal))
+            continue;
         const effect = signal.status === "positive"
             ? "helped"
             : signal.status === "negative"

package/dist/templates/catalog.d.ts

@@ -0,0 +1,19 @@
+export declare const BUILTIN_TEMPLATES_DIR: string;
+export declare const PROJECT_TEMPLATES_DIR = ".dna/templates";
+export interface TemplateCatalogEntry {
+    name: string;
+    path: string;
+    namespace?: string;
+    displayName?: string;
+    version?: string;
+    contentHash: string;
+    source: "builtin" | "project";
+    keywords: readonly string[];
+}
+export declare function calculateTemplateContentHash(content: string): string;
+export declare function listTemplateCatalog(options?: {
+    projectDir?: string;
+}): Promise<TemplateCatalogEntry[]>;
+export declare function findTemplateCatalogEntry(name: string, options?: {
+    projectDir?: string;
+}): Promise<TemplateCatalogEntry | undefined>;

package/dist/templates/catalog.js

@@ -0,0 +1,57 @@
+import { readFile, readdir } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseYAML } from "../schema/yaml-parser.js";
+import { getTemplateMatchMetadata } from "./metadata.js";
+export const BUILTIN_TEMPLATES_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "templates");
+export const PROJECT_TEMPLATES_DIR = ".dna/templates";
+function calculateContentHash(content) {
+    return createHash("sha256").update(content, "utf-8").digest("hex").slice(0, 16);
+}
+async function readTemplateEntry(path, source) {
+    const content = await readFile(path, "utf-8");
+    const data = parseYAML(content);
+    const fileName = path.split("/").pop() ?? path;
+    const name = fileName.replace(/\.dna\.ya?ml$/, "");
+    const matchMetadata = getTemplateMatchMetadata(name);
+    return {
+        name,
+        path,
+        namespace: typeof data.namespace === "string" ? data.namespace : undefined,
+        displayName: typeof data.name === "string" ? data.name : undefined,
+        version: typeof data.version === "string" ? data.version : undefined,
+        contentHash: calculateContentHash(content),
+        source,
+        keywords: matchMetadata?.keywords ?? [],
+    };
+}
+async function collectTemplates(dir, source) {
+    try {
+        const files = await readdir(dir);
+        const templateFiles = files
+            .filter((file) => file.endsWith(".dna.yaml") || file.endsWith(".dna.yml"))
+            .sort();
+        const entries = [];
+        for (const file of templateFiles) {
+            entries.push(await readTemplateEntry(resolve(dir, file), source));
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+export function calculateTemplateContentHash(content) {
+    return calculateContentHash(content);
+}
+export async function listTemplateCatalog(options) {
+    const projectDir = options?.projectDir ?? process.cwd();
+    const builtin = await collectTemplates(BUILTIN_TEMPLATES_DIR, "builtin");
+    const project = await collectTemplates(resolve(projectDir, PROJECT_TEMPLATES_DIR), "project");
+    return [...builtin, ...project];
+}
+export async function findTemplateCatalogEntry(name, options) {
+    const entries = await listTemplateCatalog(options);
+    return entries.find((entry) => entry.name === name || entry.displayName === name || entry.namespace === name);
+}

package/dist/templates/flutter-rewrite.dna.yaml

@@ -335,8 +335,8 @@ controllers:
         - "- MAX_ROUNDS: stop, report max rounds reached and next focus"
       stop_report:
         - "On REQUEST_CHANGES, BLOCKED, or MAX_ROUNDS, output exactly these Chinese sections:"
-        - "结论：state the direct stop trigger, current round, and current commit if one exists."
-        - "为什么停止：explain the workflow principle in plain language; if this is a current-round new red, explain that continuing would build on a bad baseline."
+        - "结论：state the direct stop trigger, current round, and current commit if one exists; cite verifier result_id, trace_id, or ArtifactManifest artifact id."
+        - "为什么停止：explain the workflow principle in plain language; if this is a current-round new red, explain that continuing would build on a bad baseline; prose-only claims are not sufficient."
         - "是否回滚：say whether rollback/revert is recommended. If the commit direction looks wrong or the blast radius is unclear, recommend revert; if the failure is narrow and fixable, recommend fix-forward."
         - "下一步：give one concrete next action. If recommending fix-forward, include a copy-paste single-fix prompt with current commit, exact failure, allowed scope, forbidden actions, verification command, commit expectation, and stop conditions."
       constraints:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.6.5",
+  "version": "1.7.4",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",

package/spec/README.md

@@ -15,7 +15,7 @@ This directory contains engineering specs. Use [ROADMAP.md](../ROADMAP.md) as th
 
 | Spec | Status | Purpose |
 |------|--------|---------|
-| [schema-spec.md](schema-spec.md) | Canonical | Intent DNA document structure, genes, roles, workflows, cascade, and IR contract. |
+| [schema-spec.md](schema-spec.md) | Canonical | Intent DNA document structure, genes, roles, workflows, cascade, Enterprise bundle inheritance, RuntimeDecisionEvent, and IR contract. |
 | [foundation-hardening.md](foundation-hardening.md) | Active reference | Reliability, governance, MCP, and tool-experience hardening plan. |
 | [hooks-infra-harness-hardening.md](hooks-infra-harness-hardening.md) | Active reference | Hook boundary schema, enforcement result types, state manager, context/reflection/workflow gates. |
 | [workflow-pipeline.md](workflow-pipeline.md) | Active reference | Workflow pipeline design and state management unification. |

package/spec/foundation-hardening.md

@@ -173,5 +173,6 @@ hook 报错时输出人类可读的提示而非 JSON。`dna verify` 输出友好
 
 ### 第三阶段
 - [x] dna sync 自动检测模板版本 + 提示升级
-- [x] MCP server 常驻进程解决冷启动
+- [x] MCP server 常驻进程复用完整 hook runtime + IR cache
+- [ ] Claude settings hook 零进程调度（后续性能优化）
 - [x] 错误信息人类可读

package/spec/schema-spec.md

@@ -386,7 +386,7 @@ Or shorthand: `max_rounds: 3` (equivalent to max_retries: 2)
 
 ## Cascade (Inheritance)
 
-DNA configs inherit from parent layers using CSS-like cascade.
+DNA configs inherit from parent layers using CSS-like cascade. The enterprise safety cascade order is Species → Enterprise → Project → Personal → Role → Context → Task.
 
 ```yaml
 cascade:
@@ -404,6 +404,83 @@ cascade:
 ### Threshold Protection
 Threshold codons from lower-priority layers **cannot be removed** by higher-priority layers. This ensures safety invariants propagate up the chain.
 
+Species and Enterprise thresholds are organization red lines. Project, Personal, Role, Context, and Task layers may add stricter thresholds, but they cannot relax, remove, bypass, or downgrade Species/Enterprise thresholds.
+
+### Enterprise Bundle Inheritance (v1.7.x local/shared slice)
+
+The v1.7.x Enterprise Safety Slice is scoped to local and shared policy bundle references only; it does not implement remote registry, signing, push/pull, or SaaS permissions. In v1.7.1 this section freezes the contract and resolver boundary; the concrete `dna sync` / `dna verify` resolver implementation is planned for v1.7.2.
+
+Candidate bundle locations:
+
+- `INTENTDNA_ENTERPRISE_POLICY_DIR` — admin/team-controlled shared root for authoritative local dogfood
+- `.dna/policies/enterprise/*.dna.yaml` — project-local bundle for development and fixture use
+- `~/.intentdna/policies/enterprise/*.dna.yaml` — user-local bundle for development and personal dogfood
+- `test/fixtures/enterprise-policies/` — test-only fixture root
+
+Project-local and user-local bundles are not organization-authoritative by themselves. They must be treated as local/dev provenance unless the future v1.7.2 resolver can tie them to an admin-controlled root or pinned fingerprint.
+
+Supported reference forms:
+
+```yaml
+cascade:
+  inherits:
+    - "enterprise:baseline"              # resolves baseline.dna.yaml from candidate dirs
+    - "file:../shared/baseline.dna.yaml" # explicit local/shared file
+```
+
+For v1.7.2, `dna sync` must materialize the resolved bundle id/version, source path, fingerprint, cascade layer fingerprints, and compiled IR hash into provenance. `dna verify` must reject unresolved references, inheritance cycles, missing bundle metadata, and attempts by lower layers to relax Species/Enterprise thresholds.
+
+---
+
+## Enterprise Provenance Contract (v1.7.1)
+
+v1.7.1 freezes the enterprise evidence contract before the full implementation lands. `RuntimeDecisionEvent` is required for enterprise governance evidence; legacy trace/audit/state records without this provenance remain diagnostic only.
+
+### PolicyBundle
+
+A policy bundle records the policy source that produced enforcement-relevant constraints:
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `policy_bundle_id` | yes | Stable bundle id, e.g. `enterprise_baseline` |
+| `policy_bundle_version` | yes | Bundle version used for the decision |
+| `source_ref` | yes | `enterprise:baseline`, `file:...`, or a local source path |
+| `fingerprint` | yes | Stable content/source fingerprint |
+
+### CascadeLayerFingerprint
+
+`cascade_layers` must include every layer: `species`, `enterprise`, `project`, `personal`, `role`, `context`, and `task`.
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `layer` | yes | One of the fixed cascade layer names |
+| `source_id` | yes | DNA or placeholder source id |
+| `source_ref` | yes | Resolved source path/reference or `unknown` / `unsupported` |
+| `fingerprint` | yes | Layer fingerprint or `unknown` / `unsupported` |
+| `status` | yes | `active`, `unknown`, or `unsupported` |
+
+### RuntimeDecisionEvent
+
+Every enterprise runtime decision must include these required fields:
+
+```text
+schema_version, event_id, timestamp,
+org_id, team_id, user_id, project_id,
+agent_id, agent_role, agent_type, session_agent,
+harness_adapter, runtime,
+policy_bundle_id, policy_bundle_version,
+cascade_layers, winning_constraint, compiled_ir_hash,
+decision, decision_reason,
+enforcement_point, harness_runtime_context,
+session_id, run_id, step_id,
+tool_name, action_kind, resource_ref,
+evidence_refs
+```
+
+`decision` is one of `allow`, `warn`, `block`, `escalate`, or `validate`. `enforcement_point` is one of `hook`, `sdk`, `ci`, `plugin_runtime`, `mcp_external_write`, `unknown`, or `unsupported`.
+
+The first implementation may fill unavailable dimensions with explicit `unknown` or `unsupported` values, but it must not omit required fields. Placeholder values make the event syntactically valid for phased rollout, not enterprise-authoritative: any required provenance field that remains `unknown` / `unsupported`, or any `legacy` / placeholder `evidence_refs` entry, keeps the event classified as `legacy_diagnostic`. Events missing required fields or classified as diagnostic cannot enter enterprise compliance statistics. MCP, reports, dashboards, and evolution consume this event as evidence; they do not create policy truth.
+
 ---
 
 ## Variables