@dommaker/harness 0.13.0 → 0.13.2

package/CHANGELOG.md

@@ -0,0 +1,169 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [0.13.0] - 2026-05-26
+
+### Breaking
+- **prompt-injection 迁移**: `formatConstraintsForPrompt()` + `AgentRole` + `ROLE_TRIGGERS` 迁至 `@dommaker/studio-shared`。harness 保留 deprecated re-export。
+- **`buildConstraintPrompt()` 移除**: 孤儿函数从未消费，且截断 80 字符。已删除。
+- **死亡代码清理**: `changelog_freshness` 孤儿约束、`changelog_missing` DiffType、`sync-docs --changelog`、`auto_append` config。
+
+### Added
+- **`detectSourceRoots()`**: 统一源码目录发现。支持 monorepo (packages/*, apps/*) 和单 repo (src/, lib/)。替代 5 种分散硬编码。
+- **`harness constraints --json`**: 约束元数据导出（version, hash, counts, textSize）。
+- **`harness init` → CLAUDE.md**: 写入标记段（HARNESS_CONSTRAINTS），含约束列表和版本号。
+- **`module_creation` 触发**: `detectTrigger()` 识别新目录文件变更。
+- **11 条约束补 `promptInjection`**: `no_code_without_test` 等从不可见变为 CLAUDE.md + Agent prompt 可见。
+
+### Changed
+- **内置 Freshness 泛化**: 10 项 harness 特化 → 2 项通用（CONTEXT.md + CHANGELOG 版本）。
+- **`findSourceFiles` 跳过 `index.ts`**: 与 `scanSourceModules` 一致。
+- **管线运行时去重**: CLAUDE.md 已有约束段时注入引用而非全量文本。
+- **预设 `required_dirs` 自动发现**: 不硬编码 `['src']`。
+
+### Fixed
+- `@jest/globals` 缺失 → 安装后 119/119 测试通过。
+- monorepo 工程 `harness init` 后全部检测盲过。
+- `index.ts` 导致 `docs_freshness` 误报。
+
+## [0.12.2] - 2026-05-19
+
+### Added
+- **fix_the_problem_not_the_gate guideline**: 质量门阻断时修复代码，不修复门禁
+
+## [0.12.1] - 2026-05-19
+
+### Added
+- **first_principles_first guideline**：第一性优先分析方法论。injectPrompt=true。
+- **5 behavioral guidelines**：surgical_changes_only / no_model_for_deterministic / no_conflict_blending / read_before_write / follow_conventions。全部 injectPrompt=true。
+- **2 增强 promptInjection**：no_performative_agreement / simplest_solution_first 补充 prompt 注入文本。
+- **interceptor 收敛**：无 executor 时 fallback 到 constraint.check(ctx)。
+
+### Changed
+- **docs_freshness 升级为 iron_law**：guideline → iron_law (blocking)。
+- **CONTEXT.md 删除**：17 个文件。目录描述集中在 CLAUDE.md Key Subsystems 表。
+- 约束总数：13 Iron Laws + 13 Guidelines + 2 Tips = 28 条。
+- promptInjection 优化：357→80 tokens (75% 缩减)。
+- **约束生命周期修正**：退化基于拦截率（≥10 次检查 + 拦截率 < 30%），不基于日历时间。
+
+## [0.11.0] - 2026-05-03
+
+### Added
+- **6 条新约束**：must_use_worktree / no_fuzzy_completion_claim / no_performative_agreement / two_stage_review_required（Iron Law）+ no_excuse_patterns / yagni_check（Guideline）
+- **meeting_decision_check trigger**：会议决策质量检查
+- **buildConstraintPrompt()**：收集约束 promptInjection 格式化为 Agent system prompt 片段
+- **knowledge/failure CLI**：harness knowledge / harness failure 命令
+- **sync-docs 命令**：文档新鲜度检查 + JSON 输出
+
+### Changed
+- 约束总数：8 Iron Laws → 12，13 Guidelines → 15，共 29 条
+- AI 治理简化：移除冗余 hook/apply，harness 只检测不修复
+- interceptor 修复 + 覆盖率 85.4% + JSDoc
+- `autoEvolve()` 纯计算 API + `evolution/auto-evolve.ts` 新模块
+- `checkConstraints()` 新增 `onTrace` 回调参数
+
+## [0.9.0] - 2026-05-01
+
+### Added
+
+#### Phase 1: 知识引擎核心
+- KnowledgeStore: 知识条目 CRUD + 结构化存储
+- KnowledgeQuery: 语义搜索 + 类型/标签过滤
+- ReferenceTracker: 知识引用关系图谱
+- KnowledgeLinter: 知识质量检查 (完整性/一致性/时效性)
+
+#### Phase 2: 上下文管理
+- TokenBudget: 多级 token 预算分配 (system/user/tool/reserve)
+- SessionCompaction: 会话压缩策略 (摘要/截断/滑动窗口)
+- AgentLifecycle: Agent 状态机 (init→running→paused→completed→failed)
+
+#### Phase 3: 安全护栏
+- InputGuardrail: 输入内容安全检查 (注入检测/敏感信息/格式校验)
+- OutputGuardrail: 输出内容安全检查 (泄露检测/有害内容/格式合规)
+- ToolGuardrail: 工具调用安全检查 (权限验证/参数校验/速率限制)
+- Sandbox: 沙箱执行环境管理 (级别 L1-L4/资源限制/隔离策略)
+
+#### Phase 4: 知识引擎集成
+- KnowledgeService: 统一入口 (Store + Query + Tracker + Linter)
+- 知识生命周期: draft → candidate → validated → canonical → archived
+- 跨项目知识迁移: 模式识别 + 最佳实践提炼
+
+#### Phase 5: 约束重构
+- ConstraintContext 扩展: 新增 isExternalDependency/isExplicitInstruction/isEmergencyFix/isExistingDesign
+- 自定义约束配置: .harness/config.yml 支持 extend_exceptions
+- 约束进化提案: 基于 trace 分析自动生成优化建议
+
+#### Phase 6: 冷启动
+- progressive-loader.ts: 渐进式加载 + worker pool 并发
+- cross-project-checker.ts: 跨项目依赖检查 (异步化)
+- project-config-loader.ts: 项目配置加载 + 约束合并
+
+### Changed
+- SafetyService/ContextService/AgentService 单例导出
+- KnowledgeService 单例导出
+- CLI 新增 harness flow --auto-apply 自动应用低风险提案
+
+## [0.8.4] - 2026-05-01
+
+### Changed
+
+#### 重复代码消除
+- 统一 `execAsync` 到 `utils/exec`：15 个文件的重复定义合并为单一来源
+- 新增 `normalizeTriggers()` 泛型工具函数，消除 10+ 处 `Array.isArray` 重复模式
+- 新增 `delay()` 公共函数，替换 3 处私有 `sleep/delay` 方法
+
+#### 逻辑简化
+- `checker.ts`：60 行 `switch` 例外匹配 → `EXCEPTION_FIELD_MAP` 映射表 + `some()` 一行
+- `checker.ts`：3 个近似循环 → 提取 `matchesTrigger()` + `recordTrace()` 公共方法
+- `interceptor.ts`：触发器规范化 → 复用 `normalizeTriggers`
+- `trace-analyzer.ts` / `performance-analyzer.ts`：5 次/3 次遍历统计 → 单次遍历
+- `failure/recorder.ts`：`getByType`/`getByLevel` 重复过滤 → 提取 `getFiltered()`
+
+#### 健壮性修复
+- 修复 `checker.ts` 中 Guidelines 循环直接引用 `GUIDELINES` 常量的 bug（未使用自定义约束配置）
+- 修复 `project-config-loader.ts` 中 `mergeConstraints()` 的 for 循环缩进错误（方法体脱离类作用域）
+- 修复 `progressive-loader.ts` 中 `delay` 参数名与导入函数冲突
+- 补充 `ConstraintContext` 缺失字段：`isExternalDependency`、`isExplicitInstruction`、`isEmergencyFix`、`isExistingDesign`
+
+#### 性能优化
+- `cross-project-checker.ts`：`execSync`（阻塞式）→ 异步 `runCommand`
+- `progressive-loader.ts` `processBatch`：并发结果顺序不保证 → worker pool 模式保证输入顺序
+
+#### 代码规范
+- `cli/commands/status.ts`：`any` 类型 → `TraceSummary` / `TraceAnomaly`
+- `cross-project-checker.test.ts`：更新 mock 从 `child_process` → `utils/exec`
+- 合并 10+ 处分散的 `import { exec } + promisify(exec)` 为统一导入
+
+> 净减少约 157 行代码，零编译错误，零测试回归
+
+---
+
+## Recent Commits
+
+- feat: add command CLI for blacklist checking (2026-04-29 23:24:07 +0800)
+- feat: add CommandGate for command blacklist (SEC-006) (2026-04-29 23:09:44 +0800)
+- fix: remove deprecated command tests (propose, diagnose, traces) (2026-04-29 01:10:46 +0800)
+- chore: release v0.8.0 (2026-04-28 23:41:32 +0800)
+- docs: decouple Trace section from business logic (2026-04-28 23:39:12 +0800)
+- chore: remove docs and specs directories (moved to .gitignore) (2026-04-28 23:37:35 +0800)
+- chore: ignore docs directory (2026-04-28 23:36:39 +0800)
+- docs: remove deprecated note from README (2026-04-28 23:34:30 +0800)
+- refactor(cli): remove deprecated commands (traces, diagnose, propose) (2026-04-28 23:32:26 +0800)
+- docs: sync CLI commands to README (2026-04-28 23:23:47 +0800)
+- feat(cli): add 5 gate commands - acceptance, performance, security, contract, review (2026-04-28 23:04:33 +0800)
+- chore: ignore specs directory in gitignore (2026-04-28 22:56:59 +0800)
+- chore: ignore specs/templates 目录 (2026-04-28 22:52:51 +0800)
+- feat: 新增覆盖率约束机制 (2026-04-28 22:50:15 +0800)
+- test: 覆盖率达标 85.43%！ (2026-04-28 22:39:48 +0800)
+- test: 覆盖率提升至 84.8% (2026-04-28 22:34:31 +0800)
+- test: 覆盖率提升至 83.93% (2026-04-28 22:29:51 +0800)
+- chore: 清理临时测试文件 (2026-04-28 22:21:01 +0800)
+- test: 覆盖率提升至 84.17% (2026-04-28 22:20:54 +0800)
+- init (2026-04-28 22:11:12 +0800)
+
+---
+
+> 自动生成于 2026-04-30

package/bin/harness-knowledge-capture.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * Harness Knowledge Capture Hook
+ *
+ * Runs as an afterTurn hook in Claude Code.
+ * Detects deep analysis (≥3 source files read) without knowledge-doc output,
+ * and warns the user that knowledge may need to be captured.
+ *
+ * Usage (in settings.json):
+ *   "hooks": {
+ *     "afterTurn": [{
+ *       "command": "node ~/projects/harness/bin/harness-knowledge-capture.js"
+ *     }]
+ *   }
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Read turn data from stdin
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => input += chunk);
+
+process.stdin.on('end', () => {
+  try {
+    const turn = JSON.parse(input);
+    const result = checkTurn(turn);
+    if (result.shouldWarn) {
+      process.stderr.write(`\n${'='.repeat(60)}\n`);
+      process.stderr.write('  ⚠️  可能遗漏了知识沉淀\n');
+      process.stderr.write(`${'='.repeat(60)}\n`);
+      process.stderr.write(`  本回合读取了 ${result.fileReads} 个文件\n`);
+      process.stderr.write(`  但未写入 .harness/knowledge-docs/\n`);
+      process.stderr.write(`\n`);
+      process.stderr.write(`  如果这是深度分析，请执行：\n`);
+      process.stderr.write(`    npx harness knowledge upsert --scope <scope> --file <file> --source claude\n`);
+      process.stderr.write(`${'='.repeat(60)}\n\n`);
+    }
+  } catch (e) {
+    // Silently ignore parse errors — non-JSON input is fine
+  }
+});
+
+function checkTurn(turn) {
+  let fileReads = 0;
+  let knowledgeWrites = 0;
+
+  // Walk through messages looking for tool calls
+  const messages = turn.messages || [turn];
+  for (const msg of messages) {
+    // Claude Code format: tool_uses array
+    if (msg.role === 'assistant' && msg.tool_uses) {
+      for (const tool of msg.tool_uses) {
+        if (isFileRead(tool)) fileReads++;
+        if (isKnowledgeWrite(tool)) knowledgeWrites++;
+      }
+    }
+    // Plain tool_calls format
+    if (msg.tool_calls) {
+      for (const tool of msg.tool_calls) {
+        if (isFileRead(tool)) fileReads++;
+        if (isKnowledgeWrite(tool)) knowledgeWrites++;
+      }
+    }
+    // Messages content with tool use markers
+    if (msg.content && typeof msg.content === 'string') {
+      const readMatches = msg.content.match(/\bRead\b.*/g);
+      if (readMatches) fileReads += readMatches.length;
+    }
+  }
+
+  return {
+    fileReads,
+    knowledgeWrites,
+    shouldWarn: fileReads >= 3 && knowledgeWrites === 0,
+  };
+}
+
+function isFileRead(tool) {
+  const name = (tool.name || tool.function?.name || '').toLowerCase();
+  const isReadTool = ['read', 'glob', 'grep', 'agent'].includes(name);
+  if (!isReadTool) return false;
+
+  const params = tool.parameters || tool.function?.arguments || {};
+  const filePath = params.file_path || params.path || params.pattern || '';
+  // Only count actual source file reads, not config/memory/docs
+  const isSource = /\/(src|packages|apps)\/|\.(ts|tsx|js|jsx|py|go|rs)$/.test(filePath);
+  return isSource;
+}
+
+function isKnowledgeWrite(tool) {
+  const name = (tool.name || tool.function?.name || '').toLowerCase();
+  if (name !== 'write') return false;
+
+  const params = tool.parameters || tool.function?.arguments || {};
+  const filePath = params.file_path || '';
+  return filePath.includes('.harness/knowledge-docs/') || filePath.includes('.harness/knowledge/');
+}

