easy-coding-harness 0.10.0-beta.1 → 0.10.0-beta.3

package/CHANGELOG.md

@@ -6,6 +6,34 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.10.0-beta.3
+
+- TDD 业务任务的 `VERIFICATION` 门禁收口为本地证据：每个仓库（Canonical 场景下每个
+  source task）必须有通过的本地单测，以及达到冻结阈值的本地 JaCoCo changed-line
+  coverage；不再要求远程 GitLab pipeline URL、job identity 或成功状态。
+- `ec-tdd-init` 继续在 TDD 关闭态生成并校验参数化 GitLab TEST-stage job、构建配置、
+  JaCoCo XML 与 readiness receipt，但远程 CI 只作为项目自动化能力，不再触发 Harness
+  中间提交、推送或等待远程结果。
+- beta.1/beta.2 任务中已有的 `coverage_scope=gitlab` 记录保持原样并从新验收集合中忽略，
+  因此 pending/failed 远程记录不会阻塞升级后的本地门禁；本地 baseline、阈值、报告
+  指纹及 TDD 生命周期/review 约束保持不变。
+
+## 0.10.0-beta.2
+
+- 新增 `ec-tdd-init`，在 TDD 关闭态初始化或刷新 Java 单测执行、JaCoCo XML、GitLab
+  TEST job、报告 artifact 与 changed-line coverage gate；初始化只建设基础设施，不批量补
+  存量业务单测，也不要求仓库全量覆盖率。
+- 新增 `.easy-coding/tools/easy_coding_tdd_readiness.py` 与覆盖构建、GitLab CI、coverage
+  工具的文件指纹 receipt；项目级 `easy-coding config`、session `set-tdd` 和 ANALYSIS →
+  IMPLEMENT 均在开启/冻结 TDD 前机械校验 readiness，缺失或漂移时只允许先初始化或
+  保持关闭。TDD 关闭的普通 hook 不扫描这些文件。
+- `tdd-init` 作为专用代码任务始终冻结 `tdd_enabled=false`，即使遗留项目/session 或暂停
+  任务请求开启 TDD，也可正常创建和修改 CI，消除“开启 TDD 后又依赖尚未创建 CI”的
+  循环阻塞；初始化完成后仍需用户显式开启 TDD。
+- 配置 schema 升至 5；升级时没有 readiness 的 beta.1 项目与 session TDD 请求迁移为
+  关闭并保留阈值，已冻结活动任务合同不被静默改写。后续业务任务仍只验收相对冻结
+  baseline 的新增/修改生产代码行，默认门槛 90%、测试设计目标接近 100%。
+
 ## 0.10.0-beta.1
 
 - 新增默认关闭的 Java TDD 模式，支持项目级 CLI 配置与 session 覆盖；覆盖率阈值默认

package/README.md

@@ -86,7 +86,7 @@ any stage --[user abort via ec-task-close]--> CLOSED
   ANALYSIS → IMPLEMENT 确认一次，随后各阶段在质量门禁通过后自动推进，`auto` 从开始即
   自动推进。
 - 工作流模式优先级为 session 覆盖 > 项目 `behavior.workflow_mode` > `adaptive`。Adaptive 在 ANALYSIS 结束时根据风险解析、展示并冻结为 `fast`、`standard` 或 `strict`，用户可在风险下限之上调整。
-- Java TDD 默认关闭；优先级为 session 覆盖 > 项目配置 > `false/90%`。开启后在 ANALYSIS → IMPLEMENT 冻结开关与阈值，执行 RED/GREEN/REFACTOR（纯重构使用 characterization GREEN → GREEN），并以同一工具执行本地与 GitLab TEST-stage 差异覆盖率门禁。关闭时不扫描 CI/JaCoCo、不增加命令或提高原工作流验收深度。
+- Java TDD 默认关闭；优先级为 session 覆盖 > 项目配置 > `false/90%`。首次开启前必须运行 `ec-tdd-init`，只建设 JUnit/JaCoCo/GitLab 增量覆盖率基础设施，不补存量业务单测；readiness 通过后才允许显式开启。开启后在 ANALYSIS → IMPLEMENT 冻结开关、baseline 与阈值，只验收本任务新增/修改生产代码行，执行 RED/GREEN/REFACTOR（纯重构使用 characterization GREEN → GREEN），并要求本地单测通过、本地差异覆盖率达到冻结阈值。GitLab TEST-stage job 仍会生成，但远程 pipeline 结果不属于 Harness 验收证据，也不会触发中间提交推送。关闭时普通任务不扫描 CI/JaCoCo、不增加命令或提高原工作流验收深度。
 - 所有新代码任务都完整进入 REVIEW；不同工作流模式只调整各状态内部的上下文加载、执行主体、审查独立性、验证范围和记忆深度，不绕过状态或证据门禁。
 - 显式 `doc` / `analysis` / `report` 只读任务不生成 `test-strategy.md`；展示完整报告后按生效模式进入 COMPLETE，不执行 REVIEW、VERIFICATION 或 MEMORY，也不写任务记忆。
 - `VERIFICATION` 是验证硬门控：Fast 运行最小充分检查，Standard 运行受影响范围检查，
