intentdna 1.6.4 → 1.7.0

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/dist/templates/metadata.d.ts

@@ -0,0 +1,6 @@
+export interface TemplateMatchMetadata {
+    name: string;
+    keywords: readonly string[];
+}
+export declare const TEMPLATE_MATCH_METADATA: readonly TemplateMatchMetadata[];
+export declare function getTemplateMatchMetadata(name: string): TemplateMatchMetadata | undefined;

package/dist/templates/metadata.js

@@ -0,0 +1,32 @@
+export const TEMPLATE_MATCH_METADATA = [
+    { name: "code-review-pipeline", keywords: ["review", "code review", "pr review", "pull request", "审查"] },
+    { name: "safe-refactoring", keywords: ["refactor", "refactoring", "restructure", "rewrite safely", "重构"] },
+    { name: "tdd-strict", keywords: ["tdd", "test driven", "test first", "red green", "测试驱动"] },
+    { name: "full-pipeline", keywords: ["pipeline", "plan implement test", "full workflow", "完整流水线"] },
+    { name: "systematic-debugging", keywords: ["debug", "debugging", "bug fix", "troubleshoot", "调试"] },
+    { name: "verification-loop", keywords: ["verify", "verification", "validate", "check", "验证"] },
+    { name: "secure-dev", keywords: ["security", "secure", "owasp", "vulnerability", "安全"] },
+    { name: "enterprise-baseline", keywords: ["enterprise", "organization", "company", "corporate", "企业"] },
+    { name: "frontend-quality", keywords: ["frontend", "react", "vue", "css", "ui", "前端"] },
+    { name: "api-backend", keywords: ["api", "backend", "rest", "graphql", "server", "后端"] },
+    { name: "mobile-dev", keywords: ["mobile", "ios", "android", "react native", "移动"] },
+    { name: "documentation-writer", keywords: ["doc", "documentation", "readme", "wiki", "文档"] },
+    { name: "devops-cicd", keywords: ["devops", "ci", "cd", "deploy", "pipeline", "运维"] },
+    { name: "monorepo-governance", keywords: ["monorepo", "workspace", "packages", "governance"] },
+    { name: "flutter-behavior-lock", keywords: ["flutter", "behavior lock", "behavior spec", "行为锁定"] },
+    { name: "flutter-rewrite", keywords: ["flutter", "rewrite", "migration", "flutter rewrite"] },
+    { name: "flutter-refactoring-rescue", keywords: ["flutter", "rescue", "refactoring rescue"] },
+    { name: "multi-perspective-review", keywords: ["multi perspective", "multiple reviewer", "多角度"] },
+    { name: "subagent-parallel", keywords: ["parallel", "subagent", "concurrent", "并行"] },
+    { name: "yolo-with-guardrails", keywords: ["yolo", "fast", "guardrails", "move fast"] },
+    { name: "brainstorming-first", keywords: ["brainstorm", "explore", "ideation", "探索"] },
+    { name: "branch-finishing", keywords: ["branch", "finish", "cleanup", "pr prep"] },
+    { name: "pr-submitter", keywords: ["pr", "pull request", "submit"] },
+    { name: "migration-safety", keywords: ["migration", "migrate", "upgrade", "database migration", "dependency upgrade", "迁移"] },
+    { name: "incident-response", keywords: ["incident", "production issue", "hotfix", "outage", "postmortem", "事故"] },
+    { name: "performance-audit", keywords: ["performance", "profiling", "benchmark", "optimize", "latency", "性能"] },
+];
+const TEMPLATE_MATCH_METADATA_BY_NAME = new Map(TEMPLATE_MATCH_METADATA.map((entry) => [entry.name, entry]));
+export function getTemplateMatchMetadata(name) {
+    return TEMPLATE_MATCH_METADATA_BY_NAME.get(name);
+}

package/package.json

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

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] 错误信息人类可读