package/bin/harness-knowledge-check.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+/**
+ * Stop hook — check if deep analysis happened without knowledge capture
+ *
+ * Reads state file written by harness-knowledge-track.js.
+ * If EnterPlanMode was called, or Agent(Explore) was spawned, or 10+ unique
+ * directories were Read — and no knowledge files were Written — warn.
+ *
+ * Output: JSON with systemMessage (shown to user)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const STATE_FILE = '/tmp/claude-knowledge-capture-state.json';
+const LOG_FILE = '/tmp/claude-knowledge-hooks.log';
+const EVENTS_FILE = path.join(os.homedir(), 'events', 'studio.jsonl');
+const UNIQUE_DIR_THRESHOLD = 10;
+
+function log(level, message, data) {
+  try {
+    const entry = JSON.stringify({ ts: new Date().toISOString(), level, message, ...data }) + '\n';
+    fs.appendFileSync(LOG_FILE, entry, 'utf-8');
+  } catch {}
+}
+
+try {
+  if (!fs.existsSync(STATE_FILE)) process.exit(0);
+
+  const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+  const deepAnalysis = state.planned || state.explored || state.readDirs.length >= UNIQUE_DIR_THRESHOLD;
+  const missingCapture = !state.captured;
+
+  log('info', 'stop-check', {
+    planned: state.planned, explored: state.explored,
+    readDirsCount: state.readDirs.length, captured: state.captured,
+    deepAnalysis, missingCapture,
+  });
+
+  // Check 1: deep analysis without knowledge capture
+  if (deepAnalysis && missingCapture) {
+    const signals = [];
+    if (state.planned) signals.push('EnterPlanMode called');
+    if (state.explored) signals.push('Agent(Explore) spawned');
+    if (state.readDirs.length >= UNIQUE_DIR_THRESHOLD) signals.push(`${state.readDirs.length} unique directories Read`);
+
+    log('warn', 'missing-capture', { signals });
+
+    const message = [
+      '⚠️  Deep analysis detected but no knowledge captured.',
+      `   Signals: ${signals.join(', ')}`,
+      '',
+      '   To capture:',
+      '   1. Write .harness/knowledge-docs/<scope>.md',
+      '   2. npx harness knowledge upsert --scope <scope> --file <file> --source claude',
+      '',
+      '   Or run `harness knowledge sync-status` to check staleness.',
+    ].join('\n');
+
+    console.log(JSON.stringify({ systemMessage: message }));
+  }
+
+  // Check 2: sensitive file operations without prior Read
+  const sensitiveOps = (state.sensitiveOps || []).filter(op => !op.verified);
+  if (sensitiveOps.length > 0) {
+    log('warn', 'unverified-sensitive-ops', { sensitiveOps });
+
+    const opsList = sensitiveOps.map(op => `   - ${op.tool}: ${op.file}`).join('\n');
+    const message = [
+      '⚠️  File operations on sensitive paths without prior verification.',
+      `   Operations:`,
+      opsList,
+      '',
+      '   These files were moved/edited/written without being Read first.',
+      '   Verify the changes were intentional and correct.',
+      '',
+      '   📋 Rule: feedback_verify_before_move.md — Read before acting on file classification.',
+    ].join('\n');
+
+    console.log(JSON.stringify({ systemMessage: message }));
+  }
+  // Emit session summary event → events-daemon → knowledge extraction pipeline
+  try {
+    const now = Date.now();
+    const durationMs = state.startTime ? now - state.startTime : 0;
+    const durationMin = Math.round(durationMs / 60000);
+    const event = {
+      type: 'session:summary',
+      sessionType: 'development',
+      tool: state.tool || 'unknown',        // claude | codex | opencode | etc
+      timestamp: new Date().toISOString(),
+      durationMs,
+      durationMin,
+      deepAnalysis: state.planned || state.explored || state.readDirs.length >= UNIQUE_DIR_THRESHOLD,
+      knowledgeCaptured: !!state.captured,
+      readDirsCount: state.readDirs.length,
+      planned: state.planned || false,
+      explored: state.explored || false,
+      sensitiveOpsCount: (state.sensitiveOps || []).filter(op => !op.verified).length,
+      turnCount: state.turnCount || 0,
+    };
+    const dir = path.dirname(EVENTS_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(EVENTS_FILE, JSON.stringify(event) + '\n', 'utf-8');
+    log('info', 'session-summary-emitted', event);
+  } catch {}
+
+  // Auto-ingest: scan memory files with ingest:true → call local-rag API
+  // PostToolUse hooks don't fire in interactive mode, so Stop hook handles it
+  try {
+    const MEMORY_DIR = path.join(os.homedir(), '.claude', 'projects', '-root-projects', 'memory');
+    if (fs.existsSync(MEMORY_DIR)) {
+      const files = fs.readdirSync(MEMORY_DIR).filter(f => f.endsWith('.md'));
+      const ingested = [];
+      for (const f of files) {
+        const fp = path.join(MEMORY_DIR, f);
+        const head = fs.readFileSync(fp, 'utf-8').slice(0, 500);
+        if (/^---[\s\S]*?ingest:\s*true[\s\S]*?---/.test(head)) {
+          // Check if already ingested recently (skip if unchanged in last hour)
+          const stat = fs.statSync(fp);
+          const hourAgo = Date.now() - 3600_000;
+          if (stat.mtimeMs > hourAgo) {
+            ingested.push(fp);
+          }
+        }
+      }
+      if (ingested.length > 0) {
+        log('info', 'auto-ingest-start', { count: ingested.length, files: ingested });
+        const { execSync } = require('child_process');
+        const syncScript = '/root/projects/studio/bin/memory-knowledge-sync.js';
+        let successCount = 0;
+        for (const fp of ingested) {
+          try {
+            execSync(`node "${syncScript}" "${fp}"`, { timeout: 10_000, stdio: 'pipe' });
+            successCount++;
+          } catch (e) {
+            log('warn', 'auto-ingest-failed', { file: fp, error: (e.message || String(e)).slice(0, 100) });
+          }
+        }
+        log('info', 'auto-ingest-done', { success: successCount, total: ingested.length });
+      }
+    }
+  } catch {}
+} catch (e) {
+  // Silently ignore errors
+} finally {
+  // Clean up state file for next session
+  try { fs.unlinkSync(STATE_FILE); } catch {}
+}

package/bin/harness-knowledge-track.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse hook — track deep analysis signals
+ *
+ * Updates state file with:
+ *   - planned: EnterPlanMode was called
+ *   - explored: Agent(Explore) was spawned
+ *   - readDirs: Set of unique directories Read was called on
+ *   - captured: Write to .harness/knowledge-docs/ or .harness/knowledge/
+ *   - turnCount: session turn counter
+ *
+ * Usage: PostToolUse hook with matcher "EnterPlanMode|Agent|Read|Write|Write"
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const STATE_FILE = '/tmp/claude-knowledge-capture-state.json';
+const LOG_FILE = '/tmp/claude-knowledge-hooks.log';
+
+function log(level, message, data) {
+  try {
+    const entry = JSON.stringify({ ts: new Date().toISOString(), level, message, ...data }) + '\n';
+    fs.appendFileSync(LOG_FILE, entry, 'utf-8');
+  } catch {}
+}
+
+// Read hook input from stdin
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => input += chunk);
+
+process.stdin.on('end', () => {
+  try {
+    const event = JSON.parse(input);
+    const state = loadState();
+    updateState(state, event);
+    saveState(state);
+  } catch (e) {
+    // Silently ignore parse errors
+  }
+});
+
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+    }
+  } catch {}
+  return { planned: false, explored: false, readDirs: [], captured: false };
+}
+
+function updateState(state, event) {
+  const toolName = event.tool_name || '';
+
+  if (toolName === 'EnterPlanMode') {
+    state.planned = true;
+    log('info', 'planned', { tool: toolName });
+  }
+
+  if (toolName === 'Agent') {
+    const input = event.tool_input || {};
+    if (input.subagent_type === 'Explore') {
+      state.explored = true;
+      log('info', 'explored', { tool: toolName, subagent_type: input.subagent_type });
+    }
+  }
+
+  if (toolName === 'Read') {
+    const input = event.tool_input || {};
+    const filePath = input.file_path || '';
+    const dir = path.dirname(filePath);
+    if (dir && dir !== '.' && dir !== '/' && !state.readDirs.includes(dir)) {
+      state.readDirs.push(dir);
+    }
+  }
+
+  if (toolName === 'Write') {
+    const input = event.tool_input || {};
+    const filePath = input.file_path || '';
+    if (filePath.includes('.harness/knowledge-docs/') || filePath.includes('.harness/knowledge/')) {
+      state.captured = true;
+      log('info', 'captured', { file: filePath });
+    }
+  }
+}
+
+function saveState(state) {
+  try {
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state), 'utf-8');
+  } catch {}
+}

package/bin/harness-knowledge-track.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# PostToolUse hook — track deep analysis + session metrics
+# Matcher: EnterPlanMode|Agent|Read|Write|Edit|Bash (broad coverage)
+# DailyReflection: enriched session:summary events for behavioral analysis
+
+STATE_FILE=/tmp/claude-knowledge-capture-state.json
+INPUT=$(cat)
+
+tool_name=$(echo "$INPUT" | jq -r '.tool_name // ""')
+file_path=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""')
+
+# Init state file if missing (tool: claude|codex|opencode|etc)
+_tool=$(echo "${CLAUDE_CODE_TOOL_NAME:-claude}" | tr '[:upper:]' '[:lower:]')
+[ -f "$STATE_FILE" ] || echo "{\"planned\":false,\"explored\":false,\"readDirs\":[],\"captured\":false,\"turnCount\":0,\"startTime\":$(date +%s)000,\"tool\":\"$_tool\"}" > "$STATE_FILE"
+
+# Always increment turn counter on substantive tools
+case "$tool_name" in
+  EnterPlanMode)
+    jq '.planned = true | .turnCount += 1' "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
+    ;;
+  Agent)
+    # Agent(Explore) spawned → deep analysis signal
+    _agent_type=$(echo "$INPUT" | jq -r '.tool_input.subagent_type // ""')
+    if [ "$_agent_type" = "Explore" ]; then
+      jq '.explored = true | .turnCount += 1' "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
+    fi
+    ;;
+  Read)
+    if [ -n "$file_path" ]; then
+      dir=$(dirname "$file_path")
+      if [ "$dir" != "." ] && [ "$dir" != "/" ]; then
+        jq --arg d "$dir" '.readDirs += [$d] | .readDirs |= unique | .turnCount += 1' "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
+      fi
+    fi
+    ;;
+  Write|Edit)
+    jq '.turnCount += 1' "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
+    case "$file_path" in
+      *.harness/knowledge-docs/*|*.harness/knowledge/*|*/memory/*.md|*/docs/*.md)
+        jq '.captured = true' "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
+        ;;
+    esac
+    ;;
+  Bash)
+    jq '.turnCount += 1' "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
+    ;;
+esac

package/bin/harness-sensitive-check.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# PostToolUse hook — check for operations on sensitive files without prior Read
+#
+# Detects: Bash(mv/rm), Edit, or Write targeting files in bin/, .harness/, or
+# package.json — and checks whether those files were Read earlier in this session.
+#
+# State file is maintained by harness-knowledge-track.sh which tracks all Read calls.
+
+STATE_FILE=/tmp/claude-knowledge-capture-state.json
+SENSITIVE_DIRS="bin/ .harness/"
+
+INPUT=$(cat)
+tool_name=$(echo "$INPUT" | jq -r '.tool_name // ""')
+file_path=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""')
+content=$(echo "$INPUT" | jq -r '.tool_input.content // ""')
+command=$(echo "$INPUT" | jq -r '.tool_input.command // ""')
+
+# Check if this operation targets a sensitive file
+is_sensitive=false
+for dir in $SENSITIVE_DIRS; do
+  case "$file_path" in
+    *$dir*) is_sensitive=true; break ;;
+  esac
+done
+
+# For Bash, check if the command involves mv/rm on sensitive paths
+if [ "$tool_name" = "Bash" ] && [ -n "$command" ]; then
+  for dir in $SENSITIVE_DIRS; do
+    if echo "$command" | grep -qE "(mv|rm|cp|git rm).*$dir"; then
+      is_sensitive=true
+      # Extract target from command for checking
+      file_path=$(echo "$command" | grep -oE "$dir[^ ]*" | head -1)
+      break
+    fi
+  done
+fi
+
+# Only check sensitive operations
+if [ "$is_sensitive" != "true" ] || [ -z "$file_path" ]; then
+  exit 0
+fi
+
+# Check if this file was Read earlier in the session
+if [ -f "$STATE_FILE" ]; then
+  read_dirs=$(jq -r '.readDirs // [] | join(" ")' "$STATE_FILE" 2>/dev/null || echo "")
+
+  # Check if any read_dir is an ancestor of file_path
+  verified=false
+  file_dir=$(dirname "$file_path")
+  for dir in $read_dirs; do
+    case "$file_dir" in
+      "$dir"|"$dir/"*) verified=true; break ;;
+    esac
+  done
+
+  if [ "$verified" != "true" ]; then
+    # Also check if the file itself was explicitly Read (file_path matches a read path)
+    # The track hook only records directories, not individual files — conservative check
+
+    # Emit warning via state file for Stop hook to pick up
+    jq --arg op "$tool_name" --arg fp "$file_path" \
+      '.sensitiveOps += [{"tool":$op,"file":$fp,"verified":false}]' \
+      "$STATE_FILE" > "${STATE_FILE}.tmp" && mv "${STATE_FILE}.tmp" "$STATE_FILE"
+  fi
+fi
+
+exit 0

package/dist/cli/commands/init.js

@@ -496,6 +496,36 @@ custom_constraints:
  * - 如果存在 HARNESS_CONSTRAINTS_START/END 标记，替换标记间内容
  * - 如果不存在标记，在文件末尾追加约束段
  *
+/**
+ * 在 CLAUDE.md 顶部写入 Output Style 段（仅首次创建，后续不覆盖）
+ */
+const OUTPUT_STYLE_SECTION = [
+    '## Output Style',
+    '',
+    'Terse like caveman. Technical substance exact. Only fluff die.',
+    'Drop: articles, filler (just/really/basically), pleasantries (sure/certainly/happy to), hedging.',
+    'Fragments OK. Short synonyms. Code blocks unchanged. Error messages quoted exact.',
+    'Pattern: [thing] [action] [reason]. [next step].',
+    'No sycophantic openers/closing fluff. No emojis or em-dashes.',
+    'Read existing files before writing. Don\'t re-read unless changed.',
+    'Skip files over 100KB unless required.',
+    'Don\'t guess APIs, versions, flags, commit SHAs, or package names. Verify before asserting.',
+    '',
+].join('\n');
+async function setupClaudeMdOutputStyle(projectPath) {
+    const claudeMdPath = path.join(projectPath, 'CLAUDE.md');
+    try {
+        const content = await fs.readFile(claudeMdPath, 'utf-8');
+        if (content.includes('## Output Style'))
+            return; // 已存在，不覆盖
+        const newContent = OUTPUT_STYLE_SECTION + '\n' + content;
+        await fs.writeFile(claudeMdPath, newContent, 'utf-8');
+    }
+    catch {
+        // CLAUDE.md 不存在——setupClaudeMdConstraints 会创建它
+    }
+}
+/**
  * 只写入包含 promptInjection 文本的约束
  */
 async function setupClaudeMdConstraints(projectPath) {
@@ -589,9 +619,11 @@ async function setupGovernance(projectPath, level) {
     console.log(chalk_1.default.blue('📋 设置治理文件...'));
     // 1. 生成 CHANGELOG.md
     await createChangelog(projectPath, governance);
-    // 2. 在 CLAUDE.md 中写入/更新 Governance Rules 约束段
+    // 2. 在 CLAUDE.md 中写入 Output Style 段（仅在不存在时创建）
+    await setupClaudeMdOutputStyle(projectPath);
+    // 3. 在 CLAUDE.md 中写入/更新 Governance Rules 约束段
     await setupClaudeMdConstraints(projectPath);
-    // 3. 生成 CONTEXT.md 文件
+    // 4. 生成 CONTEXT.md 文件
     const contextConfig = governance.context_files;
     if (contextConfig?.enabled) {
         let requiredDirs = contextConfig.required_dirs || [];