easy-coding-harness 0.10.0-beta.8 → 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
@@ -311,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: "/",
@@ -334,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: "$",
@@ -358,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: "/",
@@ -483,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;
@@ -721,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 {
@@ -776,6 +816,92 @@ 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",
+    "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";
+    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;
@@ -806,11 +932,32 @@ 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;
   }
+  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()
@@ -819,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;
@@ -836,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;
@@ -858,7 +1021,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 ?? ""))) {
@@ -910,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) {
@@ -925,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 [];
@@ -969,7 +1121,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) || "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;
@@ -978,7 +1130,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;
 }
@@ -987,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 {
     }
   }
@@ -1018,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) {
@@ -1048,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;
     }
@@ -2120,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) {
@@ -3052,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",
@@ -3397,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;
   }
@@ -3437,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() {
@@ -3518,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;
@@ -3646,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) {
@@ -3665,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
@@ -3673,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,