@@ -132,7 +132,7 @@ Canonical Spec 是只读设计源；`.easy-coding/tasks/<task-id>/` 下的 `dev-
 | `easy-coding add-agent` | 给已接入项目追加 Claude Code、Codex 或 Qoder 支持；supermodule 父仓可按已初始化子仓分层追加 |
 | `easy-coding upgrade` | CLI 升级后同步项目内生成文件，生成区覆盖，用户资产保留；supermodule 父仓会同步升级已初始化子仓 |
 | `easy-coding update` | 更新全局 CLI 到最新发布版 |
-| `easy-coding config` | 交互修改当前项目的 Approval、Workflow、Java TDD 与覆盖率阈值 |
+| `easy-coding config` | 交互修改当前项目的 Approval、Workflow、Java TDD 与覆盖率阈值；开启 TDD 前要求 readiness |
 | `easy-coding status` | 查看已安装平台、harness 版本、当前任务状态 |
 | `easy-coding clear` | 移除 harness 安装物，保留 tasks、spec、memory、project.yaml 等用户资产；supermodule 父仓支持交互选择、`--submodules` 和 `--no-submodules` |
 
@@ -151,6 +151,7 @@ Canonical Spec 是只读设计源；`.easy-coding/tasks/<task-id>/` 下的 `dev-
 | `ec-memory` | 写短期记忆，并在超过阈值时沉淀长期记忆 |
 | `ec-task-management` | 任务面板：查看、创建、选择、恢复、交接任务 |
 | `ec-config` | 只读查看或显式修改项目/session 的 Approval、Workflow、TDD 与阈值 |
+| `ec-tdd-init` | 在 TDD 关闭态初始化/刷新 Java changed-line coverage 基础设施，不补存量单测 |
 | `ec-task-close` | 用户主动中断任务并关闭 |
 | `ec-no-harness` | 当前会话仅旁路 Easy Coding Harness，使用原生 Agent 能力 |
 | `ec-git` | 约束 git diff、commit、push、跨仓库提交等交付动作 |
@@ -187,8 +188,11 @@ easy-coding upgrade
 `behavior.approval_mode` 与 `behavior.workflow_mode`；旧 `lite` 映射为 `guard + fast`。
 项目级模式用 `easy-coding config` 修改（要求
 项目 Harness 与 CLI 版本完全一致，否则先执行 `easy-coding upgrade` 或更新 CLI）；当前
-session 临时覆盖统一通过 `ec-config` 对话修改。升级到 0.10.0-beta.1 时配置 schema 升至
-4，旧项目、会话和在途任务均迁移为 TDD 关闭；同时部署共享 Java 差异覆盖率工具。
+session 临时覆盖统一通过 `ec-config` 对话修改。升级到 0.10.0-beta.2 时配置 schema 升至
+5；未完成 `ec-tdd-init` readiness 的项目/session TDD 请求迁移为关闭并保留阈值，同时
+部署共享 Java 差异覆盖率与 readiness 工具。0.10.0-beta.3 起，TDD 业务任务只依赖本地
+单测与本地差异覆盖率，历史远程 CI 证据保留但不再参与验收。已经冻结的活动任务合同
+不会被静默改写。
 
 若当前会话不希望 Harness 接管，显式调用 `/ec-no-harness`（Codex 使用
 `$ec-no-harness`）。它只旁路 Easy Coding，不关闭其他 hooks，也不忽略其他 skills；

package/dist/cli.js

@@ -103,7 +103,7 @@ async function isDirectory(filePath) {
 }
 
 // src/utils/config-yaml.ts
