easy-coding-harness 0.10.0-beta.9 → 1.0.0-beta.0

package/dist/cli.js

@@ -292,7 +292,7 @@ async function ensureHookBytecodeIgnored(cwd) {
 
 // src/utils/install-manifest.ts
 import { createHash } from "crypto";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile3, rmdir, unlink } from "fs/promises";
 import path4 from "path";
 
 // src/types/platform.ts
@@ -486,6 +486,41 @@ async function readInstallManifest(cwd) {
     return null;
   }
 }
+async function pruneRetiredManagedFiles(cwd, previous, artifacts) {
+  if (!previous) {
+    return { removed: [], preserved: [] };
+  }
+  const installedPaths = new Set(
+    artifacts.filter(
+      (artifact) => artifact.type === "file"
+    ).map((artifact) => toProjectPath(cwd, artifact.filePath))
+  );
+  const removed = [];
+  const preserved = [];
+  for (const file of previous.files) {
+    if (installedPaths.has(file.path)) {
+      continue;
+    }
+    const filePath = manifestPath(cwd, file.path);
+    if (!await pathExists(filePath)) {
+      continue;
+    }
+    if (!await manifestFileMatches(filePath, file.sha256)) {
+      preserved.push(file.path);
+      continue;
+    }
+    await unlink(filePath);
+    removed.push(file.path);
+    try {
+      await rmdir(path4.dirname(filePath));
+    } catch (error) {
+      if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) {
+        throw error;
+      }
+    }
+  }
+  return { removed, preserved };
+}
 async function manifestFileMatches(filePath, sha256) {
   if (!await pathExists(filePath)) {
     return false;
@@ -724,7 +759,9 @@ import path7 from "path";
 var LEGACY_STAGE_MAP = {
   WAITING_CONFIRM: "ANALYSIS",
   MEMORY_SHORT: "MEMORY",
-  MEMORY_LONG: "MEMORY"
+  MEMORY_LONG: "MEMORY",
+  REVIEW: "QUALITY",
+  VERIFICATION: "QUALITY"
 };
 function createProjectInitTask(params) {
   return {
@@ -813,7 +850,12 @@ function taskAgentFieldGroups(task) {
       fields: ["created_by", "last_agent", "workflow_mode_confirmed_by", "tdd_confirmed_by"]
     }
   ];
-  for (const field of ["pending_transition", "workflow_mode_proposal", "verification_checkpoint"]) {
+  for (const field of [
+    "pending_transition",
+    "workflow_mode_proposal",
+    "quality_checkpoint",
+    "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";
@@ -896,6 +938,26 @@ function migrateTaskWorkflowState(task) {
     task.status = LEGACY_STAGE_MAP[legacyStatus];
     changed = true;
   }
+  const pending = task.pending_transition;
+  if (pending && typeof pending === "object" && !Array.isArray(pending)) {
+    const record = pending;
+    const from = migrateStage(record.from);
+    const to = migrateStage(record.to);
+    if (from === to) {
+      task.pending_transition = void 0;
+      changed = true;
+    } else if (from !== record.from || to !== record.to) {
+      task.pending_transition = { ...record, from, to };
+      changed = true;
+    }
+  }
+  if (!task.quality_checkpoint && task.verification_checkpoint && typeof task.verification_checkpoint === "object" && !Array.isArray(task.verification_checkpoint)) {
+    task.quality_checkpoint = task.verification_checkpoint;
+  }
+  if ("verification_checkpoint" in task) {
+    task.verification_checkpoint = void 0;
+    changed = true;
+  }
   if (legacyStatus === "WAITING_CONFIRM" && !task.pending_transition) {
     const requestedAt = legacyRequestedAt && typeof legacyRequestedAt === "object" && !Array.isArray(legacyRequestedAt) ? String(
       legacyRequestedAt.entered_at ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -904,7 +966,7 @@ function migrateTaskWorkflowState(task) {
       from: "ANALYSIS",
       to: "IMPLEMENT",
       requested_at: requestedAt,
-      requested_by: String(task.last_agent ?? "upgrade-migration"),
+      requested_by: migratedAgentIdentity(task.last_agent) ?? "upgrade-migration",
       reason: "migrated-from-WAITING_CONFIRM"
     };
     changed = true;
@@ -921,9 +983,25 @@ function migrateTaskWorkflowState(task) {
   }
   const status2 = String(task.status ?? "");
   const taskType = String(task.type ?? "").toLowerCase();
-  const isActive = !["", "PENDING", "COMPLETE", "CLOSED"].includes(status2);
+  let isActive = !["", "PENDING", "COMPLETE", "CLOSED"].includes(status2);
+  if (isActive && ["analysis", "doc", "report"].includes(taskType)) {
+    task.status = "CLOSED";
+    task.closed_reason = "legacy-read-only-task-retired";
+    task.pending_transition = void 0;
+    task.stage_history = [
+      ...Array.isArray(task.stage_history) ? task.stage_history : [],
+      {
+        stage: "CLOSED",
+        agent: "upgrade-migration",
+        entered_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ];
+    task.last_agent = "upgrade-migration";
+    isActive = false;
+    changed = true;
+  }
   if (isActive && taskType !== "project-init" && !["fast", "standard", "strict"].includes(String(task.workflow_mode ?? ""))) {
-    task.workflow_mode = ["analysis", "doc", "report"].includes(taskType) ? "fast" : "strict";
+    task.workflow_mode = "standard";
     task.workflow_mode_confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
     task.workflow_mode_confirmed_by = "upgrade-migration";
     task.workflow_mode_legacy = true;
@@ -995,8 +1073,7 @@ function sessionMigrationCandidate(session) {
     currentTask: session.current_task,
     agent: typeof session.agent === "string" ? session.agent : void 0,
     lastAgent: typeof session.last_agent === "string" ? session.last_agent : void 0,
-    workflowMode,
-    legacyLite: session.workflow_mode_legacy_confirm_override === true
+    workflowMode
   };
 }
 function relevantSessionMigrationCandidates(task, candidates) {
@@ -1010,25 +1087,15 @@ function migrationWorkflowMode(task, candidates, projectWorkflowMode) {
   const taskType = String(task.type ?? "").toLowerCase();
   if (["analysis", "doc", "report"].includes(taskType)) return "fast";
   const relevantCandidates = relevantSessionMigrationCandidates(task, candidates);
-  const fallbackMode = projectWorkflowMode === "adaptive" ? "strict" : projectWorkflowMode;
+  const fallbackMode = projectWorkflowMode === "adaptive" ? "standard" : projectWorkflowMode;
   const concreteModes = relevantCandidates.map(
-    (candidate) => candidate.workflowMode === "adaptive" ? "strict" : candidate.workflowMode ?? fallbackMode
+    (candidate) => candidate.workflowMode === "adaptive" ? "standard" : candidate.workflowMode ?? fallbackMode
   );
   if (concreteModes.length === 0) return fallbackMode;
   return concreteModes.reduce(
     (highest, mode) => WORKFLOW_MODE_RANK[mode] > WORKFLOW_MODE_RANK[highest] ? mode : highest
   );
 }
-function preserveLegacyDirectEdge(task, candidates, projectLegacyLite) {
-  if (task.status !== "IMPLEMENT") return false;
-  const pending = task.pending_transition && typeof task.pending_transition === "object" && !Array.isArray(task.pending_transition) ? task.pending_transition : null;
-  if (pending?.from === "IMPLEMENT" && pending.to === "VERIFICATION") return true;
-  const relevantCandidates = relevantSessionMigrationCandidates(task, candidates);
-  if (relevantCandidates.length > 0) {
-    return relevantCandidates.every((candidate) => candidate.legacyLite);
-  }
-  return projectLegacyLite;
-}
 async function taskFiles(cwd) {
   const tasksDir = path7.join(cwd, EASY_CODING_DIR, TASKS_DIR);
   if (!await pathExists(tasksDir)) return [];
@@ -1054,7 +1121,7 @@ async function hasLegacyWorkflowState(cwd) {
     if (!await pathExists(filePath)) continue;
     const task = await readJsonRecord(filePath);
     if (!task) continue;
-    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(
+    if (hasLegacyTaskAgentIdentities(task) || isLegacyStage(task.status) || "verification_checkpoint" in task || !["PENDING", "COMPLETE", "CLOSED"].includes(String(task.status ?? "")) && ["analysis", "doc", "report"].includes(String(task.type ?? "").toLowerCase()) || !["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;
@@ -1077,14 +1144,11 @@ async function migrateLegacyWorkflowState(cwd) {
   let sessionsUpdated = 0;
   const updatedTaskPaths = /* @__PURE__ */ new Set();
   let projectWorkflowMode = "adaptive";
-  let projectLegacyLite = false;
   const configPath2 = path7.join(cwd, EASY_CODING_DIR, "config.yaml");
   if (await pathExists(configPath2)) {
     try {
       const config2 = await readConfigYaml(configPath2);
       projectWorkflowMode = resolveLegacyBehavior(config2).workflowMode;
-      const behavior = config2.behavior ?? {};
-      projectLegacyLite = behavior.confirm_mode === "lite";
     } catch {
     }
   }
@@ -1108,6 +1172,15 @@ async function migrateLegacyWorkflowState(cwd) {
       changed = true;
     }
     changed = migrateSessionBehavior(session) || changed;
+    if (typeof session.current_task === "string") {
+      const task = await readJsonRecord(getTaskJsonPath(cwd, session.current_task));
+      if (task && ["COMPLETE", "CLOSED"].includes(String(task.status ?? ""))) {
+        session.current_task = null;
+        session.last_seen_task = null;
+        session.last_seen_stage = "idle";
+        changed = true;
+      }
+    }
     const candidate = sessionMigrationCandidate(session);
     if (candidate) sessionCandidates.push(candidate);
     if (changed) {
@@ -1138,15 +1211,7 @@ async function migrateLegacyWorkflowState(cwd) {
       task.workflow_mode_confirmed_at = (/* @__PURE__ */ new Date()).toISOString();
       changed = true;
     }
-    const keepDirectEdge = preserveLegacyDirectEdge(
-      task,
-      candidatesByTask.get(taskId) ?? [],
-      projectLegacyLite
-    );
-    if (keepDirectEdge && task.workflow_mode_legacy_direct_edge !== true) {
-      task.workflow_mode_legacy_direct_edge = true;
-      changed = true;
-    } else if (!keepDirectEdge && "workflow_mode_legacy_direct_edge" in task) {
+    if ("workflow_mode_legacy_direct_edge" in task) {
       task.workflow_mode_legacy_direct_edge = void 0;
       changed = true;
     }
@@ -2210,6 +2275,16 @@ async function addAgent(opts) {
     throw new Error("No .easy-coding/config.yaml found. Run easy-coding init first.");
   }
   const platforms = await resolvePlatforms(opts, ["claude-code"]);
+  for (const target of targets) {
+    if (!await pathExists(target.configPath)) continue;
+    const config2 = await readConfigYaml(target.configPath);
+    const installedVersion = String(config2.harness_version ?? "");
+    if (installedVersion !== VERSION) {
+      throw new Error(
+        `${target.label}: installed harness ${installedVersion || "unknown"} does not match CLI ${VERSION}. Run easy-coding upgrade before add-agent.`
+      );
+    }
+  }
   const installedLabels = [];
   const refreshedLabels = [];
   for (const target of targets) {
@@ -3142,7 +3217,7 @@ async function config() {
       {
         value: "guard",
         label: "guard \u2014 confirm critical gates (default)",
-        hint: "ANALYSIS -> IMPLEMENT and VERIFICATION -> MEMORY"
+        hint: "ANALYSIS -> IMPLEMENT and QUALITY -> MEMORY"
       },
       {
         value: "confirm",
@@ -3487,12 +3562,16 @@ import path23 from "path";
 import chalk6 from "chalk";
 
 // src/utils/session.ts
-import { readdir as readdir7, unlink } from "fs/promises";
+import { readdir as readdir7, stat as stat3, unlink as unlink2 } from "fs/promises";
 import path22 from "path";
-var STALE_THRESHOLD_MS = 30 * 24 * 60 * 60 * 1e3;
+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;
   }
@@ -3527,6 +3606,138 @@ 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 unlink2(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 unlink2(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.quality_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() {
@@ -3608,6 +3819,10 @@ async function status() {
     console.log(
       `    harness: ${session.harness_disabled ? "disabled for this session" : "enabled"}`
     );
+    console.log(`    lite_mode: ${session.lite_mode === true ? "enabled" : "disabled"}`);
+    if (session.lite_proposal) {
+      console.log(`    lite_proposal: ${session.lite_proposal.digest}`);
+    }
     if (!session.current_task) {
       console.log("    current_task: none");
       continue;
@@ -3736,8 +3951,11 @@ async function upgrade(opts) {
       ...childTopologyRefreshes.map(({ target }) => `- ${target.label}: role: submodule-child`)
     ].filter(Boolean) : [],
     "Will overwrite managed skills, hooks, agents, templates, and generated main-constraint regions.",
+    "Will remove retired files that still match the previous install manifest and preserve locally modified copies.",
     "Will update project-init task to recommend ec-init re-run for version adaptation.",
     "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 active REVIEW/VERIFICATION tasks to QUALITY, retire active read-only task types as CLOSED, and preserve their artifacts and history.",
     "Will migrate legacy workflow/TDD task metadata; memory content, spec, and project knowledge files remain untouched."
   ].join("\n");
   if (opts.dryRun) {
@@ -3755,6 +3973,15 @@ async function upgrade(opts) {
     }
   }
   for (const { target, config: config2 } of pending) {
+    const previousManifest = await readInstallManifest(target.dir);
+    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
@@ -3763,6 +3990,14 @@ async function upgrade(opts) {
       supermodule: target.boundary,
       projectId
     });
+    const retiredFiles = await pruneRetiredManagedFiles(target.dir, previousManifest, artifacts);
+    if (retiredFiles.removed.length > 0 || retiredFiles.preserved.length > 0) {
+      console.log(
+        chalk8.yellow(
+          `${target.label}: removed ${retiredFiles.removed.length} retired managed file(s) and preserved ${retiredFiles.preserved.length} locally modified file(s).`
+        )
+      );
+    }
     await writeInstallManifest(target.dir, {
       harnessVersion: VERSION,
       agents: config2.agents,