easy-coding-harness 0.10.0-beta.0 → 0.10.0-beta.2

package/dist/cli.js

@@ -103,7 +103,8 @@ async function isDirectory(filePath) {
 }
 
 // src/utils/config-yaml.ts
-var CONFIG_SCHEMA_VERSION = 3;
+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"];
 function createDefaultConfig(params) {
@@ -125,7 +126,9 @@ function createDefaultConfig(params) {
     },
     behavior: {
       approval_mode: "guard",
-      workflow_mode: "adaptive"
+      workflow_mode: "adaptive",
+      tdd_enabled: false,
+      tdd_coverage_threshold: DEFAULT_TDD_COVERAGE_THRESHOLD
     }
   };
   if (params.supermodule) {
@@ -179,31 +182,44 @@ function isApprovalMode(value) {
 function isConfiguredWorkflowMode(value) {
   return typeof value === "string" && CONFIGURED_WORKFLOW_MODES.includes(value);
 }
+function isTddCoverageThreshold(value) {
+  return Number.isInteger(value) && Number(value) >= 1 && Number(value) <= 100;
+}
 function resolveLegacyBehavior(config2) {
   const behavior = config2.behavior ?? {};
   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";
-  return { approvalMode, workflowMode };
+  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) {
+async function setBehaviorModes(filePath, approvalMode, workflowMode, tddEnabled, tddCoverageThreshold) {
+  if (tddCoverageThreshold !== void 0 && !isTddCoverageThreshold(tddCoverageThreshold)) {
+    throw new Error("TDD coverage threshold must be an integer from 1 to 100.");
+  }
   return updateConfigYaml(filePath, (config2) => {
     const legacyBehavior = config2.behavior ?? {};
+    const resolvedBehavior = resolveLegacyBehavior(config2);
     const behavior = Object.fromEntries(
       Object.entries(legacyBehavior).filter(
-        ([key]) => key !== "strict_confirm" && key !== "auto_mode" && key !== "confirm_mode" && key !== "approval_mode" && key !== "workflow_mode"
+        ([key]) => key !== "strict_confirm" && key !== "auto_mode" && key !== "confirm_mode" && key !== "approval_mode" && key !== "workflow_mode" && key !== "tdd_enabled" && key !== "tdd_coverage_threshold"
       )
     );
     behavior.approval_mode = approvalMode;
     behavior.workflow_mode = workflowMode;
+    behavior.tdd_enabled = tddEnabled ?? resolvedBehavior.tddEnabled;
+    behavior.tdd_coverage_threshold = tddCoverageThreshold ?? resolvedBehavior.tddCoverageThreshold;
     config2.behavior = behavior;
     config2.version = CONFIG_SCHEMA_VERSION;
   });
 }
 async function migrateBehaviorConfig(filePath) {
   const config2 = await readConfigYaml(filePath);
-  const { approvalMode, workflowMode } = resolveLegacyBehavior(config2);
-  return setBehaviorModes(filePath, approvalMode, workflowMode);
+  const { approvalMode, workflowMode, tddEnabled, tddCoverageThreshold } = resolveLegacyBehavior(config2);
+  return setBehaviorModes(filePath, approvalMode, workflowMode, tddEnabled, tddCoverageThreshold);
 }
 async function ensureProjectId(filePath) {
   let projectId = "";
@@ -242,6 +258,9 @@ var SPEC_DIR = "spec";
 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 -->";
@@ -659,8 +678,17 @@ async function writeRuntimeScaffold(cwd, agents, opts = {}) {
   await ensureDir(path6.join(easyCodingDir, SPEC_DIR, DEV_SPEC_DIR));
   await writeMemoryScaffold(easyCodingDir);
   await writeTemplatesScaffold(easyCodingDir);
+  await writeToolsScaffold(easyCodingDir);
   return projectId;
 }
+async function writeToolsScaffold(easyCodingDir) {
+  const toolsDir = path6.join(easyCodingDir, TOOLS_DIR);
+  await ensureDir(toolsDir);
+  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);
   await ensureDir(templatesDir);
@@ -816,6 +844,17 @@ function migrateTaskWorkflowState(task) {
     task.workflow_mode_legacy = true;
     changed = true;
   }
+  if (isActive && taskType !== "project-init" && typeof task.tdd_enabled !== "boolean") {
+    task.tdd_enabled = false;
+    task.tdd_coverage_threshold = DEFAULT_TDD_COVERAGE_THRESHOLD;
+    task.tdd_confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
+    task.tdd_confirmed_by = "upgrade-migration";
+    changed = true;
+  }
+  if (task.tdd_enabled === false && "tdd_baselines" in task) {
+    task.tdd_baselines = void 0;
+    changed = true;
+  }
   return changed;
 }
 function migrateSessionBehavior(session) {
@@ -2515,6 +2554,7 @@ function addRuntimeClearEntries(plan, cwd) {
       path16.join(cwd, EASY_CODING_DIR, CONFIG_FILE),
       path16.join(cwd, EASY_CODING_DIR, SESSIONS_DIR),
       path16.join(cwd, EASY_CODING_DIR, TEMPLATES_DIR),
+      path16.join(cwd, EASY_CODING_DIR, TOOLS_DIR),
       path16.join(cwd, EASY_CODING_DIR, INSTALL_MANIFEST_FILE)
     ])
   ];
@@ -2737,8 +2777,8 @@ function renderTargetPlans(targetPlans) {
 }
 
 // src/commands/config.ts
-import path18 from "path";
-import { cancel as cancel4, confirm as confirm3, outro as outro3, select } from "@clack/prompts";
+import path19 from "path";
+import { cancel as cancel4, confirm as confirm3, outro as outro3, select, text } from "@clack/prompts";
 import chalk4 from "chalk";
 
 // src/utils/compare-versions.ts
@@ -2816,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.");
   }
@@ -2901,33 +3100,83 @@ async function config() {
     cancel4("Configuration cancelled.");
     return;
   }
+  const tddEnabled = await select({
+    message: `Enable Java TDD for this project (current: ${current.tddEnabled ? "enabled" : "disabled"})`,
+    initialValue: current.tddEnabled,
+    options: [
+      { value: false, label: "disabled \u2014 preserve current test depth (default)" },
+      { value: true, label: "enabled \u2014 require TDD evidence and changed-line coverage" }
+    ]
+  });
+  if (typeof tddEnabled === "symbol") {
+    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({
+      message: "Minimum changed-production-line coverage percentage",
+      initialValue: String(current.tddCoverageThreshold),
+      validate(value) {
+        const parsed = Number(value);
+        return isTddCoverageThreshold(parsed) ? void 0 : "Enter an integer from 1 to 100.";
+      }
+    });
+    if (typeof thresholdInput === "symbol") {
+      cancel4("Configuration cancelled.");
+      return;
+    }
+    tddCoverageThreshold = Number(thresholdInput);
+  }
   const shouldSave = await confirm3({
-    message: `Set behavior.approval_mode to ${approvalMode} and behavior.workflow_mode to ${workflowMode}?`,
+    message: `Set approval=${approvalMode}, workflow=${workflowMode}, TDD=${tddEnabled ? `enabled (${tddCoverageThreshold}%)` : "disabled"}?`,
     initialValue: true
   });
   if (typeof shouldSave === "symbol" || !shouldSave) {
     cancel4("Configuration cancelled.");
     return;
   }
-  await setBehaviorModes(configPath2, approvalMode, workflowMode);
-  outro3(chalk4.green(`Project modes updated: approval=${approvalMode}, workflow=${workflowMode}.`));
+  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(
+      `Project modes updated: approval=${approvalMode}, workflow=${workflowMode}, TDD=${tddEnabled ? `${tddCoverageThreshold}%` : "off"}.`
+    )
+  );
 }
 
 // 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 };
   }
