chati-dev 2.0.6 → 2.0.7

package/README.md

@@ -47,7 +47,8 @@ PLANNING (planning)  →  Quality Gate  →  BUILD  →  Quality Gate  →  DEPL
 | **Memory System RECALL** | 4 cognitive sectors. Persistent knowledge across sessions with attention scoring and natural decay |
 | **Decision Engine COMPASS** | Entity catalog with Jaccard similarity for REUSE/ADAPT/CREATE decisions. Self-healing registry |
 | **Session Lock** | Once activated, user stays in system until explicit exit. Zero accidental leakage |
-| **Hooks System** | 5 Claude Code hooks — constitution guard, mode governance, model governance, context injection, session digest |
+| **Hooks System** | 6 Claude Code hooks — constitution guard, mode governance, model governance, read protection, context injection, session digest |
+| **Supply Chain Security** | Ed25519 manifest signing. Package integrity verification on install. Semantic linter for cross-reference validation |
 | **Execution Modes** | Autonomous and human-in-the-loop modes with safety net (5 triggers) and circuit breaker |
 | **Multi-Terminal** | Autonomous agents spawn in separate `claude -p` terminals with dedicated models. Parallel groups (Detail + Architect + UX) with write-scope isolation |
 | **IDE-Agnostic** | Works with 6 IDEs through a thin router pattern |
@@ -276,7 +277,7 @@ your-project/
 │   ├── schemas/                  # 5 JSON schemas for validation
 │   ├── intelligence/             # Context Engine, Memory Layer, Decision Engine
 │   ├── domains/                  # Domain loading configs (per-agent, per-workflow)
-│   ├── hooks/                    # 5 Claude Code hooks (enforcement)
+│   ├── hooks/                    # 6 Claude Code hooks (enforcement)
 │   ├── context/                  # Context source files (deployed to .claude/rules/)
 │   ├── frameworks/               # Decision heuristics, quality dims
 │   ├── quality-gates/            # Planning & implementation gates

package/framework/constitution.md

@@ -384,7 +384,7 @@ The system SHALL support two execution modes that govern the degree of human inv
 
 3. Quality gate thresholds are conservative by default:
    - **qa-planning**: 95% minimum (gates planning-to-build transition)
-   - **qa-implementation**: 90% minimum (gates build-to-deploy transition)
+   - **qa-implementation**: 95% minimum (gates build-to-deploy transition)
    - **All other agents**: 90% minimum
    - Scores below threshold trigger escalation regardless of execution mode.
 

package/framework/context/governance.md

@@ -32,6 +32,6 @@ Extracted from `chati.dev/constitution.md` (17 Articles). Read the full constitu
 - Model recorded in session for cost tracking
 
 ## Execution Mode (Article XVII)
-- Autonomous mode requires gate score >= 90% (qa-planning >= 95%)
+- Autonomous mode requires gate score >= 90% (qa-planning >= 95%, qa-implementation >= 95%)
 - Safety net with 5 triggers: stuck loop, quality drop, scope creep, error cascade, user override
 - Circuit breaker: CLOSED -> OPEN (3 failures) -> HALF_OPEN (probe)

package/framework/context/quality.md

@@ -4,6 +4,7 @@
 | Agent | Minimum Score |
 |-------|--------------|
 | qa-planning | 95% |
+| qa-implementation | 95% |
 | All others | 90% |
 
 ## Review Range
@@ -13,7 +14,7 @@ Scores within 5 points below threshold trigger REVIEW (human confirmation requir
 1. **Planning Complete** — All PLANNING agents finished
 2. **QA Planning** — QA-Planning agent validates plan coherence (95% threshold)
 3. **Implementation** — Dev agent completes all tasks
-4. **QA Implementation** — Tests pass, SAST clean, coverage adequate (90% threshold)
+4. **QA Implementation** — Tests pass, SAST clean, coverage adequate (95% threshold)
 5. **Deploy Ready** — All gates passed, ready for production
 
 ## Quality Dimensions

package/framework/hooks/prism-engine.js

@@ -66,12 +66,26 @@ async function main() {
     else if (remainingPercent < 40) bracket = 'DEPLETED';
     else if (remainingPercent < 60) bracket = 'MODERATE';
 
+    // Load agent memory (if active agent has MEMORY.md)
+    let memoryBlock = '';
+    if (session.currentAgent) {
+      const memoryPath = join(projectDir, '.chati', 'memories', session.currentAgent, 'MEMORY.md');
+      if (existsSync(memoryPath)) {
+        const raw = readFileSync(memoryPath, 'utf-8').trim();
+        if (raw) {
+          const trimmed = raw.slice(0, 500);
+          memoryBlock = `  <agent-memory agent="${session.currentAgent}">\n${trimmed}\n  </agent-memory>`;
+        }
+      }
+    }
+
     // Build minimal context block (full PRISM pipeline is used by orchestrator internally)
     const contextBlock = [
       `<chati-context bracket="${bracket}">`,
       `  <mode>${session.mode}</mode>`,
       session.currentAgent ? `  <agent>${session.currentAgent}</agent>` : '',
       session.pipelinePosition ? `  <pipeline-position>${session.pipelinePosition}</pipeline-position>` : '',
+      memoryBlock,
       bracket === 'CRITICAL' ? '  <advisory>Context running low. Consider handoff or summary.</advisory>' : '',
       '</chati-context>',
     ].filter(Boolean).join('\n');
@@ -86,4 +100,10 @@ async function main() {
   }
 }
 
-main();
+export { readSessionState };
+
+// Only run main when executed directly (not imported by tests)
+import { fileURLToPath } from 'url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main();
+}