-var CONFIG_SCHEMA_VERSION = 4;
+var CONFIG_SCHEMA_VERSION = 5;
 var DEFAULT_TDD_COVERAGE_THRESHOLD = 90;
 var APPROVAL_MODES = ["approve", "guard", "confirm", "auto"];
 var CONFIGURED_WORKFLOW_MODES = ["adaptive", "fast", "standard", "strict"];
@@ -190,9 +190,10 @@ function resolveLegacyBehavior(config2) {
   const legacyLite = behavior.confirm_mode === "lite";
   const approvalMode = isApprovalMode(behavior.approval_mode) ? behavior.approval_mode : isApprovalMode(behavior.confirm_mode) ? behavior.confirm_mode : behavior.auto_mode === true ? "auto" : behavior.strict_confirm === true ? "approve" : "guard";
   const workflowMode = isConfiguredWorkflowMode(behavior.workflow_mode) ? behavior.workflow_mode : legacyLite ? "fast" : "adaptive";
-  const supportsTdd = Number(config2.version) >= CONFIG_SCHEMA_VERSION;
-  const tddEnabled = supportsTdd && behavior.tdd_enabled === true;
-  const tddCoverageThreshold = supportsTdd && isTddCoverageThreshold(behavior.tdd_coverage_threshold) ? behavior.tdd_coverage_threshold : DEFAULT_TDD_COVERAGE_THRESHOLD;
+  const supportsTddThreshold = Number(config2.version) >= 4;
+  const supportsReadyTdd = Number(config2.version) >= CONFIG_SCHEMA_VERSION;
+  const tddEnabled = supportsReadyTdd && behavior.tdd_enabled === true;
+  const tddCoverageThreshold = supportsTddThreshold && isTddCoverageThreshold(behavior.tdd_coverage_threshold) ? behavior.tdd_coverage_threshold : DEFAULT_TDD_COVERAGE_THRESHOLD;
   return { approvalMode, workflowMode, tddEnabled, tddCoverageThreshold };
 }
 async function setBehaviorModes(filePath, approvalMode, workflowMode, tddEnabled, tddCoverageThreshold) {
@@ -258,6 +259,8 @@ var MAIN_SPEC_DIR = "main";
 var DEV_SPEC_DIR = "dev";
 var TEMPLATES_DIR = "templates";
 var TOOLS_DIR = "tools";
+var TDD_DIR = "tdd";
+var TDD_READINESS_FILE = "readiness.json";
 var SESSIONS_GITIGNORE_ENTRY = ".easy-coding/sessions/";
 var HOOK_BYTECODE_GITIGNORE_ENTRY = "__pycache__/";
 var GENERATED_REGION_START = "<!-- \u2550\u2550\u2550 easy-coding-harness generated (DO NOT EDIT BETWEEN MARKERS) \u2550\u2550\u2550 -->";
@@ -681,8 +684,10 @@ async function writeRuntimeScaffold(cwd, agents, opts = {}) {
 async function writeToolsScaffold(easyCodingDir) {
   const toolsDir = path6.join(easyCodingDir, TOOLS_DIR);
   await ensureDir(toolsDir);
-  const src = getTemplatePath("runtime", "tools", "easy_coding_java_coverage.py");
-  await writeTextFile(path6.join(toolsDir, "easy_coding_java_coverage.py"), await readTextFile(src));
+  for (const file of ["easy_coding_java_coverage.py", "easy_coding_tdd_readiness.py"]) {
+    const src = getTemplatePath("runtime", "tools", file);
+    await writeTextFile(path6.join(toolsDir, file), await readTextFile(src));
+  }
 }
 async function writeTemplatesScaffold(easyCodingDir) {
   const templatesDir = path6.join(easyCodingDir, TEMPLATES_DIR);
@@ -2772,7 +2777,7 @@ function renderTargetPlans(targetPlans) {
 }
 
 // src/commands/config.ts
-import path18 from "path";
+import path19 from "path";
 import { cancel as cancel4, confirm as confirm3, outro as outro3, select, text } from "@clack/prompts";
 import chalk4 from "chalk";
 
@@ -2851,10 +2856,169 @@ async function checkForUpgrade(cwd) {
   }
 }
 
+// src/utils/tdd-readiness.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile4, readdir as readdir5, realpath as realpath2 } from "fs/promises";
+import path18 from "path";
+var TDD_READINESS_SCHEMA = "easy-coding/tdd-readiness-v1";
+var TDD_READINESS_SCOPE = "changed-production-lines";
+var TDD_BASE_VARIABLE = "EASY_CODING_TDD_BASE_SHA";
+var TDD_THRESHOLD_VARIABLE = "EASY_CODING_TDD_THRESHOLD";
+var COVERAGE_TOOL_PATH = ".easy-coding/tools/easy_coding_java_coverage.py";
+var JAVA_BUILD_FILE_NAMES = /* @__PURE__ */ new Set(["pom.xml", "build.gradle", "build.gradle.kts"]);
+var GITLAB_CI_ENTRY_FILES = /* @__PURE__ */ new Set([".gitlab-ci.yml", ".gitlab-ci.yaml"]);
+function readinessPath(root) {
+  return path18.join(root, EASY_CODING_DIR, TDD_DIR, TDD_READINESS_FILE);
+}
+function parseFileRecords(value, field, reasons) {
+  if (!Array.isArray(value) || value.length === 0) {
+    reasons.push(`${field} must contain at least one file`);
+    return [];
+  }
+  const records = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      reasons.push(`${field} contains an invalid record`);
+      continue;
+    }
+    const record = item;
+    if (typeof record.path !== "string" || !record.path.trim() || path18.isAbsolute(record.path) || typeof record.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(record.sha256)) {
+      reasons.push(`${field} contains an invalid path or SHA-256`);
+      continue;
+    }
+    records.push({ path: record.path, sha256: record.sha256 });
+  }
+  return records;
+}
+function usesRequiredGateVariables(command) {
+  const normalized = command.replaceAll(`\${${TDD_BASE_VARIABLE}}`, `$${TDD_BASE_VARIABLE}`).replaceAll(`\${${TDD_THRESHOLD_VARIABLE}}`, `$${TDD_THRESHOLD_VARIABLE}`);
+  return new RegExp(`--base\\s+['"]?\\$${TDD_BASE_VARIABLE}(?:['"]|\\s|$)`).test(normalized) && new RegExp(`--threshold\\s+['"]?\\$${TDD_THRESHOLD_VARIABLE}(?:['"]|\\s|$)`).test(normalized);
+}
+function isSafeReportPattern(value) {
+  const normalized = value.replaceAll("\\", "/");
+  return !path18.isAbsolute(value) && !normalized.split("/").includes("..");
+}
+function activeCiContent(contents) {
+  return contents.join("\n").split("\n").map((line) => line.replace(/^\s*#.*$/, "").replace(/\s+#.*$/, "")).join("\n");
+}
+async function validateFiles(root, records, reasons) {
+  const contents = [];
+  const resolvedRoot = await realpath2(root);
+  for (const record of records) {
+    const absolute = path18.resolve(root, record.path);
+    try {
+      const resolved = await realpath2(absolute);
+      if (resolved !== resolvedRoot && !resolved.startsWith(`${resolvedRoot}${path18.sep}`)) {
+        reasons.push(`readiness file escapes project root: ${record.path}`);
+        continue;
+      }
+      const content = await readFile4(resolved);
+      const digest = createHash2("sha256").update(content).digest("hex");
+      if (digest !== record.sha256) reasons.push(`readiness file changed: ${record.path}`);
+      contents.push(content.toString("utf8"));
+    } catch {
+      reasons.push(`readiness file is missing or unreadable: ${record.path}`);
+    }
+  }
+  return contents;
+}
+async function inspectTddReadiness(root) {
+  const manifestPath2 = readinessPath(root);
+  if (!await pathExists(manifestPath2)) {
+    return { status: "needs_init", reasons: ["TDD readiness receipt is missing"], manifestPath: manifestPath2 };
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(await readFile4(manifestPath2, "utf8"));
+  } catch {
+    return { status: "needs_init", reasons: ["TDD readiness receipt is invalid"], manifestPath: manifestPath2 };
+  }
+  const reasons = [];
+  if (manifest.schema !== TDD_READINESS_SCHEMA) reasons.push("unsupported readiness schema");
+  if (manifest.provider !== "gitlab") reasons.push("readiness provider must be gitlab");
+  if (manifest.coverage_scope !== TDD_READINESS_SCOPE) {
+    reasons.push("coverage scope must be changed-production-lines");
+  }
+  if (manifest.historical_coverage_required !== false) {
+    reasons.push("historical coverage must remain disabled");
+  }
+  if (!Array.isArray(manifest.coverage_report_patterns) || manifest.coverage_report_patterns.length === 0 || manifest.coverage_report_patterns.some(
+    (item) => typeof item !== "string" || !item.trim() || !isSafeReportPattern(item)
+  )) {
+    reasons.push("coverage_report_patterns must contain safe project-relative report patterns");
+  }
+  if (typeof manifest.changed_line_gate_command !== "string" || !manifest.changed_line_gate_command.includes(COVERAGE_TOOL_PATH)) {
+    reasons.push("changed-line coverage gate command is missing");
+  } else if (!usesRequiredGateVariables(manifest.changed_line_gate_command)) {
+    reasons.push("changed-line coverage gate must use the task baseline and threshold variables");
+  }
+  const buildFiles = parseFileRecords(manifest.build_files, "build_files", reasons);
+  const ciFiles = parseFileRecords(manifest.ci_files, "ci_files", reasons);
+  const toolFiles = parseFileRecords(manifest.tool_files, "tool_files", reasons);
+  if (!buildFiles.some((record) => JAVA_BUILD_FILE_NAMES.has(path18.basename(record.path)))) {
+    reasons.push("build_files must include a Maven or Gradle Java build file");
+  }
+  if (!ciFiles.some((record) => GITLAB_CI_ENTRY_FILES.has(record.path.replaceAll("\\", "/")))) {
+    reasons.push("ci_files must include the project-root GitLab CI entry file");
+  }
+  if (!toolFiles.some((record) => record.path.replaceAll("\\", "/") === COVERAGE_TOOL_PATH)) {
+    reasons.push(`tool_files must include ${COVERAGE_TOOL_PATH}`);
+  }
+  const buildContents = await validateFiles(root, buildFiles, reasons);
+  const ciContents = await validateFiles(root, ciFiles, reasons);
+  await validateFiles(root, toolFiles, reasons);
+  if (!buildContents.some((content) => /jacoco/i.test(content))) {
+    reasons.push("build files do not configure JaCoCo");
+  }
+  const combinedCi = activeCiContent(ciContents);
+  for (const marker of [
+    "jacoco",
+    "artifacts",
+    COVERAGE_TOOL_PATH,
+    TDD_BASE_VARIABLE,
+    TDD_THRESHOLD_VARIABLE
+  ]) {
+    if (!combinedCi.toLowerCase().includes(marker.toLowerCase())) {
+      reasons.push(`CI files do not contain required marker: ${marker}`);
+    }
+  }
+  if (!usesRequiredGateVariables(combinedCi)) {
+    reasons.push("CI changed-line gate must use the task baseline and threshold variables");
+  }
+  if (!/(?:^|\n)\s*stage\s*:\s*['"]?test['"]?\s*(?:#.*)?(?:\n|$)/i.test(combinedCi)) {
+    reasons.push("CI files do not declare a TEST-stage job");
+  }
+  return {
+    status: reasons.length === 0 ? "ready" : "needs_init",
+    reasons: [...new Set(reasons)],
+    manifestPath: manifestPath2
+  };
+}
+async function disableUnreadySessionTddOverrides(root) {
+  if ((await inspectTddReadiness(root)).status === "ready") return 0;
+  const sessionsDir = path18.join(root, EASY_CODING_DIR, SESSIONS_DIR);
+  if (!await pathExists(sessionsDir)) return 0;
+  let updated = 0;
+  for (const entry of await readdir5(sessionsDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const filePath = path18.join(sessionsDir, entry.name);
+    try {
+      const session = JSON.parse(await readFile4(filePath, "utf8"));
+      if (session.tdd_enabled !== true) continue;
+      session.tdd_enabled = false;
+      await writeTextFile(filePath, `${JSON.stringify(session, null, 2)}
+`);
+      updated += 1;
+    } catch {
+    }
+  }
+  return updated;
+}
+
 // src/commands/config.ts
 async function config() {
   renderBanner();
-  const configPath2 = path18.join(process.cwd(), EASY_CODING_DIR, CONFIG_FILE);
+  const configPath2 = path19.join(process.cwd(), EASY_CODING_DIR, CONFIG_FILE);
   if (!await pathExists(configPath2)) {
     throw new Error("No easy-coding harness found in this project.");
   }
@@ -2948,6 +3112,15 @@ async function config() {
     cancel4("Configuration cancelled.");
     return;
   }
+  if (tddEnabled) {
+    const readiness = await inspectTddReadiness(process.cwd());
+    if (readiness.status !== "ready") {
+      cancel4(
+        `TDD was not enabled. Run ec-tdd-init first: ${readiness.reasons.join("; ")}. No project modes were changed.`
+      );
+      return;
+    }
+  }
   let tddCoverageThreshold = current.tddCoverageThreshold;
   if (tddEnabled) {
     const thresholdInput = await text({
@@ -2972,6 +3145,15 @@ async function config() {
     cancel4("Configuration cancelled.");
     return;
   }
+  if (tddEnabled) {
+    const readiness = await inspectTddReadiness(process.cwd());
+    if (readiness.status !== "ready") {
+      cancel4(
+        `TDD was not enabled because readiness changed before save: ${readiness.reasons.join("; ")}. No project modes were changed.`
+      );
+      return;
+    }
+  }
   await setBehaviorModes(configPath2, approvalMode, workflowMode, tddEnabled, tddCoverageThreshold);
   outro3(
     chalk4.green(
@@ -2981,20 +3163,20 @@ async function config() {
 }
 
 // src/commands/init.ts
-import path20 from "path";
+import path21 from "path";
 import { note, outro as outro4 } from "@clack/prompts";
 import chalk5 from "chalk";
 
 // src/utils/install-state.ts
-import { readdir as readdir5 } from "fs/promises";
-import path19 from "path";
+import { readdir as readdir6 } from "fs/promises";
+import path20 from "path";
 var LEGACY_ROOT_FILES = ["SOUL.md", "RULES.md", "ABSTRACT.md"];
 async function detectEasyCodingInstallState(cwd) {
-  const easyCodingDir = path19.join(cwd, EASY_CODING_DIR);
+  const easyCodingDir = path20.join(cwd, EASY_CODING_DIR);
   if (!await pathExists(easyCodingDir)) {
     return { kind: "fresh", easyCodingDir };
   }
-  const configPath2 = path19.join(easyCodingDir, CONFIG_FILE);
+  const configPath2 = path20.join(easyCodingDir, CONFIG_FILE);
   if (await pathExists(configPath2)) {
     return { kind: "installed", easyCodingDir, configPath: configPath2 };
   }
@@ -3012,17 +3194,17 @@ async function detectEasyCodingInstallState(cwd) {
 async function detectLegacyAssets(easyCodingDir) {
   const assets = [];
   for (const file of LEGACY_ROOT_FILES) {
-    if (await pathExists(path19.join(easyCodingDir, file))) {
+    if (await pathExists(path20.join(easyCodingDir, file))) {
       assets.push(relativeEasyCodingPath(file));
     }
   }
-  if (await pathExists(path19.join(easyCodingDir, "memory", "long", "MEMORY.md"))) {
+  if (await pathExists(path20.join(easyCodingDir, "memory", "long", "MEMORY.md"))) {
     assets.push(relativeEasyCodingPath("memory", "long", "MEMORY.md"));
   }
-  const shortMemoryFiles = await listMarkdownFiles(path19.join(easyCodingDir, "memory", "short"));
+  const shortMemoryFiles = await listMarkdownFiles(path20.join(easyCodingDir, "memory", "short"));
   assets.push(...shortMemoryFiles.map((file) => relativeEasyCodingPath("memory", "short", file)));
   for (const dir of ["spec", "prototype"]) {
-    if (await hasAnyDirectoryEntry(path19.join(easyCodingDir, dir))) {
+    if (await hasAnyDirectoryEntry(path20.join(easyCodingDir, dir))) {
       assets.push(relativeEasyCodingPath(dir));
     }
   }
@@ -3032,23 +3214,23 @@ async function listMarkdownFiles(dir) {
   if (!await isDirectory(dir)) {
     return [];
   }
-  const entries = await readdir5(dir, { withFileTypes: true });
+  const entries = await readdir6(dir, { withFileTypes: true });
   return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => entry.name).sort();
 }
 async function hasAnyDirectoryEntry(dir) {
   if (!await isDirectory(dir)) {
     return false;
   }
-  return (await readdir5(dir)).length > 0;
+  return (await readdir6(dir)).length > 0;
 }
 function relativeEasyCodingPath(...segments) {
-  return path19.posix.join(EASY_CODING_DIR, ...segments);
+  return path20.posix.join(EASY_CODING_DIR, ...segments);
 }
 function relativeConfigPath() {
-  return path19.posix.join(EASY_CODING_DIR, CONFIG_FILE);
+  return path20.posix.join(EASY_CODING_DIR, CONFIG_FILE);
 }
 function relativeProjectInitTaskPath() {
-  return path19.posix.join(EASY_CODING_DIR, TASKS_DIR, PROJECT_INIT_TASK_ID, "task.json");
+  return path20.posix.join(EASY_CODING_DIR, TASKS_DIR, PROJECT_INIT_TASK_ID, "task.json");
 }
 
 // src/commands/init.ts
@@ -3129,7 +3311,7 @@ async function supermoduleTargets(cwd, opts, submodules) {
     if (!targetSubmodulePaths.has(entry.path)) {
       continue;
     }
-    const dir = path20.join(cwd, entry.path);
+    const dir = path21.join(cwd, entry.path);
     targets.push(
       await targetFromState(dir, entry.path, "submodule-child", {
         parent: toPosixRelative2(dir, cwd)
@@ -3176,24 +3358,24 @@ function contextFromState(role, installState) {
   };
 }
 function toPosixRelative2(from, to) {
-  const relative = path20.relative(from, to);
-  return relative ? relative.split(path20.sep).join("/") : ".";
+  const relative = path21.relative(from, to);
+  return relative ? relative.split(path21.sep).join("/") : ".";
 }
 async function resolveInitPlatforms(cwd, opts, parentInstalled) {
   if (opts.agent || !parentInstalled) {
     return resolvePlatforms(opts, ["claude-code"]);
   }
-  const config2 = await readConfigYaml(path20.join(cwd, EASY_CODING_DIR, CONFIG_FILE));
+  const config2 = await readConfigYaml(path21.join(cwd, EASY_CODING_DIR, CONFIG_FILE));
   if (Array.isArray(config2.agents) && config2.agents.length > 0) {
     return config2.agents;
   }
   return resolvePlatforms(opts, ["claude-code"]);
 }
 async function refreshParentTopologyIfNeeded(cwd, parentTarget2, installPlatforms) {
-  if (!await pathExists(path20.join(cwd, EASY_CODING_DIR, CONFIG_FILE))) {
+  if (!await pathExists(path21.join(cwd, EASY_CODING_DIR, CONFIG_FILE))) {
     return;
   }
-  const config2 = parentTarget2.installed ? await readConfigYaml(path20.join(cwd, EASY_CODING_DIR, CONFIG_FILE)) : { agents: installPlatforms };
+  const config2 = parentTarget2.installed ? await readConfigYaml(path21.join(cwd, EASY_CODING_DIR, CONFIG_FILE)) : { agents: installPlatforms };
   const platforms = Array.isArray(config2.agents) && config2.agents.length > 0 ? config2.agents : installPlatforms;
   await refreshSupermoduleParent(cwd, platforms, parentTarget2.context.submodulePaths ?? []);
 }
@@ -3202,7 +3384,7 @@ async function refreshInstalledChildTopologies(targets) {
     if (!target.installed || target.context.role !== "submodule-child") {
       continue;
     }
-    const configPath2 = path20.join(target.dir, EASY_CODING_DIR, CONFIG_FILE);
+    const configPath2 = path21.join(target.dir, EASY_CODING_DIR, CONFIG_FILE);
     if (!await pathExists(configPath2)) {
       continue;
     }
@@ -3211,12 +3393,12 @@ async function refreshInstalledChildTopologies(targets) {
 }
 
 // src/commands/status.ts
-import path22 from "path";
+import path23 from "path";
 import chalk6 from "chalk";
 
 // src/utils/session.ts
-import { readdir as readdir6, unlink } from "fs/promises";
-import path21 from "path";
+import { readdir as readdir7, unlink } from "fs/promises";
+import path22 from "path";
 var STALE_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1e3;
 function parseSessionFile(content) {
   try {
@@ -3226,7 +3408,7 @@ function parseSessionFile(content) {
   }
 }
 function getSessionDir(cwd) {
-  return path21.join(cwd, EASY_CODING_DIR, SESSIONS_DIR);
+  return path22.join(cwd, EASY_CODING_DIR, SESSIONS_DIR);
 }
 async function listSessionFiles(cwd) {
   const dir = getSessionDir(cwd);
@@ -3234,11 +3416,11 @@ async function listSessionFiles(cwd) {
     return [];
   }
   const entries = [];
-  for (const name of await readdir6(dir)) {
+  for (const name of await readdir7(dir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
-    const filePath = path21.join(dir, name);
+    const filePath = path22.join(dir, name);
     const content = await readTextIfExists(filePath);
     if (!content) {
       continue;
@@ -3260,7 +3442,7 @@ async function listSessionFiles(cwd) {
 async function status() {
   renderBanner();
   const cwd = process.cwd();
-  const configPath2 = path22.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  const configPath2 = path23.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
   if (!await pathExists(configPath2)) {
     throw new Error("No easy-coding harness found in this project.");
   }
@@ -3270,6 +3452,7 @@ async function status() {
   const activeTasks = tasks.filter((item) => isActiveTask(item.task));
   const sessions = await listSessionFiles(cwd);
   const versionRelation = compareVersions(config2.harness_version, VERSION);
+  const tddReadiness = await inspectTddReadiness(cwd);
   console.log(chalk6.bold("Harness"));
   console.log(`  version: ${config2.harness_version}`);
   console.log(`  cli: ${VERSION}`);
@@ -3291,6 +3474,10 @@ async function status() {
   console.log(`  workflow_mode: ${projectWorkflowMode}`);
   console.log(`  tdd_enabled: ${projectTddEnabled}`);
   console.log(`  tdd_coverage_threshold: ${projectTddCoverageThreshold}`);
+  console.log(`  tdd_readiness: ${tddReadiness.status}`);
+  if (tddReadiness.status !== "ready") {
+    console.log(`  tdd_readiness_reasons: ${tddReadiness.reasons.join("; ")}`);
+  }
   console.log("");
   console.log(chalk6.bold("Sessions"));
   console.log(`  project_approval_mode: ${projectApprovalMode}`);
@@ -3398,7 +3585,7 @@ async function update(opts) {
 }
 
 // src/commands/upgrade.ts
-import path23 from "path";
+import path24 from "path";
 import { cancel as cancel6, confirm as confirm5, outro as outro6 } from "@clack/prompts";
 import chalk8 from "chalk";
 var EXPECTED_HOOK_REGISTRATION_SCRIPTS = {
@@ -3460,7 +3647,7 @@ async function upgrade(opts) {
     ].filter(Boolean) : [],
     "Will overwrite managed skills, hooks, agents, templates, and generated main-constraint regions.",
     "Will update project-init task to recommend ec-init re-run for version adaptation.",
-    "Will migrate behavior config to Approval, Workflow, and default-off Java TDD schema 4 fields.",
+    "Will migrate behavior config to schema 5 and disable unready project/session TDD settings.",
     "Will migrate legacy workflow/TDD task metadata; memory content, spec, and project knowledge files remain untouched."
   ].join("\n");
   if (opts.dryRun) {
@@ -3478,6 +3665,7 @@ async function upgrade(opts) {
     }
   }
   for (const { target, config: config2 } of pending) {
+    const beta1ProjectTddRequested = Number(config2.version) === 4 && config2.behavior?.tdd_enabled === true;
     const projectId = await writeRuntimeScaffold(target.dir, config2.agents, {
       supermodule: target.supermodule
     });
@@ -3494,6 +3682,14 @@ async function upgrade(opts) {
     await ensureHookBytecodeIgnored(target.dir);
     await migrateLegacyWorkflowState(target.dir);
     await migrateBehaviorConfig(target.configPath);
+    const disabledSessionTddOverrides = await disableUnreadySessionTddOverrides(target.dir);
+    if (beta1ProjectTddRequested || disabledSessionTddOverrides > 0) {
+      console.log(
+        chalk8.yellow(
+          `${target.label}: TDD remains off until ec-tdd-init succeeds (project=${beta1ProjectTddRequested ? "disabled" : "unchanged"}, sessions_disabled=${disabledSessionTddOverrides}).`
+        )
+      );
+    }
     await updateHarnessVersion(target.configPath, VERSION);
     await updateSupermoduleConfig(target.configPath, target.supermodule);
     await setPendingInitSince(target.dir, VERSION);
@@ -3549,7 +3745,7 @@ async function needsHookConfigRefresh(target, config2) {
   const manifest = await readInstallManifest(target.dir);
   for (const agent of config2.agents) {
     const meta = resolvePlatformMeta(target.dir, agent);
-    const configPath2 = path23.join(target.dir, meta.hookConfigFile);
+    const configPath2 = path24.join(target.dir, meta.hookConfigFile);
     const content = await readTextIfExists(configPath2);
     if (content === null) {
       return true;
@@ -3689,7 +3885,7 @@ function isCurrentProjectManagedHookPath(cwd, hookPath, meta, platform) {
       return true;
     }
     return pathAliases(
-      normalizePathForHookComparison(path23.resolve(cwd, relativeHookPath))
+      normalizePathForHookComparison(path24.resolve(cwd, relativeHookPath))
     ).includes(normalizedHookPath);
   });
 }