@@ -2945,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));
     }
   }
@@ -2965,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
@@ -3062,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)
@@ -3109,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 ?? []);
 }
@@ -3135,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;
     }
@@ -3144,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 {
@@ -3159,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);
@@ -3167,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;
@@ -3193,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.");
   }
@@ -3203,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}`);
@@ -3218,14 +3468,28 @@ async function status() {
   const migratedBehavior = resolveLegacyBehavior(config2);
   const projectApprovalMode = isApprovalMode(config2.behavior?.approval_mode) ? config2.behavior.approval_mode : migratedBehavior.approvalMode;
   const projectWorkflowMode = isConfiguredWorkflowMode(config2.behavior?.workflow_mode) ? config2.behavior.workflow_mode : migratedBehavior.workflowMode;
+  const projectTddEnabled = migratedBehavior.tddEnabled;
+  const projectTddCoverageThreshold = migratedBehavior.tddCoverageThreshold;
   console.log(`  approval_mode: ${projectApprovalMode}`);
   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}`);
   console.log(`  project_workflow_mode: ${projectWorkflowMode}`);
+  console.log(`  project_tdd_enabled: ${projectTddEnabled}`);
+  console.log(`  project_tdd_coverage_threshold: ${projectTddCoverageThreshold}`);
   console.log(`  effective_approval_mode: ${projectApprovalMode} (without a session override)`);
   console.log(`  configured_workflow_mode: ${projectWorkflowMode} (without a session override)`);