package/framework/hooks/read-protection.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * Read Protection Hook — PreToolUse (Read)
+ *
+ * BLOCKS reading sensitive files that may contain secrets:
+ * - .env files (except .env.example, .env.template)
+ * - Private keys (*.pem, *.key) — except signing-public-key.pem
+ * - Credentials and secrets files
+ * - .git/config (may contain tokens)
+ *
+ * Enforces Article IV: Secret protection.
+ */
+
+import { relative, basename } from 'path';
+
+const SENSITIVE_PATTERNS = [
+  /^\.env$/,
+  /^\.env\.[^.]+$/,
+  /\.pem$/,
+  /^credentials\./,
+  /^secrets\./,
+  /\.key$/,
+  /^\.git\/config$/,
+];
+
+const ALLOWED_EXCEPTIONS = [
+  /signing-public-key\.pem$/,
+  /\.env\.example$/,
+  /\.env\.template$/,
+];
+
+/**
+ * Check if a file path is sensitive (should not be read).
+ * @param {string} filePath - Absolute or relative file path
+ * @param {string} cwd - Current working directory
+ * @returns {{ sensitive: boolean, reason: string }}
+ */
+function isSensitivePath(filePath, cwd) {
+  if (!filePath || typeof filePath !== 'string') {
+    return { sensitive: false, reason: '' };
+  }
+
+  // Normalize to relative path
+  let rel;
+  try {
+    rel = relative(cwd, filePath);
+  } catch {
+    rel = filePath;
+  }
+
+  const name = basename(rel);
+
+  // Check allowed exceptions first
+  for (const pattern of ALLOWED_EXCEPTIONS) {
+    if (pattern.test(name) || pattern.test(rel)) {
+      return { sensitive: false, reason: '' };
+    }
+  }
+
+  // Check sensitive patterns against both filename and relative path
+  for (const pattern of SENSITIVE_PATTERNS) {
+    if (pattern.test(name) || pattern.test(rel)) {
+      return {
+        sensitive: true,
+        reason: `File matches sensitive pattern: ${pattern.source}`,
+      };
+    }
+  }
+
+  return { sensitive: false, reason: '' };
+}
+
+async function main() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  try {
+    const event = JSON.parse(input);
+    const toolInput = event.tool_input || {};
+    const filePath = toolInput.file_path || '';
+    const cwd = event.cwd || process.cwd();
+
+    const result = isSensitivePath(filePath, cwd);
+
+    if (result.sensitive) {
+      process.stdout.write(JSON.stringify({
+        decision: 'block',
+        reason: `[Article IV] ${result.reason}. Use environment variables or secure vaults instead of reading sensitive files directly.`,
+      }));
+      return;
+    }
+
+    process.stdout.write(JSON.stringify({ decision: 'allow' }));
+  } catch {
+    process.stdout.write(JSON.stringify({ decision: 'allow' }));
+  }
+}
+
+export { isSensitivePath, SENSITIVE_PATTERNS, ALLOWED_EXCEPTIONS };
+
+// Only run main when executed directly (not imported by tests)
+import { fileURLToPath } from 'url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main();
+}

package/framework/hooks/settings.json

