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

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 -->";
@@ -308,6 +311,7 @@ var PLATFORM_META = {
     stateInjectEvent: ["SessionStart", "UserPromptSubmit"],
     hasSubagentContext: true,
     templateContext: {
+      workflow_agent_id: "claude-code",
       sub_agent_dispatch: "Agent tool",
       platform_spawn_instruction: 'Use the Agent tool with run_in_background when useful; use isolation: "worktree" for parallel file edits.',
       skill_trigger: "/",
@@ -331,6 +335,7 @@ var PLATFORM_META = {
     stateInjectEvent: ["SessionStart", "UserPromptSubmit"],
     hasSubagentContext: false,
     templateContext: {
+      workflow_agent_id: "codex",
       sub_agent_dispatch: "Codex sub-agent dispatch",
       platform_spawn_instruction: "Use Codex sub-agent delegation where available; pass the full task card in the prompt.",
       skill_trigger: "$",
@@ -355,6 +360,7 @@ var PLATFORM_META = {
     hasSubagentContext: true,
     cnVariant: ".qodercn",
     templateContext: {
+      workflow_agent_id: "qoder",
       sub_agent_dispatch: "Agent tool",
       platform_spawn_instruction: "Use the Agent tool with worktree isolation for parallel file edits.",
       skill_trigger: "/",
@@ -681,8 +687,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);
@@ -771,6 +779,87 @@ function isLegacyStage(value) {
 function migrateStage(value) {
   return isLegacyStage(value) ? LEGACY_STAGE_MAP[value] : value;
 }
+var LEGACY_DISPLAY_AGENT_IDENTITIES = {
+  "claude with easy coding": "claude-code",
+  "claude-code with easy coding": "claude-code",
+  "claude code with easy coding": "claude-code",
+  "codex with easy coding": "codex",
+  "qoder with easy coding": "qoder"
+};
+function migratedAgentIdentity(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "claude-code" || normalized === "codex" || normalized === "qoder") {
+    return normalized;
+  }
+  if (/^\/?root(?:\/[a-z0-9._-]+)*$/.test(normalized)) return "codex";
+  return LEGACY_DISPLAY_AGENT_IDENTITIES[normalized];
+}
+function migrateAgentFields(record, fields) {
+  let changed = false;
+  for (const field of fields) {
+    const migrated = migratedAgentIdentity(record[field]);
+    if (migrated && migrated !== record[field]) {
+      record[field] = migrated;
+      changed = true;
+    }
+  }
+  return changed;
+}
+function taskAgentFieldGroups(task) {
+  const groups = [
+    {
+      record: task,
+      fields: ["created_by", "last_agent", "workflow_mode_confirmed_by", "tdd_confirmed_by"]
+    }
+  ];
+  for (const field of ["pending_transition", "workflow_mode_proposal", "verification_checkpoint"]) {
+    const value = task[field];
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const identityField = field === "pending_transition" ? "requested_by" : field === "workflow_mode_proposal" ? "proposed_by" : "recorded_by";
+    groups.push({ record: value, fields: [identityField] });
+  }
+  if (Array.isArray(task.workflow_mode_escalations)) {
+    for (const escalation of task.workflow_mode_escalations) {
+      if (!escalation || typeof escalation !== "object" || Array.isArray(escalation)) continue;
+      groups.push({ record: escalation, fields: ["raised_by"] });
+    }
+  }
+  const memoryProgress = task.memory_progress;
+  if (memoryProgress && typeof memoryProgress === "object" && !Array.isArray(memoryProgress)) {
+    const assessment = memoryProgress.architecture_assessment;
+    if (assessment && typeof assessment === "object" && !Array.isArray(assessment)) {
+      groups.push({ record: assessment, fields: ["recorded_by"] });
+    }
+  }
+  if (Array.isArray(task.spec_dependency_evidence)) {
+    for (const evidence of task.spec_dependency_evidence) {
+      if (!evidence || typeof evidence !== "object" || Array.isArray(evidence)) continue;
+      groups.push({ record: evidence, fields: ["satisfied_by"] });
+    }
+  }
+  if (Array.isArray(task.stage_history)) {
+    for (const entry of task.stage_history) {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+      groups.push({ record: entry, fields: ["agent"] });
+    }
+  }
+  return groups;
+}
+function migrateTaskAgentIdentities(task) {
+  return taskAgentFieldGroups(task).reduce(
+    (changed, group) => migrateAgentFields(group.record, group.fields) || changed,
+    false
+  );
+}
+function hasLegacyTaskAgentIdentities(task) {
+  return taskAgentFieldGroups(task).some(
+    ({ record, fields }) => fields.some((field) => {
+      const migrated = migratedAgentIdentity(record[field]);
+      return migrated !== void 0 && migrated !== record[field];
+    })
+  );
+}
 function migrateStageHistory(task) {
   if (!Array.isArray(task.stage_history)) return false;
   let changed = false;
@@ -801,7 +890,8 @@ function migrateTaskWorkflowState(task) {
   const legacyRequestedAt = Array.isArray(task.stage_history) ? [...task.stage_history].reverse().find(
     (entry) => entry && typeof entry === "object" && !Array.isArray(entry) && entry.stage === "WAITING_CONFIRM"
   ) : null;
-  let changed = migrateStageHistory(task);
+  let changed = migrateTaskAgentIdentities(task);
+  changed = migrateStageHistory(task) || changed;
   if (legacyStatus) {
     task.status = LEGACY_STAGE_MAP[legacyStatus];
     changed = true;
@@ -853,7 +943,7 @@ function migrateTaskWorkflowState(task) {
   return changed;
 }
 function migrateSessionBehavior(session) {
-  let changed = false;
+  let changed = migrateAgentFields(session, ["agent", "last_agent"]);
   const legacyMode = session.confirm_mode;
   const legacyLite = legacyMode === "lite";
   if (!["approve", "guard", "confirm", "auto"].includes(String(session.approval_mode ?? ""))) {
@@ -964,7 +1054,7 @@ async function hasLegacyWorkflowState(cwd) {
     if (!await pathExists(filePath)) continue;
     const task = await readJsonRecord(filePath);
     if (!task) continue;
-    if (isLegacyStage(task.status) || !["PENDING", "COMPLETE", "CLOSED"].includes(String(task.status ?? "")) && String(task.type ?? "") !== "project-init" && !["fast", "standard", "strict"].includes(String(task.workflow_mode ?? "")) || Array.isArray(task.stage_history) && task.stage_history.some(
+    if (hasLegacyTaskAgentIdentities(task) || isLegacyStage(task.status) || !["PENDING", "COMPLETE", "CLOSED"].includes(String(task.status ?? "")) && String(task.type ?? "") !== "project-init" && !["fast", "standard", "strict"].includes(String(task.workflow_mode ?? "")) || Array.isArray(task.stage_history) && task.stage_history.some(
       (entry) => entry && typeof entry === "object" && !Array.isArray(entry) && isLegacyStage(entry.stage)
     )) {
       return true;
@@ -973,7 +1063,12 @@ async function hasLegacyWorkflowState(cwd) {
   for (const filePath of await sessionFiles(cwd)) {
     const session = await readJsonRecord(filePath);
     if (!session) continue;
-    if (isLegacyStage(session.last_seen_stage) || "confirm_mode" in session) return true;
+    if (["agent", "last_agent"].some((field) => {
+      const migrated = migratedAgentIdentity(session[field]);
+      return migrated !== void 0 && migrated !== session[field];
+    }) || isLegacyStage(session.last_seen_stage) || "confirm_mode" in session) {
+      return true;
+    }
   }
   return false;
 }
@@ -2772,7 +2867,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 +2946,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.");
   }
@@ -2898,7 +3152,7 @@ async function config() {
       {
         value: "auto",
         label: "auto \u2014 advance workflow stages automatically",
-        hint: "task closure remains explicit"
+        hint: "only new post-verification code drift pauses for exact acceptance"
       }
     ]
   });
@@ -2948,6 +3202,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 +3235,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 +3253,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 +3284,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 +3304,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 +3401,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 +3448,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 +3474,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,22 +3483,26 @@ 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";
-var STALE_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1e3;
+import { readdir as readdir7, stat as stat3, unlink } from "fs/promises";
+import path22 from "path";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var IDLE_SESSION_RETENTION_MS = 7 * DAY_MS;
+var ATTACHED_SESSION_RETENTION_MS = 30 * DAY_MS;
+var MAX_SESSION_FILES = 100;
 function parseSessionFile(content) {
   try {
-    return JSON.parse(content);
+    const parsed = JSON.parse(content);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 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 +3510,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;
@@ -3255,12 +3531,144 @@ async function listSessionFiles(cwd) {
   }
   return entries.sort((left, right) => left.key.localeCompare(right.key));
 }
+async function cleanSessionRuntime(cwd, options = {}) {
+  const now = Date.now();
+  const idleRetentionMs = options.idleRetentionMs ?? IDLE_SESSION_RETENTION_MS;
+  const attachedRetentionMs = options.attachedRetentionMs ?? ATTACHED_SESSION_RETENTION_MS;
+  const maxSessions = options.maxSessions ?? MAX_SESSION_FILES;
+  const reserveSlots = options.reserveSlots ?? 0;
+  const candidates = await listSessionCleanupCandidates(cwd);
+  const removed = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    const retentionMs = candidate.attached ? attachedRetentionMs : idleRetentionMs;
+    if (now - candidate.activityTime <= retentionMs) {
+      continue;
+    }
+    if (await unlinkIfUnchanged(candidate)) {
+      removed.add(candidate.filePath);
+    }
+  }
+  const allowedExistingSessions = Math.max(0, maxSessions - reserveSlots);
+  const remaining = candidates.filter((candidate) => !removed.has(candidate.filePath)).sort((left, right) => left.activityTime - right.activityTime);
+  for (const candidate of remaining.slice(
+    0,
+    Math.max(0, remaining.length - allowedExistingSessions)
+  )) {
+    if (await unlinkIfUnchanged(candidate)) {
+      removed.add(candidate.filePath);
+    }
+  }
+  return {
+    sessionsRemoved: removed.size,
+    acceptanceSnapshotsRemoved: await cleanOrphanAcceptanceSnapshots(cwd)
+  };
+}
+async function listSessionCleanupCandidates(cwd) {
+  const dir = getSessionDir(cwd);
+  if (!await pathExists(dir)) {
+    return [];
+  }
+  const candidates = [];
+  for (const entry of await readdir7(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+      continue;
+    }
+    const filePath = path22.join(dir, entry.name);
+    try {
+      const [content, fileStat] = await Promise.all([readTextFile(filePath), stat3(filePath)]);
+      const session = parseSessionFile(content);
+      const activityValue = session?.last_active_at ?? session?.created_at;
+      const parsedActivity = typeof activityValue === "string" ? new Date(activityValue).getTime() : Number.NaN;
+      candidates.push({
+        filePath,
+        content,
+        activityTime: Number.isNaN(parsedActivity) ? fileStat.mtimeMs : parsedActivity,
+        attached: Boolean(session?.current_task)
+      });
+    } catch (error) {
+      if (!isFileNotFound(error)) {
+        throw error;
+      }
+    }
+  }
+  return candidates;
+}
+async function unlinkIfUnchanged(candidate) {
+  try {
+    if (await readTextFile(candidate.filePath) !== candidate.content) {
+      return false;
+    }
+    await unlink(candidate.filePath);
+    return true;
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function cleanOrphanAcceptanceSnapshots(cwd) {
+  const acceptanceDir = path22.join(getSessionDir(cwd), "acceptance");
+  if (!await pathExists(acceptanceDir)) {
+    return 0;
+  }
+  let removed = 0;
+  for (const entry of await readdir7(acceptanceDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+      continue;
+    }
+    const snapshotPath = path22.join(acceptanceDir, entry.name);
+    if (!await isOrphanAcceptanceSnapshot(cwd, snapshotPath, entry.name.slice(0, -5))) {
+      continue;
+    }
+    try {
+      await unlink(snapshotPath);
+      removed++;
+    } catch (error) {
+      if (!isFileNotFound(error)) {
+        throw error;
+      }
+    }
+  }
+  return removed;
+}
+async function isOrphanAcceptanceSnapshot(cwd, snapshotPath, taskId) {
+  let taskContent;
+  try {
+    taskContent = await readTextFile(
+      path22.join(cwd, EASY_CODING_DIR, TASKS_DIR, taskId, "task.json")
+    );
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return true;
+    }
+    throw error;
+  }
+  let parsedTask;
+  try {
+    parsedTask = JSON.parse(taskContent);
+  } catch {
+    return false;
+  }
+  if (typeof parsedTask !== "object" || parsedTask === null || Array.isArray(parsedTask)) {
+    return false;
+  }
+  const task = parsedTask;
+  if (task.status === "COMPLETE" || task.status === "CLOSED") {
+    return true;
+  }
+  const checkpoint = task.verification_checkpoint;
+  return typeof checkpoint?.snapshot_file !== "string" || path22.resolve(cwd, checkpoint.snapshot_file) !== path22.resolve(snapshotPath);
+}
+function isFileNotFound(error) {
+  return error.code === "ENOENT";
+}
 
 // src/commands/status.ts
 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 +3678,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 +3700,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 +3811,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 +3873,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 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 prune expired session bindings and orphan acceptance snapshots in each upgraded target while preserving tasks, memory, spec, and project knowledge.",
     "Will migrate legacy workflow/TDD task metadata; memory content, spec, and project knowledge files remain untouched."
   ].join("\n");
   if (opts.dryRun) {
@@ -3478,6 +3892,15 @@ async function upgrade(opts) {
     }
   }
   for (const { target, config: config2 } of pending) {
+    const sessionCleanup = await cleanSessionRuntime(target.dir);
+    if (sessionCleanup.sessionsRemoved > 0 || sessionCleanup.acceptanceSnapshotsRemoved > 0) {
+      console.log(
+        chalk8.yellow(
+          `${target.label}: session GC removed ${sessionCleanup.sessionsRemoved} session file(s) and ${sessionCleanup.acceptanceSnapshotsRemoved} orphan acceptance snapshot(s).`
+        )
+      );
+    }
+    const beta1ProjectTddRequested = Number(config2.version) === 4 && config2.behavior?.tdd_enabled === true;
     const projectId = await writeRuntimeScaffold(target.dir, config2.agents, {
       supermodule: target.supermodule
     });
@@ -3494,6 +3917,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 +3980,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 +4120,7 @@ function isCurrentProjectManagedHookPath(cwd, hookPath, meta, platform) {
       return true;
     }
     return pathAliases(
-      normalizePathForHookComparison(path23.resolve(cwd, relativeHookPath))
+      normalizePathForHookComparison(path24.resolve(cwd, relativeHookPath))
     ).includes(normalizedHookPath);
   });
 }