+  console.log(`  effective_tdd_enabled: ${projectTddEnabled} (without a session override)`);
+  console.log(
+    `  effective_tdd_coverage_threshold: ${projectTddCoverageThreshold} (without a session override)`
+  );
   if (sessions.length === 0) {
     console.log("  no session files");
   }
@@ -3236,13 +3500,21 @@ async function status() {
     );
     const sessionApprovalMode = session.approval_mode ?? (legacySessionMode === "lite" ? "guard" : legacySessionMode);
     const sessionWorkflowMode = session.workflow_mode ?? (legacySessionMode === "lite" ? "fast" : hasLegacySessionMode ? "adaptive" : void 0);
+    const sessionTddEnabled = session.tdd_enabled;
+    const sessionTddCoverageThreshold = session.tdd_coverage_threshold;
     console.log(`  - ${key}`);
     console.log(`    agent: ${session.agent ?? "legacy/unknown"}`);
     console.log(`    source: ${session.session_source ?? "legacy"}`);
     console.log(`    approval_mode: ${sessionApprovalMode ?? "project default"}`);
     console.log(`    workflow_mode: ${sessionWorkflowMode ?? "project default"}`);
+    console.log(`    tdd_enabled: ${sessionTddEnabled ?? "project default"}`);
+    console.log(`    tdd_coverage_threshold: ${sessionTddCoverageThreshold ?? "project default"}`);
     console.log(`    effective_approval_mode: ${sessionApprovalMode ?? projectApprovalMode}`);
     console.log(`    configured_workflow_mode: ${sessionWorkflowMode ?? projectWorkflowMode}`);
+    console.log(`    effective_tdd_enabled: ${sessionTddEnabled ?? projectTddEnabled}`);
+    console.log(
+      `    effective_tdd_coverage_threshold: ${sessionTddCoverageThreshold ?? projectTddCoverageThreshold}`
+    );
     console.log(
       `    harness: ${session.harness_disabled ? "disabled for this session" : "enabled"}`
     );
@@ -3258,6 +3530,10 @@ async function status() {
       console.log(
         `    task_workflow_mode: ${task.workflow_mode ?? task.workflow_mode_proposal?.selected_mode ?? "not resolved"}`
       );
+      console.log(`    task_tdd_enabled: ${task.tdd_enabled ?? "not frozen"}`);
+      console.log(
+        `    task_tdd_coverage_threshold: ${task.tdd_coverage_threshold ?? "not frozen"}`
+      );
       console.log(`    last_agent: ${task.last_agent}`);
     } else {
       console.log(`    current_task: ${session.current_task} (task.json missing)`);
@@ -3309,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 = {
@@ -3371,8 +3647,8 @@ 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 legacy confirmation settings to behavior.approval_mode and behavior.workflow_mode.",
-    "Will migrate legacy workflow stage metadata; memory content, spec, and project knowledge files remain untouched."
+    "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) {
     console.log(summary);
@@ -3389,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
     });
@@ -3405,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);
@@ -3460,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;
@@ -3600,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);
   });
 }