@@ -17,6 +17,15 @@
       }
     ],
     "PreToolUse": [
+      {
+        "matcher": "Read",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node chati.dev/hooks/read-protection.js"
+          }
+        ]
+      },
       {
         "matcher": "Write|Edit",
         "hooks": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "AI-Powered Multi-Agent Orchestration System — Structured vibe coding for Full Stack Development",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
   "scripts": {
     "start": "node bin/chati.js",
     "bundle": "node scripts/bundle-framework.js",
-    "prepublishOnly": "node scripts/bundle-framework.js",
+    "prepublishOnly": "node scripts/bundle-framework.js && node scripts/validate-package.js && node scripts/sign-manifest.js",
     "test": "node --test test/**/*.test.js",
     "lint": "eslint src/ bin/",
     "lint:fix": "eslint src/ bin/ --fix"

package/scripts/generate-signing-key.js

@@ -0,0 +1,33 @@
+/**
+ * One-time keypair generation for Ed25519 manifest signing.
+ * Run: node scripts/generate-signing-key.js
+ *
+ * Private key: .signing-key.pem (GITIGNORED — never commit)
+ * Public key:  src/installer/signing-public-key.pem (committed — distributed with package)
+ */
+import { generateKeyPairSync } from 'crypto';
+import { writeFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const privateKeyPath = join(__dirname, '..', '.signing-key.pem');
+const publicKeyPath = join(__dirname, '..', 'src', 'installer', 'signing-public-key.pem');
+
+if (existsSync(privateKeyPath)) {
+  console.error('Private key already exists at .signing-key.pem');
+  console.error('Delete it first if you want to regenerate.');
+  process.exit(1);
+}
+
+const { publicKey, privateKey } = generateKeyPairSync('ed25519', {
+  publicKeyEncoding: { type: 'spki', format: 'pem' },
+  privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+});
+
+writeFileSync(privateKeyPath, privateKey);
+writeFileSync(publicKeyPath, publicKey);
+
+console.log('Ed25519 keypair generated.');
+console.log(`  Private: .signing-key.pem (GITIGNORED)`);
+console.log(`  Public:  src/installer/signing-public-key.pem`);

package/scripts/semantic-lint.js

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+
+/**
+ * Semantic Linter — Validates cross-reference consistency across the framework.
+ *
+ * Goes beyond structural validation (validate-agents, validate-tasks) to check
+ * semantic consistency: entity registry integrity, domain-agent alignment,
+ * workflow references, i18n completeness, schema existence, constitution articles.
+ *
+ * Exports:
+ *   semanticLint(frameworkDir) → { errors, warnings, checks, passed }
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Check that all paths in entity-registry.yaml point to existing files.
+ */
+function checkEntityRegistryIntegrity(frameworkDir, results) {
+  results.checks++;
+  const registryPath = join(frameworkDir, 'data', 'entity-registry.yaml');
+
+  if (!existsSync(registryPath)) {
+    results.errors.push('Entity registry not found at data/entity-registry.yaml');
+    return;
+  }
+
+  const registry = yaml.load(readFileSync(registryPath, 'utf-8'));
+  const entities = registry.entities || {};
+  let total = 0;
+  let found = 0;
+  const missing = [];
+
+  for (const category of Object.values(entities)) {
+    for (const [name, entity] of Object.entries(category)) {
+      if (!entity.path) continue;
+      total++;
+
+      // Path in registry is relative to project root (e.g., "chati.dev/agents/...")
+      // Strip "chati.dev/" prefix to get path relative to frameworkDir
+      const relPath = entity.path.replace(/^chati\.dev\//, '');
+      if (existsSync(join(frameworkDir, relPath))) {
+        found++;
+      } else {
+        missing.push(`${name}: ${entity.path}`);
+      }
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+    results.details.push(`Entity registry integrity: ${found}/${total} paths exist`);
+  } else {
+    results.errors.push(`Entity registry: ${missing.length} missing files — ${missing.slice(0, 5).join('; ')}${missing.length > 5 ? '...' : ''}`);
+  }
+}
+
+/**
+ * Check that each agent in domains/agents/ has a corresponding agent definition file.
+ */
+function checkDomainAgentAlignment(frameworkDir, results) {
+  results.checks++;
+  const domainsDir = join(frameworkDir, 'domains', 'agents');
+
+  if (!existsSync(domainsDir)) {
+    results.errors.push('Domain agents directory not found at domains/agents/');
+    return;
+  }
+
+  const domainFiles = readdirSync(domainsDir).filter(f => f.endsWith('.yaml'));
+  const mismatches = [];
+
+  for (const file of domainFiles) {
+    const agentName = basename(file, '.yaml');
+
+    // orchestrator has a different path
+    if (agentName === 'orchestrator') {
+      if (!existsSync(join(frameworkDir, 'orchestrator', 'chati.md'))) {
+        mismatches.push('orchestrator');
+      }
+      continue;
+    }
+
+    // Other agents: check all category dirs
+    const agentDirs = ['agents/planning', 'agents/quality', 'agents/build', 'agents/deploy'];
+    const found = agentDirs.some(dir =>
+      existsSync(join(frameworkDir, dir, `${agentName}.md`))
+    );
+
+    if (!found) {
+      mismatches.push(agentName);
+    }
+  }
+
+  if (mismatches.length === 0) {
+    results.passed++;
+    results.details.push(`Domain-agent alignment: ${domainFiles.length}/${domainFiles.length} agents matched`);
+  } else {
+    results.errors.push(`Domain-agent mismatch: ${mismatches.join(', ')} have domain YAML but no agent .md`);
+  }
+}
+
+/**
+ * Check that i18n files have consistent keys across all languages.
+ */
+function checkI18nCompleteness(frameworkDir, results) {
+  results.checks++;
+  const i18nDir = join(frameworkDir, 'i18n');
+
+  if (!existsSync(i18nDir)) {
+    results.errors.push('i18n directory not found');
+    return;
+  }
+
+  const languages = ['en', 'pt', 'es', 'fr'];
+  const keysByLang = {};
+
+  for (const lang of languages) {
+    const filePath = join(i18nDir, `${lang}.yaml`);
+    if (!existsSync(filePath)) {
+      results.errors.push(`i18n file missing: ${lang}.yaml`);
+      return;
+    }
+
+    const content = yaml.load(readFileSync(filePath, 'utf-8'));
+    keysByLang[lang] = flattenKeys(content);
+  }
+
+  // Use 'en' as reference
+  const refKeys = new Set(keysByLang.en);
+  const missingByLang = {};
+
+  for (const lang of languages) {
+    if (lang === 'en') continue;
+    const langKeys = new Set(keysByLang[lang]);
+
+    for (const key of refKeys) {
+      // Skip non-translatable keys
+      if (key === 'language' || key === 'name') continue;
+
+      if (!langKeys.has(key)) {
+        if (!missingByLang[lang]) missingByLang[lang] = [];
+        missingByLang[lang].push(key);
+      }
+    }
+  }
+
+  const totalMissing = Object.values(missingByLang).reduce((sum, arr) => sum + arr.length, 0);
+
+  if (totalMissing === 0) {
+    results.passed++;
+    results.details.push(`i18n completeness: all ${languages.length} languages have consistent keys`);
+  } else {
+    for (const [lang, keys] of Object.entries(missingByLang)) {
+      results.warnings.push(`i18n: '${lang}' missing ${keys.length} key(s): ${keys.slice(0, 3).join(', ')}${keys.length > 3 ? '...' : ''}`);
+    }
+    results.passed++; // warnings don't fail the check
+  }
+}
+
+/**
+ * Check that all expected schema files exist.
+ */
+function checkSchemaExistence(frameworkDir, results) {
+  results.checks++;
+  const schemasDir = join(frameworkDir, 'schemas');
+  const expectedSchemas = [
+    'session.schema.json', 'config.schema.json', 'task.schema.json',
+    'context.schema.json', 'memory.schema.json',
+  ];
+
+  const missing = expectedSchemas.filter(s => !existsSync(join(schemasDir, s)));
+
+  if (missing.length === 0) {
+    results.passed++;
+    results.details.push(`Schema existence: ${expectedSchemas.length}/${expectedSchemas.length} schemas found`);
+  } else {
+    results.errors.push(`Missing schemas: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Check constitution has >= 17 articles.
+ */
+function checkConstitution(frameworkDir, results) {
+  results.checks++;
+  const constitutionPath = join(frameworkDir, 'constitution.md');
+
+  if (!existsSync(constitutionPath)) {
+    results.errors.push('constitution.md not found');
+    return;
+  }
+
+  const content = readFileSync(constitutionPath, 'utf-8');
+  const articleCount = (content.match(/^## Article/gm) || []).length;
+
+  if (articleCount >= 17) {
+    results.passed++;
+    results.details.push(`Constitution: ${articleCount} articles found`);
+  } else {
+    results.errors.push(`Constitution has only ${articleCount} articles (expected >= 17)`);
+  }
+}
+
+/**
+ * Check that workflow files reference valid agents.
+ */
+function checkWorkflowAgentRefs(frameworkDir, results) {
+  results.checks++;
+  const workflowsDir = join(frameworkDir, 'workflows');
+
+  if (!existsSync(workflowsDir)) {
+    results.errors.push('workflows/ directory not found');
+    return;
+  }
+
+  // Collect known agent names
+  const knownAgents = new Set(['orchestrator']);
+  const agentDirs = ['agents/planning', 'agents/quality', 'agents/build', 'agents/deploy'];
+  for (const dir of agentDirs) {
+    const fullDir = join(frameworkDir, dir);
+    if (!existsSync(fullDir)) continue;
+    for (const file of readdirSync(fullDir)) {
+      if (file.endsWith('.md')) {
+        knownAgents.add(basename(file, '.md'));
+      }
+    }
+  }
+
+  const workflowFiles = readdirSync(workflowsDir).filter(f => f.endsWith('.yaml'));
+  const unknownRefs = [];
+
+  for (const file of workflowFiles) {
+    const content = readFileSync(join(workflowsDir, file), 'utf-8');
+    // Look for agent references in YAML (agent: xxx or - xxx in steps)
+    const agentRefs = content.match(/agent:\s*(\S+)/g) || [];
+    for (const ref of agentRefs) {
+      const agentName = ref.replace('agent:', '').trim();
+      if (agentName && !knownAgents.has(agentName)) {
+        unknownRefs.push(`${file}: ${agentName}`);
+      }
+    }
+  }
+
+  if (unknownRefs.length === 0) {
+    results.passed++;
+    results.details.push(`Workflow-agent references: ${workflowFiles.length} workflows, all agents valid`);
+  } else {
+    results.warnings.push(`Unknown agent refs in workflows: ${unknownRefs.join('; ')}`);
+    results.passed++; // warnings don't fail
+  }
+}
+
+/**
+ * Flatten a nested object into dot-notation keys.
+ */
+function flattenKeys(obj, prefix = '') {
+  const keys = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      keys.push(...flattenKeys(value, fullKey));
+    } else {
+      keys.push(fullKey);
+    }
+  }
+  return keys;
+}
+
+/**
+ * Run all semantic lint checks.
+ * @param {string} frameworkDir - Path to the framework directory (chati.dev/)
+ * @returns {{ errors: string[], warnings: string[], details: string[], checks: number, passed: number }}
+ */
+export function semanticLint(frameworkDir) {
+  const results = { errors: [], warnings: [], details: [], checks: 0, passed: 0 };
+
+  checkEntityRegistryIntegrity(frameworkDir, results);
+  checkDomainAgentAlignment(frameworkDir, results);
+  checkWorkflowAgentRefs(frameworkDir, results);
+  checkI18nCompleteness(frameworkDir, results);
+  checkSchemaExistence(frameworkDir, results);
+  checkConstitution(frameworkDir, results);
+
+  return results;
+}
+
+/**
+ * Format results for CLI output.
+ */
+function formatResults(results) {
+  const status = results.errors.length === 0 ? 'PASS' : 'FAIL';
+  const lines = [
+    `Semantic Lint: ${status} (${results.passed}/${results.checks} checks, ${results.warnings.length} warnings, ${results.errors.length} errors)`,
+    '',
+  ];
+
+  for (const detail of results.details) {
+    lines.push(`  ✓ ${detail}`);
+  }
+
+  for (const warning of results.warnings) {
+    lines.push(`  ⚠ ${warning}`);
+  }
+
+  for (const error of results.errors) {
+    lines.push(`  ✗ ${error}`);
+  }
+
+  return lines.join('\n');
+}
+
+// CLI entry point
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const frameworkDir = join(__dirname, '..', '..', '..', 'chati.dev');
+  const results = semanticLint(frameworkDir);
+
+  console.log(formatResults(results));
+
+  if (results.errors.length > 0) {
+    process.exit(1);
+  }
+}

package/scripts/sign-manifest.js

@@ -0,0 +1,53 @@
+/**
+ * Sign the framework manifest with Ed25519.
+ * Generates manifest.json (file hashes) + manifest.sig (signature).
+ *
+ * Run: node scripts/sign-manifest.js
+ * Requires: .signing-key.pem (generated by generate-signing-key.js)
+ */
+import { sign, createPrivateKey } from 'crypto';
+import { readFileSync, writeFileSync, readdirSync, existsSync } from 'fs';
+import { join, dirname, relative } from 'path';
+import { fileURLToPath } from 'url';
+import { generateManifest } from '../src/installer/manifest.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const frameworkDir = join(__dirname, '..', 'framework');
+const privateKeyPath = join(__dirname, '..', '.signing-key.pem');
+
+if (!existsSync(frameworkDir)) {
+  console.error('Framework directory not found. Run bundle-framework.js first.');
+  process.exit(1);
+}
+
+if (!existsSync(privateKeyPath)) {
+  console.warn('No signing key found at .signing-key.pem — skipping manifest signing.');
+  process.exit(0);
+}
+
+function collectFiles(dir, base = dir) {
+  let files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files = files.concat(collectFiles(full, base));
+    } else if (entry.name !== 'manifest.json' && entry.name !== 'manifest.sig') {
+      files.push(relative(base, full));
+    }
+  }
+  return files.sort();
+}
+
+const files = collectFiles(frameworkDir);
+const version = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')).version;
+const manifest = generateManifest(frameworkDir, files, version);
+
+const manifestJson = JSON.stringify(manifest, Object.keys(manifest).sort(), 2);
+
+const privateKey = createPrivateKey(readFileSync(privateKeyPath));
+const signature = sign(null, Buffer.from(manifestJson), privateKey);
+
+writeFileSync(join(frameworkDir, 'manifest.json'), manifestJson + '\n');
+writeFileSync(join(frameworkDir, 'manifest.sig'), signature.toString('base64'));
+
+console.log(`Signed manifest: ${Object.keys(manifest.files).length} files, v${version}`);

package/scripts/validate-package.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+/**
+ * Package Completeness Validator
+ *
+ * Validates that the npm package has all required files before publishing.
+ * Run as part of prepublishOnly (after bundle, before sign-manifest).
+ *
+ * Exports:
+ *   validatePackage(packageRoot) → { errors, warnings, checks, passed }
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Expected directories in framework/ (must match bundle-framework.js)
+ */
+const EXPECTED_BUNDLE_DIRS = [
+  'orchestrator',
+  'agents/planning', 'agents/quality', 'agents/build', 'agents/deploy',
+  'templates', 'workflows', 'quality-gates',
+  'schemas', 'frameworks', 'intelligence', 'patterns',
+  'hooks', 'domains',
+  'i18n', 'migrations', 'data',
+  'tasks', 'context',
+];
+
+const EXPECTED_ROOT_FILES = ['constitution.md', 'config.yaml'];
+
+const SENSITIVE_FILES = ['.signing-key.pem', '.env', '.env.local', '.env.production'];
+
+/**
+ * Validate that framework/ directory exists.
+ */
+function checkFrameworkExists(packageRoot, results) {
+  results.checks++;
+  const frameworkDir = join(packageRoot, 'framework');
+  if (existsSync(frameworkDir)) {
+    results.passed++;
+  } else {
+    results.errors.push('framework/ directory not found. Run `npm run bundle` first.');
+  }
+}
+
+/**
+ * Validate all expected bundle directories exist.
+ */
+function checkBundledDirs(packageRoot, results) {
+  results.checks++;
+  const frameworkDir = join(packageRoot, 'framework');
+  if (!existsSync(frameworkDir)) return;
+
+  const missing = [];
+  for (const dir of EXPECTED_BUNDLE_DIRS) {
+    if (!existsSync(join(frameworkDir, dir))) {
+      missing.push(dir);
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Missing framework directories: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Validate root framework files exist.
+ */
+function checkRootFiles(packageRoot, results) {
+  results.checks++;
+  const frameworkDir = join(packageRoot, 'framework');
+  if (!existsSync(frameworkDir)) return;
+
+  const missing = [];
+  for (const file of EXPECTED_ROOT_FILES) {
+    if (!existsSync(join(frameworkDir, file))) {
+      missing.push(file);
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Missing framework root files: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Check that no sensitive files leaked into the bundle.
+ */
+function checkNoSensitiveFiles(packageRoot, results) {
+  results.checks++;
+  const found = [];
+
+  // Only check inside publishable directories (bin/, src/, assets/, framework/, scripts/)
+  // Root-level files like .signing-key.pem are excluded by package.json "files" field
+  const publishableDirs = ['framework', 'src', 'scripts', 'bin', 'assets'];
+  for (const file of SENSITIVE_FILES) {
+    for (const dir of publishableDirs) {
+      if (existsSync(join(packageRoot, dir, file))) {
+        found.push(`${dir}/${file}`);
+      }
+    }
+  }
+
+  if (found.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Sensitive files found in package: ${found.join(', ')}`);
+  }
+}
+
+/**
+ * Validate that all package.json exports resolve to existing files.
+ */
+function checkExportsResolve(packageRoot, results) {
+  results.checks++;
+  const pkgPath = join(packageRoot, 'package.json');
+  if (!existsSync(pkgPath)) return;
+
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const exports = pkg.exports || {};
+  const missing = [];
+
+  for (const [key, value] of Object.entries(exports)) {
+    const filePath = join(packageRoot, value);
+    if (!existsSync(filePath)) {
+      missing.push(`${key} → ${value}`);
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Unresolved exports: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Validate that bin entry exists.
+ */
+function checkBinExists(packageRoot, results) {
+  results.checks++;
+  const pkgPath = join(packageRoot, 'package.json');
+  if (!existsSync(pkgPath)) return;
+
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  const bin = pkg.bin || {};
+  const missing = [];
+
+  for (const [name, path] of Object.entries(bin)) {
+    if (!existsSync(join(packageRoot, path))) {
+      missing.push(`${name} → ${path}`);
+    }
+  }
+
+  if (missing.length === 0) {
+    results.passed++;
+  } else {
+    results.errors.push(`Missing bin entries: ${missing.join(', ')}`);
+  }
+}
+
+/**
+ * Compare entity count in registry vs actual files in framework/.
+ */
+function checkEntityCount(packageRoot, results) {
+  results.checks++;
+  const registryPath = join(packageRoot, 'framework', 'data', 'entity-registry.yaml');
+  if (!existsSync(registryPath)) {
+    results.warnings.push('Entity registry not found in framework/data/ — skipping count check.');
+    results.passed++;
+    return;
+  }
+
+  // Count files in framework/ recursively (excluding manifest.json, manifest.sig)
+  let fileCount = 0;
+  function countFiles(dir) {
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          countFiles(join(dir, entry.name));
+        } else if (entry.name !== 'manifest.json' && entry.name !== 'manifest.sig') {
+          fileCount++;
+        }
+      }
+    } catch { /* skip unreadable dirs */ }
+  }
+
+  countFiles(join(packageRoot, 'framework'));
+
+  if (fileCount > 0) {
+    results.passed++;
+  } else {
+    results.errors.push('Framework directory is empty (0 files).');
+  }
+}
+
+/**
+ * Validate the npm package completeness.
+ * @param {string} packageRoot - Root of the package (packages/chati-dev/)
+ * @returns {{ errors: string[], warnings: string[], checks: number, passed: number }}
+ */
+export function validatePackage(packageRoot) {
+  const results = { errors: [], warnings: [], checks: 0, passed: 0 };
+
+  checkFrameworkExists(packageRoot, results);
+  checkBundledDirs(packageRoot, results);
+  checkRootFiles(packageRoot, results);
+  checkNoSensitiveFiles(packageRoot, results);
+  checkExportsResolve(packageRoot, results);
+  checkBinExists(packageRoot, results);
+  checkEntityCount(packageRoot, results);
+
+  return results;
+}
+
+/**
+ * Format results for CLI output.
+ */
+function formatResults(results) {
+  const status = results.errors.length === 0 ? 'PASS' : 'FAIL';
+  const lines = [
+    `Package Validation: ${status} (${results.passed}/${results.checks} checks passed)`,
+  ];
+
+  if (results.errors.length > 0) {
+    lines.push('');
+    lines.push('Errors:');
+    results.errors.forEach(e => lines.push(`  ✗ ${e}`));
+  }
+
+  if (results.warnings.length > 0) {
+    lines.push('');
+    lines.push('Warnings:');
+    results.warnings.forEach(w => lines.push(`  ⚠ ${w}`));
+  }
+
+  return lines.join('\n');
+}
+
+// CLI entry point
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const packageRoot = join(__dirname, '..');
+  const results = validatePackage(packageRoot);
+
+  console.log(formatResults(results));
+
+  if (results.errors.length > 0) {
+    process.exit(1);
+  }
+}

package/src/autonomy/autonomous-gate.js

@@ -17,7 +17,7 @@ export const GATE_RESULTS = {
 // Minimum passing scores per agent (conservative: 90 default)
 const GATE_THRESHOLDS = {
   'qa-planning': 95,        // Highest — gates planning→build transition
-  'qa-implementation': 90,  // Gates build→deploy transition
+  'qa-implementation': 95,  // Gates build→deploy transition
   'brief': 90,              // Requirements are critical
   'detail': 90,
   'architect': 90,

package/src/gates/g4-qa-implementation.js

@@ -6,9 +6,9 @@
  * benchmarks are met, and security scans are clean.
  *
  * Verdicts:
- *   PASS     — All criteria met, score >= 90%
- *   CONCERNS — Score 85-90%, minor issues noted
- *   FAIL     — Score < 85% or critical issues
+ *   PASS     — All criteria met, score >= 95%
+ *   CONCERNS — Score 90-95%, minor issues noted
+ *   FAIL     — Score < 90% or critical issues
  *   WAIVED   — Human explicitly overrode
  */
 
@@ -127,11 +127,11 @@ export class QAImplementationGate extends GateBase {
       return QA_IMPL_VERDICTS.FAIL;
     }
 
-    if (score >= 90 && evidence.allTestCriteriaMet) {
+    if (score >= 95 && evidence.allTestCriteriaMet) {
       return QA_IMPL_VERDICTS.PASS;
     }
 
-    if (score >= 85) {
+    if (score >= 90) {
       return QA_IMPL_VERDICTS.CONCERNS;
     }
 
@@ -151,7 +151,7 @@ export class QAImplementationGate extends GateBase {
       'No critical bugs open',
       'Performance benchmarks met',
       'Security scan clean',
-      'QA-Implementation score >= 90',
+      'QA-Implementation score >= 95',
     ];
 
     const criteriaResults = [];
@@ -192,10 +192,10 @@ export class QAImplementationGate extends GateBase {
     }
 
     // Check score
-    if (evidence.qaImplHandoff && evidence.qaImplHandoff.score >= 90) {
-      criteriaResults.push('QA-Implementation score >= 90');
+    if (evidence.qaImplHandoff && evidence.qaImplHandoff.score >= 95) {
+      criteriaResults.push('QA-Implementation score >= 95');
     } else if (evidence.qaImplHandoff) {
-      warnings.push(`QA-Impl score: ${evidence.qaImplHandoff.score} (need >= 90)`);
+      warnings.push(`QA-Impl score: ${evidence.qaImplHandoff.score} (need >= 95)`);
     }
 
     const score = allCriteria.length > 0

package/src/installer/core.js

@@ -1,9 +1,10 @@
-import { mkdirSync, writeFileSync, copyFileSync, existsSync } from 'fs';
+import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { IDE_CONFIGS } from '../config/ide-configs.js';
 import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
 import { generateSessionYaml, generateConfigYaml, generateClaudeMd, generateClaudeLocalMd } from './templates.js';
+import { verifyManifest } from './manifest.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -19,6 +20,20 @@ const FRAMEWORK_SOURCE = existsSync(BUNDLED_SOURCE) ? BUNDLED_SOURCE : MONOREPO_
 export async function installFramework(config) {
   const { targetDir, projectType, language, selectedIDEs, selectedMCPs, projectName, version } = config;
 
+  // 0. Verify framework signature (supply chain protection)
+  const manifestPath = join(FRAMEWORK_SOURCE, 'manifest.json');
+  const sigPath = join(FRAMEWORK_SOURCE, 'manifest.sig');
+
+  if (existsSync(manifestPath) && existsSync(sigPath)) {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    const signature = readFileSync(sigPath, 'utf-8').trim();
+    const result = verifyManifest(manifest, signature);
+
+    if (!result.valid && result.reason === 'signature-mismatch') {
+      throw new Error('Framework signature verification failed. Package may have been tampered with.');
+    }
+  }
+
   // 1. Create .chati/ session directory
   createDir(join(targetDir, '.chati'));
   writeFileSync(

package/src/installer/manifest.js

@@ -1,10 +1,25 @@
 import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { verify as cryptoVerify, createPublicKey } from 'crypto';
 import { hashFile } from './file-hasher.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
 const MANIFEST_FILENAME = 'manifest.json';
 const MANIFEST_DIR = '.chati';
 
+/**
+ * Load the Ed25519 public key for signature verification.
+ * Returns null if key file doesn't exist (dev environment).
+ */
+let SIGNING_PUBLIC_KEY = null;
+try {
+  const pemPath = join(__dirname, 'signing-public-key.pem');
+  SIGNING_PUBLIC_KEY = createPublicKey(readFileSync(pemPath));
+} catch {
+  // Public key not available (dev environment without key generation)
+}
+
 /**
  * Generate a manifest for a set of files under a root directory.
  *
@@ -115,3 +130,20 @@ export function compareManifests(oldManifest, newManifest) {
 
   return { added, removed, modified, unchanged };
 }
+
+/**
+ * Verify a manifest signature using the embedded Ed25519 public key.
+ *
+ * @param {object} manifest - The manifest object to verify
+ * @param {string} signatureBase64 - Base64-encoded Ed25519 signature
+ * @returns {{ valid: boolean, reason: string }}
+ */
+export function verifyManifest(manifest, signatureBase64) {
+  if (!SIGNING_PUBLIC_KEY) return { valid: false, reason: 'no-public-key' };
+
+  const manifestJson = JSON.stringify(manifest, Object.keys(manifest).sort(), 2);
+  const signature = Buffer.from(signatureBase64, 'base64');
+
+  const valid = cryptoVerify(null, Buffer.from(manifestJson), SIGNING_PUBLIC_KEY, signature);
+  return { valid, reason: valid ? 'ok' : 'signature-mismatch' };
+}

package/src/installer/signing-public-key.pem

@@ -0,0 +1,3 @@
+-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEA8thWGs1GHKpeJyUTejpBwp8TZ7iZiN3vDxGDoQf8dMs=
+-----END PUBLIC KEY-----

package/src/installer/validator.js

@@ -1,5 +1,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
+import { hashFile } from './file-hasher.js';
+import { loadManifest } from './manifest.js';
 
 /**
  * Validate chati.dev installation
@@ -17,6 +19,7 @@ export async function validateInstallation(targetDir) {
     registry: { pass: false, details: [] },
     memories: { pass: false, details: [] },
     context: { pass: false, details: [] },
+    integrity: { pass: false, details: [] },
     total: 0,
     passed: 0,
   };
@@ -166,5 +169,35 @@ export async function validateInstallation(targetDir) {
   results.total += 1;
   if (results.context.pass) results.passed += 1;
 
+  // Check integrity: verify installed files match manifest hashes
+  const manifest = loadManifest(targetDir);
+  if (manifest && manifest.files) {
+    let matched = 0;
+    let mismatched = 0;
+    const mismatches = [];
+
+    for (const [relPath, entry] of Object.entries(manifest.files)) {
+      const absPath = join(targetDir, 'chati.dev', relPath);
+      if (existsSync(absPath)) {
+        const currentHash = hashFile(absPath);
+        if (currentHash === entry.hash) {
+          matched++;
+        } else {
+          mismatched++;
+          mismatches.push(relPath);
+        }
+      }
+    }
+
+    results.integrity.pass = mismatched === 0;
+    results.integrity.details.push({ matched, mismatched, mismatches });
+  } else {
+    // No manifest = skip integrity (first install or dev environment)
+    results.integrity.pass = true;
+    results.integrity.details.push({ skipped: true, reason: 'no-manifest' });
+  }
+  results.total += 1;
+  if (results.integrity.pass) results.passed += 1;
+
   return results;
 }

package/src/memory/agent-memory.js

@@ -215,6 +215,26 @@ export function searchAgentMemories(projectDir, query) {
   return results;
 }
 
+/**
+ * Get top memory entries for an agent, sorted by confidence.
+ * Used by orchestrator/agents for programmatic memory access.
+ * @param {string} projectDir - Project directory
+ * @param {string} agentName - Agent name
+ * @param {number} [limit=5] - Max entries to return
+ * @returns {object[]} Top entries sorted by confidence (high → medium → low)
+ */
+export function getTopMemories(projectDir, agentName, limit = 5) {
+  const memory = readAgentMemory(projectDir, agentName);
+  if (!memory.loaded) return [];
+
+  const confidenceOrder = { high: 3, medium: 2, low: 1 };
+  const sorted = [...memory.entries].sort((a, b) => {
+    return (confidenceOrder[b.confidence] || 2) - (confidenceOrder[a.confidence] || 2);
+  });
+
+  return sorted.slice(0, limit);
+}
+
 /**
  * Get memory stats per agent.
  * @param {string} projectDir - Project directory

package/src/orchestrator/pipeline-manager.js

@@ -26,7 +26,7 @@ export const AGENT_STATUS = {
  * Required QA score for phase transitions.
  */
 const QA_PLANNING_THRESHOLD = 95;
-const QA_IMPLEMENTATION_THRESHOLD = 90;
+const QA_IMPLEMENTATION_THRESHOLD = 95;
 
 /**
  * Initialize a new pipeline for a project.