easy-coding-harness 0.1.8 → 0.2.1

package/dist/cli.js

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import { Command } from "commander";
 
 // src/commands/add-agent.ts
-import path8 from "path";
+import path13 from "path";
 import { outro } from "@clack/prompts";
 import chalk2 from "chalk";
 
 // src/configurators/claude.ts
-import path4 from "path";
+import path5 from "path";
 
 // src/types/platform.ts
 var pythonCmd = process.platform === "win32" ? "python" : "python3";
@@ -88,13 +88,15 @@ function isAgentPlatform(value) {
   return Object.hasOwn(PLATFORM_META, value);
 }
 
-// src/configurators/shared.ts
-import { readdir, stat as stat2 } from "fs/promises";
-import path3 from "path";
+// src/utils/install-manifest.ts
+import { createHash } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
 
 // src/constants/paths.ts
 var EASY_CODING_DIR = ".easy-coding";
 var CONFIG_FILE = "config.yaml";
+var INSTALL_MANIFEST_FILE = "install-manifest.json";
 var SESSIONS_DIR = "sessions";
 var TASKS_DIR = "tasks";
 var PROJECT_INIT_TASK_ID = "project-init";
@@ -102,6 +104,7 @@ var MEMORY_DIR = "memory";
 var SPEC_DIR = "spec";
 var MAIN_SPEC_DIR = "main";
 var DEV_SPEC_DIR = "dev";
+var TEMPLATES_DIR = "templates";
 var SESSIONS_GITIGNORE_ENTRY = ".easy-coding/sessions/";
 var GENERATED_REGION_START = "<!-- \u2550\u2550\u2550 easy-coding-harness generated (DO NOT EDIT BETWEEN MARKERS) \u2550\u2550\u2550 -->";
 var GENERATED_REGION_END = "<!-- \u2550\u2550\u2550 end easy-coding-harness generated \u2550\u2550\u2550 -->";
@@ -143,6 +146,196 @@ async function isDirectory(filePath) {
   }
 }
 
+// src/utils/install-manifest.ts
+function fileArtifact(filePath, kind, platform) {
+  return { type: "file", kind, filePath, platform };
+}
+function constraintRegionArtifact(filePath, platform) {
+  return { type: "constraint-region", filePath, platform };
+}
+async function hookRegistrationArtifacts(configPath, platform) {
+  const content = await readTextIfExists(configPath);
+  if (content === null) {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  return collectHookCommands(parsed.hooks).map((command) => ({
+    type: "hook-registration",
+    configPath,
+    command,
+    hookPath: extractHookPathFromCommand(command),
+    platform
+  }));
+}
+async function writeInstallManifest(cwd, params) {
+  const existing = params.mode === "merge" ? await readInstallManifest(cwd) : null;
+  const files = /* @__PURE__ */ new Map();
+  const hookRegistrations = /* @__PURE__ */ new Map();
+  const constraintRegions = /* @__PURE__ */ new Map();
+  if (existing) {
+    for (const file of existing.files) {
+      files.set(file.path, file);
+    }
+    for (const registration of existing.hook_registrations) {
+      hookRegistrations.set(
+        `${registration.config_path}\0${normalizeCommand(registration.command)}`,
+        registration
+      );
+    }
+    for (const region of existing.constraint_regions) {
+      constraintRegions.set(region.path, region);
+    }
+  }
+  for (const artifact of params.artifacts) {
+    if (artifact.type === "file") {
+      if (!await pathExists(artifact.filePath)) {
+        continue;
+      }
+      const relPath2 = toProjectPath(cwd, artifact.filePath);
+      files.set(relPath2, {
+        path: relPath2,
+        kind: artifact.kind,
+        platform: artifact.platform,
+        sha256: await sha256File(artifact.filePath)
+      });
+      continue;
+    }
+    if (artifact.type === "hook-registration") {
+      const configPath = toProjectPath(cwd, artifact.configPath);
+      const registration = {
+        config_path: configPath,
+        command: artifact.command,
+        hook_path: artifact.hookPath,
+        platform: artifact.platform
+      };
+      hookRegistrations.set(`${configPath}\0${normalizeCommand(artifact.command)}`, registration);
+      continue;
+    }
+    const relPath = toProjectPath(cwd, artifact.filePath);
+    constraintRegions.set(relPath, {
+      path: relPath,
+      platform: artifact.platform
+    });
+  }
+  const manifest = {
+    schema_version: 1,
+    harness_version: params.harnessVersion,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...params.agents])],
+    files: [...files.values()].sort(byPath),
+    hook_registrations: [...hookRegistrations.values()].sort(
+      (a, b) => `${a.config_path}\0${a.command}`.localeCompare(`${b.config_path}\0${b.command}`)
+    ),
+    constraint_regions: [...constraintRegions.values()].sort(byPath)
+  };
+  await writeTextFile(
+    path2.join(cwd, EASY_CODING_DIR, INSTALL_MANIFEST_FILE),
+    JSON.stringify(manifest, null, 2)
+  );
+}
+async function readInstallManifest(cwd) {
+  const manifestPath2 = path2.join(cwd, EASY_CODING_DIR, INSTALL_MANIFEST_FILE);
+  const content = await readTextIfExists(manifestPath2);
+  if (content === null) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.schema_version !== 1 || !Array.isArray(parsed.files) || !Array.isArray(parsed.hook_registrations) || !Array.isArray(parsed.constraint_regions)) {
+      return null;
+    }
+    const agents = Array.isArray(parsed.agents) ? parsed.agents.filter((agent) => isAgentPlatform(agent)) : [];
+    return { ...parsed, agents };
+  } catch {
+    return null;
+  }
+}
+async function manifestFileMatches(filePath, sha256) {
+  if (!await pathExists(filePath)) {
+    return false;
+  }
+  return await sha256File(filePath) === sha256;
+}
+function manifestPath(cwd, projectPath) {
+  return resolveProjectPath(cwd, projectPath);
+}
+function toProjectPath(cwd, filePath) {
+  const root = path2.resolve(cwd);
+  const resolved = path2.resolve(filePath);
+  assertPathInsideProject(root, resolved, filePath);
+  return path2.relative(root, resolved).split(path2.sep).join("/");
+}
+function normalizeCommand(command) {
+  return command.replace(/\\/g, "/").trim().replace(/\s+/g, " ");
+}
+async function sha256File(filePath) {
+  const content = await readFile2(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+function resolveProjectPath(cwd, projectPath) {
+  const normalized = projectPath.replace(/\\/g, "/");
+  const parts = normalized.split("/");
+  if (normalized.trim() === "" || path2.isAbsolute(projectPath) || path2.posix.isAbsolute(normalized) || path2.win32.isAbsolute(projectPath) || /^[A-Za-z]:/.test(projectPath) || parts.some((part) => part === "..")) {
+    throw new Error(`Unsafe install manifest path: ${projectPath}`);
+  }
+  const root = path2.resolve(cwd);
+  const resolved = path2.resolve(root, normalized);
+  assertPathInsideProject(root, resolved, projectPath);
+  return resolved;
+}
+function assertPathInsideProject(root, resolvedPath, sourcePath) {
+  const relative = path2.relative(root, resolvedPath);
+  if (!relative || relative.startsWith("..") || path2.isAbsolute(relative)) {
+    throw new Error(`Unsafe install manifest path: ${sourcePath}`);
+  }
+}
+function collectHookCommands(hooks) {
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return [];
+  }
+  const commands = [];
+  for (const value of Object.values(hooks)) {
+    if (!Array.isArray(value)) {
+      continue;
+    }
+    for (const group of value) {
+      if (!group || typeof group !== "object") {
+        continue;
+      }
+      const hookItems = group.hooks;
+      if (!Array.isArray(hookItems)) {
+        continue;
+      }
+      for (const hook of hookItems) {
+        if (!hook || typeof hook !== "object") {
+          continue;
+        }
+        const command = hook.command;
+        if (typeof command === "string") {
+          commands.push(command);
+        }
+      }
+    }
+  }
+  return commands;
+}
+function extractHookPathFromCommand(command) {
+  const match = normalizeCommand(command).match(/(?:^|\s)(\S+\/hooks\/\S+\.py)(?:\s|$)/);
+  return match?.[1] ?? null;
+}
+function byPath(a, b) {
+  return a.path.localeCompare(b.path);
+}
+
+// src/configurators/shared.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import path4 from "path";
+
 // src/utils/marked-region.ts
 var MarkedRegionError = class extends Error {
   constructor(message) {
@@ -170,18 +363,27 @@ ${existing.trimStart()}`.trimEnd();
   }
   return existing.replace(currentRegion, generatedRegion.trim());
 }
+function removeMarkedRegion(content) {
+  const region = extractMarkedRegion(content);
+  if (!region) {
+    return content;
+  }
+  const remaining = content.replace(region, "").replace(/\n{3,}/g, "\n\n").trim();
+  return remaining ? `${remaining}
+` : "";
+}
 
 // src/utils/template-paths.ts
 import { existsSync } from "fs";
-import path2 from "path";
+import path3 from "path";
 import { fileURLToPath } from "url";
 function getTemplateRoot() {
-  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const here = path3.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path2.resolve(here, "../templates"),
-    path2.resolve(here, "../../templates"),
-    path2.resolve(process.cwd(), "src/templates"),
-    path2.resolve(process.cwd(), "templates")
+    path3.resolve(here, "../templates"),
+    path3.resolve(here, "../../templates"),
+    path3.resolve(process.cwd(), "src/templates"),
+    path3.resolve(process.cwd(), "templates")
   ];
   const found = candidates.find((candidate) => existsSync(candidate));
   if (!found) {
@@ -190,7 +392,7 @@ function getTemplateRoot() {
   return found;
 }
 function getTemplatePath(...segments) {
-  return path2.join(getTemplateRoot(), ...segments);
+  return path3.join(getTemplateRoot(), ...segments);
 }
 
 // src/configurators/shared.ts
@@ -217,11 +419,11 @@ async function resolveSkills(ctx) {
   const entries = await readdir(skillsRoot);
   const skills = [];
   for (const entry of entries.sort()) {
-    const skillDir = path3.join(skillsRoot, entry);
+    const skillDir = path4.join(skillsRoot, entry);
     if (!await isDirectory(skillDir)) {
       continue;
     }
-    const content = await readTextFile(path3.join(skillDir, "SKILL.md"));
+    const content = await readTextFile(path4.join(skillDir, "SKILL.md"));
     skills.push({
       name: entry,
       content: resolvePlaceholders(content, ctx, `common/skills/${entry}/SKILL.md`)
@@ -237,7 +439,7 @@ async function resolveBundledSkills(ctx) {
   const entries = await readdir(bundledRoot);
   const bundled = [];
   for (const entry of entries.sort()) {
-    const sourceDir = path3.join(bundledRoot, entry);
+    const sourceDir = path4.join(bundledRoot, entry);
     if (await isDirectory(sourceDir)) {
       bundled.push({ name: entry, sourceDir, context: ctx });
     }
@@ -246,23 +448,30 @@ async function resolveBundledSkills(ctx) {
 }
 async function writeSkills(dir, skills, bundled) {
   await ensureDir(dir);
+  const written = [];
   for (const skill of skills) {
-    await writeTextFile(path3.join(dir, skill.name, "SKILL.md"), skill.content);
+    const destination = path4.join(dir, skill.name, "SKILL.md");
+    await writeTextFile(destination, skill.content);
+    written.push(destination);
   }
   for (const skill of bundled) {
-    await copyTemplateDirectory(skill.sourceDir, path3.join(dir, skill.name), skill.context);
+    written.push(
+      ...await copyTemplateDirectory(skill.sourceDir, path4.join(dir, skill.name), skill.context)
+    );
   }
+  return written;
 }
 async function writeSharedHooks(dir, platform, opts = {}) {
   const hooksRoot = getTemplatePath("shared-hooks");
   const ctx = PLATFORM_META[platform].templateContext;
   const entries = await readdir(hooksRoot);
   await ensureDir(dir);
+  const written = [];
   for (const entry of entries.sort()) {
     if (opts.skipSubagentContext && entry === "inject-subagent-context.py") {
       continue;
     }
-    const sourcePath = path3.join(hooksRoot, entry);
+    const sourcePath = path4.join(hooksRoot, entry);
     if ((await stat2(sourcePath)).isDirectory()) {
       continue;
     }
@@ -271,14 +480,16 @@ async function writeSharedHooks(dir, platform, opts = {}) {
       ctx,
       `shared-hooks/${entry}`
     );
-    const destination = path3.join(dir, entry);
+    const destination = path4.join(dir, entry);
     await writeTextFile(destination, content);
     await import("fs/promises").then(({ chmod }) => chmod(destination, 493));
+    written.push(destination);
   }
+  return written;
 }
 async function copyPlatformTemplates(platformTemplateDir, destination, skipDirs, ctx) {
   const source = getTemplatePath(platformTemplateDir);
-  await copyTemplateDirectory(source, destination, ctx, new Set(skipDirs));
+  return copyTemplateDirectory(source, destination, ctx, new Set(skipDirs));
 }
 async function writeMainConstraint(cwd, platform) {
   const meta = PLATFORM_META[platform];
@@ -289,7 +500,7 @@ async function writeMainConstraint(cwd, platform) {
   if (!generated.includes(GENERATED_REGION_START) || !generated.includes(GENERATED_REGION_END)) {
     throw new Error(`Main constraint template ${templateName} does not contain generated markers.`);
   }
-  const destination = path3.join(cwd, meta.mainConstraint);
+  const destination = path4.join(cwd, meta.mainConstraint);
   const current = await readTextIfExists(destination);
   if (current) {
     const markerContent = extractMarkedRegion(generated);
@@ -300,23 +511,27 @@ async function writeMainConstraint(cwd, platform) {
   } else {
     await writeTextFile(destination, generated);
   }
+  return destination;
 }
 async function copyTemplateDirectory(source, destination, ctx, skipDirs = /* @__PURE__ */ new Set()) {
   await ensureDir(destination);
+  const written = [];
   for (const entry of (await readdir(source)).sort()) {
     if (skipDirs.has(entry) || shouldSkipTemplateEntry(entry)) {
       continue;
     }
-    const sourcePath = path3.join(source, entry);
-    const destinationPath = path3.join(destination, stripTemplateExtension(entry));
+    const sourcePath = path4.join(source, entry);
+    const destinationPath = path4.join(destination, stripTemplateExtension(entry));
     const sourceStat = await stat2(sourcePath);
     if (sourceStat.isDirectory()) {
-      await copyTemplateDirectory(sourcePath, destinationPath, ctx, skipDirs);
+      written.push(...await copyTemplateDirectory(sourcePath, destinationPath, ctx, skipDirs));
       continue;
     }
     const content = resolvePlaceholders(await readTextFile(sourcePath), ctx, sourcePath);
     await writeTextFile(destinationPath, content);
+    written.push(destinationPath);
   }
+  return written;
 }
 function shouldSkipTemplateEntry(entry) {
   return entry === ".DS_Store" || entry === "__pycache__" || entry.endsWith(".ts") || entry.endsWith(".js") || entry.endsWith(".map");
@@ -330,69 +545,194 @@ async function configureClaude(cwd) {
   const platform = "claude-code";
   const meta = PLATFORM_META[platform];
   const ctx = meta.templateContext;
-  const dest = path4.join(cwd, ".claude");
-  await copyPlatformTemplates("claude", dest, ["hooks"], ctx);
-  await writeSharedHooks(path4.join(dest, "hooks"), platform);
-  await writeSkills(
-    path4.join(cwd, meta.skillsDir),
-    await resolveSkills(ctx),
-    await resolveBundledSkills(ctx)
+  const dest = path5.join(cwd, ".claude");
+  const hookConfigPath = path5.join(cwd, meta.hookConfigFile);
+  const artifacts = [];
+  const platformFiles = await copyPlatformTemplates("claude", dest, ["hooks"], ctx);
+  artifacts.push(
+    ...platformFiles.filter((filePath) => filePath !== hookConfigPath).map(
+      (filePath) => fileArtifact(
+        filePath,
+        filePath.startsWith(path5.join(cwd, meta.agentsDir)) ? "agent" : "platform-config",
+        platform
+      )
+    )
+  );
+  artifacts.push(...await hookRegistrationArtifacts(hookConfigPath, platform));
+  artifacts.push(
+    ...(await writeSharedHooks(path5.join(dest, "hooks"), platform)).map(
+      (filePath) => fileArtifact(filePath, "hook", platform)
+    )
+  );
+  artifacts.push(
+    ...(await writeSkills(
+      path5.join(cwd, meta.skillsDir),
+      await resolveSkills(ctx),
+      await resolveBundledSkills(ctx)
+    )).map((filePath) => fileArtifact(filePath, "skill", platform))
   );
-  await writeMainConstraint(cwd, platform);
+  artifacts.push(constraintRegionArtifact(await writeMainConstraint(cwd, platform), platform));
+  return artifacts;
 }
 
 // src/configurators/codex.ts
-import path5 from "path";
+import path6 from "path";
 async function configureCodex(cwd) {
   const platform = "codex";
   const meta = PLATFORM_META[platform];
   const ctx = meta.templateContext;
-  await writeSkills(
-    path5.join(cwd, meta.skillsDir),
-    await resolveSkills(ctx),
-    await resolveBundledSkills(ctx)
+  const hookConfigPath = path6.join(cwd, meta.hookConfigFile);
+  const artifacts = [];
+  artifacts.push(
+    ...(await writeSkills(
+      path6.join(cwd, meta.skillsDir),
+      await resolveSkills(ctx),
+      await resolveBundledSkills(ctx)
+    )).map((filePath) => fileArtifact(filePath, "skill", platform))
   );
-  await writeSharedHooks(path5.join(cwd, meta.hooksDir), platform, { skipSubagentContext: true });
-  await copyPlatformTemplates("codex", path5.join(cwd, ".codex"), ["hooks"], ctx);
-  await writeMainConstraint(cwd, platform);
+  artifacts.push(
+    ...(await writeSharedHooks(path6.join(cwd, meta.hooksDir), platform, {
+      skipSubagentContext: true
+    })).map((filePath) => fileArtifact(filePath, "hook", platform))
+  );
+  const platformFiles = await copyPlatformTemplates(
+    "codex",
+    path6.join(cwd, ".codex"),
+    ["hooks"],
+    ctx
+  );
+  artifacts.push(
+    ...platformFiles.filter((filePath) => filePath !== hookConfigPath).map(
+      (filePath) => fileArtifact(
+        filePath,
+        filePath.startsWith(path6.join(cwd, meta.agentsDir)) ? "agent" : "platform-config",
+        platform
+      )
+    )
+  );
+  artifacts.push(...await hookRegistrationArtifacts(hookConfigPath, platform));
+  artifacts.push(constraintRegionArtifact(await writeMainConstraint(cwd, platform), platform));
+  return artifacts;
 }
 
 // src/configurators/qoder.ts
-import { existsSync as existsSync2, readdirSync } from "fs";
-import path6 from "path";
-function claudeSkillsExist(cwd) {
-  const claudeSkillsDir = path6.join(cwd, ".claude", "skills");
-  if (!existsSync2(claudeSkillsDir)) return false;
+import { readdir as readdir2 } from "fs/promises";
+import path8 from "path";
+
+// src/utils/platform-paths.ts
+import { existsSync as existsSync2 } from "fs";
+import path7 from "path";
+function detectQoderCnVariant(cwd) {
+  if (process.env.EC_QODER_VARIANT === "cn" || process.env.QODER_VARIANT === "cn") {
+    return true;
+  }
+  return existsSync2(path7.join(cwd, PLATFORM_META.qoder.cnVariant ?? ".qodercn"));
+}
+function resolvePlatformMeta(cwd, platform) {
+  const meta = PLATFORM_META[platform];
+  if (platform !== "qoder" || !detectQoderCnVariant(cwd)) {
+    return meta;
+  }
+  return resolveQoderMetaForBaseDir(meta.cnVariant ?? ".qodercn");
+}
+function resolveQoderVariantMetas() {
+  const standardDir = PLATFORM_META.qoder.templateContext.platform_config_dir;
+  const cnDir = PLATFORM_META.qoder.cnVariant ?? ".qodercn";
+  return [.../* @__PURE__ */ new Set([standardDir, cnDir])].map(resolveQoderMetaForBaseDir);
+}
+function resolveQoderMetaForBaseDir(baseDir) {
+  const meta = PLATFORM_META.qoder;
+  return {
+    ...meta,
+    skillsDir: `${baseDir}/skills`,
+    hooksDir: `${baseDir}/hooks`,
+    hookConfigFile: `${baseDir}/settings.json`,
+    agentsDir: `${baseDir}/agents`,
+    templateContext: {
+      ...meta.templateContext,
+      platform_config_dir: baseDir
+    }
+  };
+}
+
+// src/configurators/qoder.ts
+async function claudeHarnessSkillsExist(cwd) {
+  return pathExists(path8.join(cwd, ".claude", "skills", "ec-workflow", "SKILL.md"));
+}
+async function listFilesRecursive(dir) {
+  let entries;
   try {
-    return readdirSync(claudeSkillsDir).some((d) => d.startsWith("ec-"));
-  } catch {
-    return false;
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
   }
+  const files = [];
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const entryPath = path8.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursive(entryPath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+async function existingManagedSkillArtifacts(skillsDir, skillNames, platform) {
+  const artifacts = [];
+  for (const skillName of skillNames) {
+    for (const filePath of await listFilesRecursive(path8.join(skillsDir, skillName))) {
+      artifacts.push(fileArtifact(filePath, "skill", platform));
+    }
+  }
+  return artifacts;
 }
 async function configureQoder(cwd) {
   const platform = "qoder";
-  const baseDir = detectQoderCnVariant(cwd) ? ".qodercn" : ".qoder";
-  const ctx = {
-    ...PLATFORM_META[platform].templateContext,
-    platform_config_dir: baseDir
-  };
-  const dest = path6.join(cwd, baseDir);
-  await copyPlatformTemplates("qoder", dest, ["hooks"], ctx);
-  await writeSharedHooks(path6.join(dest, "hooks"), platform);
-  if (!claudeSkillsExist(cwd)) {
-    await writeSkills(
-      path6.join(dest, "skills"),
-      await resolveSkills(ctx),
-      await resolveBundledSkills(ctx)
+  const meta = resolvePlatformMeta(cwd, platform);
+  const ctx = meta.templateContext;
+  const dest = path8.join(cwd, ctx.platform_config_dir);
+  const hookConfigPath = path8.join(cwd, meta.hookConfigFile);
+  const artifacts = [];
+  const platformFiles = await copyPlatformTemplates("qoder", dest, ["hooks"], ctx);
+  artifacts.push(
+    ...platformFiles.filter((filePath) => filePath !== hookConfigPath).map(
+      (filePath) => fileArtifact(
+        filePath,
+        filePath.startsWith(path8.join(cwd, meta.agentsDir)) ? "agent" : "platform-config",
+        platform
+      )
+    )
+  );
+  artifacts.push(...await hookRegistrationArtifacts(hookConfigPath, platform));
+  artifacts.push(
+    ...(await writeSharedHooks(path8.join(dest, "hooks"), platform)).map(
+      (filePath) => fileArtifact(filePath, "hook", platform)
+    )
+  );
+  const skills = await resolveSkills(ctx);
+  const bundledSkills = await resolveBundledSkills(ctx);
+  if (!await claudeHarnessSkillsExist(cwd)) {
+    artifacts.push(
+      ...(await writeSkills(path8.join(dest, "skills"), skills, bundledSkills)).map(
+        (filePath) => fileArtifact(filePath, "skill", platform)
+      )
+    );
+  } else {
+    artifacts.push(
+      ...await existingManagedSkillArtifacts(
+        path8.join(dest, "skills"),
+        [...skills.map((skill) => skill.name), ...bundledSkills.map((skill) => skill.name)],
+        platform
+      )
     );
   }
-  await writeMainConstraint(cwd, platform);
-}
-function detectQoderCnVariant(cwd) {
-  if (process.env.EC_QODER_VARIANT === "cn" || process.env.QODER_VARIANT === "cn") {
-    return true;
-  }
-  return existsSync2(path6.join(cwd, ".qodercn"));
+  artifacts.push(constraintRegionArtifact(await writeMainConstraint(cwd, platform), platform));
+  return artifacts;
 }
 
 // src/configurators/index.ts
@@ -402,23 +742,19 @@ var CONFIGURATORS = {
   qoder: configureQoder
 };
 
-// src/ui/banner.ts
-import chalk from "chalk";
-import figlet from "figlet";
-
 // src/constants/version.ts
 import { readFileSync } from "fs";
-import path7 from "path";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var packageMetadata = readPackageMetadata();
 var PACKAGE_NAME = packageMetadata.name;
 var VERSION = packageMetadata.version;
 function readPackageMetadata() {
-  const here = path7.dirname(fileURLToPath2(import.meta.url));
+  const here = path9.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path7.resolve(here, "../../package.json"),
-    path7.resolve(here, "../package.json"),
-    path7.resolve(process.cwd(), "package.json")
+    path9.resolve(here, "../../package.json"),
+    path9.resolve(here, "../package.json"),
+    path9.resolve(process.cwd(), "package.json")
   ];
   for (const candidate of candidates) {
     try {
@@ -433,6 +769,8 @@ function readPackageMetadata() {
 }
 
 // src/ui/banner.ts
+import chalk from "chalk";
+import figlet from "figlet";
 var WIDE_TERMINAL_WIDTH = 88;
 var MEDIUM_TERMINAL_WIDTH = 72;
 function renderBanner() {
@@ -457,7 +795,7 @@ function colorizeBanner(art) {
 }
 
 // src/utils/config-yaml.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import YAML, { isScalar, isSeq, parseDocument } from "yaml";
 function createDefaultConfig(params) {
   return {
@@ -465,18 +803,13 @@ function createDefaultConfig(params) {
     harness_version: params.harnessVersion,
     agents: params.agents,
     project: {
-      name: params.projectName,
-      mode: "auto"
+      name: params.projectName
     },
     memory: {
       short_term_max: 10,
       short_term_keep: 5,
       schema_version: 2
     },
-    test: {
-      framework: "auto",
-      command: ""
-    },
     tasks: {
       auto_archive_days: 30
     },
@@ -493,11 +826,11 @@ async function writeConfigYaml(filePath, config) {
   await writeTextFile(filePath, stringifyConfig(config));
 }
 async function readConfigYaml(filePath) {
-  const content = await readFile2(filePath, "utf8");
+  const content = await readFile3(filePath, "utf8");
   return YAML.parse(content);
 }
 async function updateConfigYaml(filePath, updater) {
-  const content = await readFile2(filePath, "utf8");
+  const content = await readFile3(filePath, "utf8");
   const document = parseDocument(content);
   const config = document.toJSON();
   updater(config);
@@ -519,87 +852,10 @@ async function updateHarnessVersion(filePath, version) {
   });
 }
 
-// src/commands/platforms.ts
-import { cancel, confirm, multiselect } from "@clack/prompts";
-function parseAgentList(agentList) {
-  const values = agentList.split(",").map((value) => value.trim()).filter(Boolean);
-  if (values.length === 0) {
-    throw new Error("No agent platform specified.");
-  }
-  const invalid = values.filter((value) => !isAgentPlatform(value));
-  if (invalid.length > 0) {
-    throw new Error(`Unknown agent platform: ${invalid.join(", ")}`);
-  }
-  return [...new Set(values)];
-}
-async function resolvePlatforms(opts, defaults = ["claude-code"]) {
-  if (opts.agent) {
-    return parseAgentList(opts.agent);
-  }
-  if (opts.yes) {
-    return defaults;
-  }
-  let selectedDefaults = defaults;
-  while (true) {
-    const result = await multiselect({
-      message: "Select agent platforms (Space to toggle, Enter to review)",
-      options: AGENT_PLATFORMS.map((platform) => ({
-        label: PLATFORM_META[platform].label,
-        value: platform
-      })),
-      initialValues: selectedDefaults,
-      required: true
-    });
-    if (typeof result === "symbol") {
-      cancel("Platform selection cancelled.");
-      process.exit(1);
-    }
-    const labels = result.map((platform) => PLATFORM_META[platform].label).join(", ");
-    const shouldInstall = await confirm({
-      message: `Install Easy Coding for: ${labels}?`,
-      initialValue: true
-    });
-    if (typeof shouldInstall === "symbol") {
-      cancel("Platform selection cancelled.");
-      process.exit(1);
-    }
-    if (shouldInstall) {
-      return result;
-    }
-    selectedDefaults = result;
-  }
-}
-
-// src/commands/add-agent.ts
-async function addAgent(opts) {
-  renderBanner();
-  const cwd = process.cwd();
-  const configPath = path8.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
-  if (!await pathExists(configPath)) {
-    throw new Error("No .easy-coding/config.yaml found. Run easy-coding init first.");
-  }
-  const config = await readConfigYaml(configPath);
-  const platforms = await resolvePlatforms(opts, ["claude-code"]);
-  const toInstall = platforms.filter((platform) => !config.agents.includes(platform));
-  if (toInstall.length === 0) {
-    outro(chalk2.yellow("All selected agent platforms are already installed."));
-    return;
-  }
-  for (const platform of toInstall) {
-    await CONFIGURATORS[platform](cwd);
-  }
-  await addAgentsToConfig(configPath, toInstall);
-  outro(chalk2.green(`Added agent platforms: ${toInstall.join(", ")}`));
-}
-
-// src/commands/init.ts
-import { note, outro as outro2 } from "@clack/prompts";
-import chalk3 from "chalk";
-
 // src/utils/gitignore.ts
-import path9 from "path";
+import path10 from "path";
 async function ensureGitignoreEntry(cwd, entry, heading = "# \u2550\u2550\u2550 easy-coding-harness (auto-generated) \u2550\u2550\u2550\n# Personal runtime state; do not commit") {
-  const gitignorePath = path9.join(cwd, ".gitignore");
+  const gitignorePath = path10.join(cwd, ".gitignore");
   const current = await readTextIfExists(gitignorePath) ?? "";
   const lines = current.split(/\r?\n/).map((line) => line.trim());
   if (lines.includes(entry)) {
@@ -614,90 +870,32 @@ async function ensureEasyCodingSessionsIgnored(cwd) {
   return ensureGitignoreEntry(cwd, SESSIONS_GITIGNORE_ENTRY);
 }
 
-// src/utils/install-state.ts
-import { readdir as readdir2 } from "fs/promises";
-import path10 from "path";
-var LEGACY_ROOT_FILES = ["SOUL.md", "RULES.md", "ABSTRACT.md"];
-async function detectEasyCodingInstallState(cwd) {
-  const easyCodingDir = path10.join(cwd, EASY_CODING_DIR);
-  if (!await pathExists(easyCodingDir)) {
-    return { kind: "fresh", easyCodingDir };
-  }
-  const configPath = path10.join(easyCodingDir, CONFIG_FILE);
-  if (await pathExists(configPath)) {
-    return { kind: "installed", easyCodingDir, configPath };
-  }
-  const legacyAssets = await detectLegacyAssets(easyCodingDir);
-  if (legacyAssets.length === 0) {
-    return { kind: "unknown", easyCodingDir };
+// src/utils/runtime-scaffold.ts
+import path11 from "path";
+async function writeRuntimeScaffold(cwd, agents) {
+  const easyCodingDir = path11.join(cwd, EASY_CODING_DIR);
+  await ensureDir(easyCodingDir);
+  const configPath = path11.join(easyCodingDir, CONFIG_FILE);
+  if (!await pathExists(configPath)) {
+    const projectName = path11.basename(cwd);
+    await writeConfigYaml(
+      configPath,
+      createDefaultConfig({ projectName, harnessVersion: VERSION, agents })
+    );
   }
-  return {
-    kind: "legacy",
-    easyCodingDir,
-    legacyAssets,
-    missingHarnessFiles: [relativeConfigPath(), relativeProjectInitTaskPath()]
-  };
+  await ensureDir(path11.join(easyCodingDir, "tasks"));
+  await ensureDir(path11.join(easyCodingDir, SESSIONS_DIR));
+  await ensureDir(path11.join(easyCodingDir, SPEC_DIR, MAIN_SPEC_DIR));
+  await ensureDir(path11.join(easyCodingDir, SPEC_DIR, DEV_SPEC_DIR));
+  await writeMemoryScaffold(easyCodingDir);
+  await writeTemplatesScaffold(easyCodingDir);
 }
-async function detectLegacyAssets(easyCodingDir) {
-  const assets = [];
-  for (const file of LEGACY_ROOT_FILES) {
-    if (await pathExists(path10.join(easyCodingDir, file))) {
-      assets.push(relativeEasyCodingPath(file));
-    }
-  }
-  if (await pathExists(path10.join(easyCodingDir, "memory", "long", "MEMORY.md"))) {
-    assets.push(relativeEasyCodingPath("memory", "long", "MEMORY.md"));
-  }
-  const shortMemoryFiles = await listMarkdownFiles(path10.join(easyCodingDir, "memory", "short"));
-  assets.push(...shortMemoryFiles.map((file) => relativeEasyCodingPath("memory", "short", file)));
-  for (const dir of ["spec", "prototype"]) {
-    if (await hasAnyDirectoryEntry(path10.join(easyCodingDir, dir))) {
-      assets.push(relativeEasyCodingPath(dir));
-    }
-  }
-  return assets.sort();
-}
-async function listMarkdownFiles(dir) {
-  if (!await isDirectory(dir)) {
-    return [];
-  }
-  const entries = await readdir2(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 readdir2(dir)).length > 0;
-}
-function relativeEasyCodingPath(...segments) {
-  return path10.posix.join(EASY_CODING_DIR, ...segments);
-}
-function relativeConfigPath() {
-  return path10.posix.join(EASY_CODING_DIR, CONFIG_FILE);
-}
-function relativeProjectInitTaskPath() {
-  return path10.posix.join(EASY_CODING_DIR, TASKS_DIR, PROJECT_INIT_TASK_ID, "task.json");
-}
-
-// src/utils/runtime-scaffold.ts
-import path11 from "path";
-async function writeRuntimeScaffold(cwd, agents) {
-  const easyCodingDir = path11.join(cwd, EASY_CODING_DIR);
-  await ensureDir(easyCodingDir);
-  const configPath = path11.join(easyCodingDir, CONFIG_FILE);
-  if (!await pathExists(configPath)) {
-    const projectName = path11.basename(cwd);
-    await writeConfigYaml(
-      configPath,
-      createDefaultConfig({ projectName, harnessVersion: VERSION, agents })
-    );
-  }
-  await ensureDir(path11.join(easyCodingDir, "tasks"));
-  await ensureDir(path11.join(easyCodingDir, SESSIONS_DIR));
-  await ensureDir(path11.join(easyCodingDir, SPEC_DIR, MAIN_SPEC_DIR));
-  await ensureDir(path11.join(easyCodingDir, SPEC_DIR, DEV_SPEC_DIR));
-  await writeMemoryScaffold(easyCodingDir);
+async function writeTemplatesScaffold(easyCodingDir) {
+  const templatesDir = path11.join(easyCodingDir, TEMPLATES_DIR);
+  await ensureDir(templatesDir);
+  const src = getTemplatePath("runtime", "templates", "dev-spec-skeleton.md");
+  const dest = path11.join(templatesDir, "dev-spec-skeleton.md");
+  await writeTextFile(dest, await readTextFile(src));
 }
 async function writeMemoryScaffold(easyCodingDir) {
   const memoryDir = path11.join(easyCodingDir, MEMORY_DIR);
@@ -711,6 +909,11 @@ async function writeMemoryScaffold(easyCodingDir) {
     const templatePath = getTemplatePath("runtime", "memory", "long", file);
     await writeTextFile(destination, await readTextFile(templatePath));
   }
+  const shortTemplateDest = path11.join(memoryDir, "SHORT_MEMORY_TEMPLATE.md");
+  if (!await pathExists(shortTemplateDest)) {
+    const templatePath = getTemplatePath("runtime", "memory", "SHORT_MEMORY_TEMPLATE.md");
+    await writeTextFile(shortTemplateDest, await readTextFile(templatePath));
+  }
 }
 
 // src/utils/task-json.ts
@@ -756,6 +959,14 @@ async function writeProjectInitTask(cwd, agents, options = {}) {
     })
   );
 }
+async function setPendingInitSince(cwd, version) {
+  const filePath = getTaskJsonPath(cwd, PROJECT_INIT_TASK_ID);
+  if (!await pathExists(filePath)) return;
+  const task = await readTaskJson(filePath);
+  if (task.status !== "COMPLETE") return;
+  task.pending_init_since = version;
+  await writeTaskJson(filePath, task);
+}
 async function listTasks(cwd) {
   const tasksDir = path12.join(cwd, EASY_CODING_DIR, TASKS_DIR);
   if (!await pathExists(tasksDir)) {
@@ -788,6 +999,672 @@ function isActiveTask(task) {
   return task.status !== "COMPLETE" && task.status !== "CLOSED";
 }
 
+// src/commands/platforms.ts
+import { cancel, confirm, multiselect } from "@clack/prompts";
+function parseAgentList(agentList) {
+  const values = agentList.split(",").map((value) => value.trim()).filter(Boolean);
+  if (values.length === 0) {
+    throw new Error("No agent platform specified.");
+  }
+  const invalid = values.filter((value) => !isAgentPlatform(value));
+  if (invalid.length > 0) {
+    throw new Error(`Unknown agent platform: ${invalid.join(", ")}`);
+  }
+  return [...new Set(values)];
+}
+async function resolvePlatforms(opts, defaults = ["claude-code"]) {
+  if (opts.agent) {
+    return parseAgentList(opts.agent);
+  }
+  if (opts.yes) {
+    return defaults;
+  }
+  let selectedDefaults = defaults;
+  while (true) {
+    const result = await multiselect({
+      message: "Select agent platforms (Space to toggle, Enter to review)",
+      options: AGENT_PLATFORMS.map((platform) => ({
+        label: PLATFORM_META[platform].label,
+        value: platform
+      })),
+      initialValues: selectedDefaults,
+      required: true
+    });
+    if (typeof result === "symbol") {
+      cancel("Platform selection cancelled.");
+      process.exit(1);
+    }
+    const labels = result.map((platform) => PLATFORM_META[platform].label).join(", ");
+    const shouldInstall = await confirm({
+      message: `Install Easy Coding for: ${labels}?`,
+      initialValue: true
+    });
+    if (typeof shouldInstall === "symbol") {
+      cancel("Platform selection cancelled.");
+      process.exit(1);
+    }
+    if (shouldInstall) {
+      return result;
+    }
+    selectedDefaults = result;
+  }
+}
+
+// src/commands/add-agent.ts
+async function addAgent(opts) {
+  renderBanner();
+  const cwd = process.cwd();
+  const configPath = path13.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  if (!await pathExists(configPath)) {
+    throw new Error("No .easy-coding/config.yaml found. Run easy-coding init first.");
+  }
+  const config = await readConfigYaml(configPath);
+  const platforms = await resolvePlatforms(opts, ["claude-code"]);
+  const toInstall = platforms.filter((platform) => !config.agents.includes(platform));
+  if (toInstall.length === 0) {
+    outro(chalk2.yellow("All selected agent platforms are already installed."));
+    return;
+  }
+  const artifacts = [];
+  for (const platform of toInstall) {
+    artifacts.push(...await CONFIGURATORS[platform](cwd));
+  }
+  await writeRuntimeScaffold(cwd, [...config.agents, ...toInstall]);
+  await writeInstallManifest(cwd, {
+    harnessVersion: VERSION,
+    agents: toInstall,
+    artifacts,
+    mode: "merge"
+  });
+  await ensureEasyCodingSessionsIgnored(cwd);
+  await addAgentsToConfig(configPath, toInstall);
+  await setPendingInitSince(cwd, VERSION);
+  outro(chalk2.green(`Added agent platforms: ${toInstall.join(", ")}`));
+}
+
+// src/commands/clear.ts
+import { readdir as readdir4, rm, writeFile } from "fs/promises";
+import path14 from "path";
+import { cancel as cancel2, confirm as confirm2, outro as outro2 } from "@clack/prompts";
+import chalk3 from "chalk";
+var PLATFORM_TEMPLATE_DIR = {
+  "claude-code": "claude",
+  codex: "codex",
+  qoder: "qoder"
+};
+async function clear(opts) {
+  renderBanner();
+  const cwd = process.cwd();
+  const easyCodingDir = path14.join(cwd, EASY_CODING_DIR);
+  if (!await pathExists(easyCodingDir)) {
+    throw new Error("No .easy-coding directory found in this project \u2014 nothing to clear.");
+  }
+  const agents = await resolveInstalledAgents(cwd);
+  const plan = await buildClearPlan(cwd, agents);
+  console.log(renderPlan(cwd, agents, plan));
+  if (opts.dryRun) {
+    return;
+  }
+  if (!opts.yes) {
+    const ok = await confirm2({
+      message: "Remove these harness files? Tasks, spec, memory, and knowledge files are kept.",
+      initialValue: false
+    });
+    if (typeof ok === "symbol" || !ok) {
+      cancel2("Clear cancelled.");
+      return;
+    }
+  }
+  await executeClearPlan(plan);
+  outro2(chalk3.green("Easy Coding harness removed. Run easy-coding init to reinstall."));
+}
+async function resolveInstalledAgents(cwd) {
+  const configPath = path14.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  if (await pathExists(configPath)) {
+    try {
+      const config = await readConfigYaml(configPath);
+      const listed = Array.isArray(config.agents) ? config.agents.filter(isAgentPlatform) : [];
+      if (listed.length > 0) {
+        return listed;
+      }
+    } catch {
+    }
+  }
+  const detected = [];
+  for (const platform of AGENT_PLATFORMS) {
+    if (await hasPlatformInstall(cwd, platform)) {
+      detected.push(platform);
+    }
+  }
+  return detected;
+}
+async function hasPlatformInstall(cwd, platform) {
+  const metas = platform === "qoder" ? resolveQoderVariantMetas() : [resolvePlatformMeta(cwd, platform)];
+  for (const meta of metas) {
+    if (await hasInstallMarkers(cwd, meta)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function hasInstallMarkers(cwd, meta) {
+  const markers = [meta.skillsDir, meta.hooksDir, meta.agentsDir, meta.hookConfigFile];
+  for (const marker of markers) {
+    if (await pathExists(path14.join(cwd, marker))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function resolveClearPlatformMetas(cwd, platform) {
+  if (platform !== "qoder") {
+    return [resolvePlatformMeta(cwd, platform)];
+  }
+  const installed = [];
+  for (const meta of resolveQoderVariantMetas()) {
+    if (await hasInstallMarkers(cwd, meta)) {
+      installed.push(meta);
+    }
+  }
+  return installed.length > 0 ? installed : [resolvePlatformMeta(cwd, platform)];
+}
+async function buildClearPlan(cwd, agents) {
+  const manifest = await readInstallManifest(cwd);
+  if (manifest) {
+    const plan2 = await buildManifestClearPlan(cwd, agents, manifest);
+    const manifestAgents = new Set(manifest.agents.filter(isAgentPlatform));
+    const missingAgents = agents.filter((agent) => !manifestAgents.has(agent));
+    if (missingAgents.length > 0) {
+      mergeClearPlan(plan2, await buildTemplateClearPlan(cwd, missingAgents));
+    }
+    if (manifestAgents.has("qoder") && agents.includes("qoder")) {
+      const uncoveredQoderMetas = await resolveManifestUncoveredQoderMetas(cwd, manifest);
+      if (uncoveredQoderMetas.length > 0) {
+        mergeClearPlan(
+          plan2,
+          await buildTemplateClearPlanForMetas(cwd, "qoder", uncoveredQoderMetas)
+        );
+      }
+    }
+    addRuntimeClearEntries(plan2, cwd);
+    return plan2;
+  }
+  const plan = await buildTemplateClearPlan(cwd, agents);
+  addRuntimeClearEntries(plan, cwd);
+  return plan;
+}
+async function buildManifestClearPlan(cwd, agents, manifest) {
+  const plan = createClearPlan();
+  const agentSet = new Set(agents);
+  for (const file of manifest.files) {
+    if (!agentSet.has(file.platform)) {
+      continue;
+    }
+    const filePath = manifestPath(cwd, file.path);
+    if (!await pathExists(filePath)) {
+      continue;
+    }
+    if (await manifestFileMatches(filePath, file.sha256)) {
+      plan.removeFiles.push({ filePath, expectedSha256: file.sha256 });
+      addEmptyDirChain(plan.emptyDirs, path14.dirname(filePath), cwd);
+    } else {
+      plan.skippedModified.push(filePath);
+    }
+  }
+  for (const registration of manifest.hook_registrations) {
+    if (!agentSet.has(registration.platform)) {
+      continue;
+    }
+    addHookConfigPrune(
+      plan.pruneHookConfigs,
+      plan.pruneHookCommands,
+      manifestPath(cwd, registration.config_path),
+      registration.hook_path ? [registration.hook_path] : [],
+      [registration.command]
+    );
+  }
+  for (const region of manifest.constraint_regions) {
+    if (!agentSet.has(region.platform)) {
+      continue;
+    }
+    plan.constraints.add(manifestPath(cwd, region.path));
+  }
+  return finalizeClearPlan(plan);
+}
+async function buildTemplateClearPlan(cwd, agents) {
+  const plan = createClearPlan();
+  const managedSkills = await listDirNames(getTemplatePath("common", "skills"));
+  managedSkills.push(...await listDirNames(getTemplatePath("common", "bundled-skills")));
+  for (const platform of agents) {
+    const metas = await resolveClearPlatformMetas(cwd, platform);
+    await addTemplateClearEntries(plan, cwd, platform, metas, managedSkills);
+  }
+  return finalizeClearPlan(plan);
+}
+async function buildTemplateClearPlanForMetas(cwd, platform, metas) {
+  const plan = createClearPlan();
+  const managedSkills = await listDirNames(getTemplatePath("common", "skills"));
+  managedSkills.push(...await listDirNames(getTemplatePath("common", "bundled-skills")));
+  await addTemplateClearEntries(plan, cwd, platform, metas, managedSkills);
+  return finalizeClearPlan(plan);
+}
+async function addTemplateClearEntries(plan, cwd, platform, metas, managedSkills) {
+  const hookFileNames = await listSharedHookNamesForPlatform(platform);
+  const agentFileNames = await listFileNames(
+    getTemplatePath(PLATFORM_TEMPLATE_DIR[platform], "agents")
+  );
+  for (const meta of metas) {
+    for (const name of managedSkills) {
+      plan.remove.add(path14.join(cwd, meta.skillsDir, name));
+    }
+    for (const name of hookFileNames) {
+      plan.remove.add(path14.join(cwd, meta.hooksDir, name));
+    }
+    for (const name of agentFileNames) {
+      plan.remove.add(path14.join(cwd, meta.agentsDir, name));
+    }
+    addHookConfigPrune(
+      plan.pruneHookConfigs,
+      plan.pruneHookCommands,
+      path14.join(cwd, meta.hookConfigFile),
+      hookFileNames.map((name) => `${meta.templateContext.platform_config_dir}/hooks/${name}`),
+      []
+    );
+    plan.constraints.add(path14.join(cwd, meta.mainConstraint));
+    if (platform === "codex") {
+      plan.remove.add(path14.join(cwd, meta.templateContext.platform_config_dir, "config.toml"));
+    }
+    plan.emptyDirs.add(path14.join(cwd, meta.skillsDir));
+    plan.emptyDirs.add(path14.join(cwd, meta.hooksDir));
+    plan.emptyDirs.add(path14.join(cwd, meta.agentsDir));
+  }
+}
+async function resolveManifestUncoveredQoderMetas(cwd, manifest) {
+  const coveredBaseDirs = manifestCoveredQoderBaseDirs(manifest);
+  const metas = [];
+  for (const meta of resolveQoderVariantMetas()) {
+    const baseDir = meta.templateContext.platform_config_dir;
+    if (coveredBaseDirs.has(baseDir)) {
+      continue;
+    }
+    if (await hasInstallMarkers(cwd, meta)) {
+      metas.push(meta);
+    }
+  }
+  return metas;
+}
+function manifestCoveredQoderBaseDirs(manifest) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const meta of resolveQoderVariantMetas()) {
+    const baseDir = meta.templateContext.platform_config_dir.replace(/\\/g, "/");
+    const prefix = `${baseDir}/`;
+    if (manifest.files.some((file) => file.platform === "qoder" && file.path.startsWith(prefix)) || manifest.hook_registrations.some(
+      (registration) => registration.platform === "qoder" && (registration.config_path === meta.hookConfigFile || registration.config_path.startsWith(prefix) || Boolean(registration.hook_path?.startsWith(prefix)))
+    )) {
+      covered.add(baseDir);
+    }
+  }
+  return covered;
+}
+function addHookConfigPrune(pruneHookConfigs, pruneHookCommands, filePath, managedHookPaths, managedHookCommands) {
+  const existingPaths = pruneHookConfigs.get(filePath) ?? /* @__PURE__ */ new Set();
+  for (const managedHookPath of managedHookPaths) {
+    existingPaths.add(managedHookPath);
+  }
+  pruneHookConfigs.set(filePath, existingPaths);
+  const existingCommands = pruneHookCommands.get(filePath) ?? /* @__PURE__ */ new Set();
+  for (const managedHookCommand of managedHookCommands) {
+    existingCommands.add(managedHookCommand);
+  }
+  pruneHookCommands.set(filePath, existingCommands);
+}
+function createClearPlan() {
+  return {
+    remove: /* @__PURE__ */ new Set(),
+    removeFiles: [],
+    skippedModified: [],
+    pruneHookConfigs: /* @__PURE__ */ new Map(),
+    pruneHookCommands: /* @__PURE__ */ new Map(),
+    constraints: /* @__PURE__ */ new Set(),
+    emptyDirs: /* @__PURE__ */ new Set()
+  };
+}
+function finalizeClearPlan(plan) {
+  return {
+    remove: [...plan.remove],
+    removeFiles: plan.removeFiles,
+    skippedModified: plan.skippedModified,
+    pruneHookConfigs: mergeHookConfigPrunes(plan.pruneHookConfigs, plan.pruneHookCommands),
+    constraints: [...plan.constraints],
+    emptyDirs: [...plan.emptyDirs]
+  };
+}
+function mergeHookConfigPrunes(pruneHookConfigs, pruneHookCommands) {
+  const filePaths = /* @__PURE__ */ new Set([...pruneHookConfigs.keys(), ...pruneHookCommands.keys()]);
+  return [...filePaths].map((filePath) => ({
+    filePath,
+    managedHookPaths: [...pruneHookConfigs.get(filePath) ?? /* @__PURE__ */ new Set()],
+    managedHookCommands: [...pruneHookCommands.get(filePath) ?? /* @__PURE__ */ new Set()]
+  }));
+}
+function mergeClearPlan(target, source) {
+  target.remove = [.../* @__PURE__ */ new Set([...target.remove, ...source.remove])];
+  target.removeFiles = dedupeFileRemovals([...target.removeFiles, ...source.removeFiles]);
+  target.skippedModified = [.../* @__PURE__ */ new Set([...target.skippedModified, ...source.skippedModified])];
+  target.constraints = [.../* @__PURE__ */ new Set([...target.constraints, ...source.constraints])];
+  target.emptyDirs = [.../* @__PURE__ */ new Set([...target.emptyDirs, ...source.emptyDirs])];
+  for (const sourcePrune of source.pruneHookConfigs) {
+    const existing = target.pruneHookConfigs.find(
+      (prune) => prune.filePath === sourcePrune.filePath
+    );
+    if (!existing) {
+      target.pruneHookConfigs.push(sourcePrune);
+      continue;
+    }
+    existing.managedHookPaths = [
+      .../* @__PURE__ */ new Set([...existing.managedHookPaths, ...sourcePrune.managedHookPaths])
+    ];
+    existing.managedHookCommands = [
+      .../* @__PURE__ */ new Set([...existing.managedHookCommands, ...sourcePrune.managedHookCommands])
+    ];
+  }
+}
+function dedupeFileRemovals(removals) {
+  const byPath2 = /* @__PURE__ */ new Map();
+  for (const removal of removals) {
+    byPath2.set(removal.filePath, removal);
+  }
+  return [...byPath2.values()];
+}
+function addRuntimeClearEntries(plan, cwd) {
+  plan.remove = [
+    .../* @__PURE__ */ new Set([
+      ...plan.remove,
+      path14.join(cwd, EASY_CODING_DIR, CONFIG_FILE),
+      path14.join(cwd, EASY_CODING_DIR, SESSIONS_DIR),
+      path14.join(cwd, EASY_CODING_DIR, TEMPLATES_DIR),
+      path14.join(cwd, EASY_CODING_DIR, INSTALL_MANIFEST_FILE)
+    ])
+  ];
+}
+function addEmptyDirChain(emptyDirs, startDir, cwd) {
+  let current = startDir;
+  while (current !== cwd && isInsideDirectory(cwd, current)) {
+    emptyDirs.add(current);
+    const parent = path14.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+}
+function isInsideDirectory(parent, child) {
+  const relative = path14.relative(parent, child);
+  return Boolean(relative) && !relative.startsWith("..") && !path14.isAbsolute(relative);
+}
+async function listSharedHookNamesForPlatform(platform) {
+  const names = await listFileNames(getTemplatePath("shared-hooks"));
+  if (PLATFORM_META[platform].hasSubagentContext) {
+    return names;
+  }
+  return names.filter((name) => name !== "inject-subagent-context.py");
+}
+async function executeClearPlan(plan) {
+  for (const target of plan.removeFiles) {
+    if (await manifestFileMatches(target.filePath, target.expectedSha256)) {
+      await rm(target.filePath, { force: true });
+    }
+  }
+  for (const target of plan.remove) {
+    await rm(target, { recursive: true, force: true });
+  }
+  for (const config of plan.pruneHookConfigs) {
+    await pruneHookConfig(config);
+  }
+  for (const constraint of plan.constraints) {
+    await stripConstraintRegion(constraint);
+  }
+  for (const dir of sortDirsDeepestFirst(plan.emptyDirs)) {
+    await removeIfEmpty(dir);
+  }
+}
+async function pruneHookConfig(config) {
+  const { filePath, managedHookCommands, managedHookPaths } = config;
+  const content = await readTextIfExists(filePath);
+  if (content === null) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return;
+  }
+  const hooks = parsed.hooks;
+  if (hooks && typeof hooks === "object" && !Array.isArray(hooks)) {
+    const cleaned = pruneHookEvents(
+      hooks,
+      managedHookPaths,
+      managedHookCommands
+    );
+    if (cleaned === null) {
+      parsed = Object.fromEntries(Object.entries(parsed).filter(([key]) => key !== "hooks"));
+    } else {
+      parsed.hooks = cleaned;
+    }
+  }
+  if (Object.keys(parsed).length === 0) {
+    await rm(filePath, { force: true });
+    return;
+  }
+  await writeFile(filePath, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+}
+function pruneHookEvents(hooks, managedHookPaths, managedHookCommands) {
+  const result = {};
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) {
+      result[event] = value;
+      continue;
+    }
+    const keptGroups = value.map((group) => pruneHookGroup(group, managedHookPaths, managedHookCommands)).filter((group) => group !== null);
+    if (keptGroups.length > 0) {
+      result[event] = keptGroups;
+    }
+  }
+  return Object.keys(result).length === 0 ? null : result;
+}
+function pruneHookGroup(group, managedHookPaths, managedHookCommands) {
+  if (!group || typeof group !== "object") {
+    return group;
+  }
+  const entry = group;
+  if (!Array.isArray(entry.hooks)) {
+    return group;
+  }
+  const keptHooks = entry.hooks.filter(
+    (hook) => !isManagedHook(hook, managedHookPaths, managedHookCommands)
+  );
+  if (keptHooks.length === 0) {
+    return null;
+  }
+  return { ...group, hooks: keptHooks };
+}
+function isManagedHook(hook, managedHookPaths, managedHookCommands) {
+  if (!hook || typeof hook !== "object") {
+    return false;
+  }
+  const command = hook.command;
+  if (typeof command !== "string") {
+    return false;
+  }
+  const normalizedManagedCommands = managedHookCommands.map(normalizeCommand);
+  if (normalizedManagedCommands.includes(normalizeCommand(command))) {
+    return true;
+  }
+  const normalizedCommand = command.replace(/\\/g, "/");
+  return managedHookPaths.some(
+    (hookPath) => commandContainsPathToken(normalizedCommand, hookPath.replace(/\\/g, "/"))
+  );
+}
+function commandContainsPathToken(command, targetPath) {
+  const escaped = targetPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|\\s|["'])${escaped}($|\\s|["'])`).test(command);
+}
+async function stripConstraintRegion(filePath) {
+  const content = await readTextIfExists(filePath);
+  if (content === null) {
+    return;
+  }
+  const stripped = removeMarkedRegion(content);
+  if (stripped !== content) {
+    await writeFile(filePath, stripped, "utf8");
+  }
+}
+async function removeIfEmpty(dir) {
+  try {
+    const entries = await readdir4(dir);
+    if (entries.length === 0) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+function sortDirsDeepestFirst(dirs) {
+  return [...dirs].sort((left, right) => {
+    const depthDiff = pathDepth(right) - pathDepth(left);
+    return depthDiff === 0 ? left.localeCompare(right) : depthDiff;
+  });
+}
+function pathDepth(dir) {
+  return path14.normalize(dir).split(path14.sep).filter(Boolean).length;
+}
+async function listDirNames(dir) {
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+async function listFileNames(dir) {
+  try {
+    const entries = await readdir4(dir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function renderPlan(cwd, agents, plan) {
+  const rel = (target) => path14.relative(cwd, target) || target;
+  const lines = [];
+  lines.push(chalk3.bold("easy-coding clear"));
+  lines.push(`Platforms: ${agents.length > 0 ? agents.join(", ") : "(none detected)"}`);
+  lines.push("");
+  lines.push("Will remove:");
+  for (const target of plan.removeFiles) {
+    lines.push(`  - ${rel(target.filePath)}`);
+  }
+  for (const target of plan.remove) {
+    lines.push(`  - ${rel(target)}`);
+  }
+  if (plan.skippedModified.length > 0) {
+    lines.push("Will keep modified manifest files:");
+    for (const target of plan.skippedModified) {
+      lines.push(`  - ${rel(target)}`);
+    }
+  }
+  if (plan.constraints.length > 0) {
+    lines.push("Will strip the generated region from (file kept):");
+    for (const target of plan.constraints) {
+      lines.push(`  - ${rel(target)}`);
+    }
+  }
+  if (plan.pruneHookConfigs.length > 0) {
+    lines.push("Will prune harness hooks from (file kept if other config remains):");
+    for (const target of plan.pruneHookConfigs) {
+      lines.push(`  - ${rel(target.filePath)}`);
+    }
+  }
+  lines.push("");
+  lines.push(
+    chalk3.dim(
+      "Kept: .easy-coding/tasks, spec, memory, project.yaml, and knowledge files (SOUL/RULES/ABSTRACT/TEST_STRATEGY)."
+    )
+  );
+  return lines.join("\n");
+}
+
+// src/commands/init.ts
+import { note, outro as outro3 } from "@clack/prompts";
+import chalk4 from "chalk";
+
+// src/utils/install-state.ts
+import { readdir as readdir5 } from "fs/promises";
+import path15 from "path";
+var LEGACY_ROOT_FILES = ["SOUL.md", "RULES.md", "ABSTRACT.md"];
+async function detectEasyCodingInstallState(cwd) {
+  const easyCodingDir = path15.join(cwd, EASY_CODING_DIR);
+  if (!await pathExists(easyCodingDir)) {
+    return { kind: "fresh", easyCodingDir };
+  }
+  const configPath = path15.join(easyCodingDir, CONFIG_FILE);
+  if (await pathExists(configPath)) {
+    return { kind: "installed", easyCodingDir, configPath };
+  }
+  const legacyAssets = await detectLegacyAssets(easyCodingDir);
+  if (legacyAssets.length === 0) {
+    return { kind: "unknown", easyCodingDir };
+  }
+  return {
+    kind: "legacy",
+    easyCodingDir,
+    legacyAssets,
+    missingHarnessFiles: [relativeConfigPath(), relativeProjectInitTaskPath()]
+  };
+}
+async function detectLegacyAssets(easyCodingDir) {
+  const assets = [];
+  for (const file of LEGACY_ROOT_FILES) {
+    if (await pathExists(path15.join(easyCodingDir, file))) {
+      assets.push(relativeEasyCodingPath(file));
+    }
+  }
+  if (await pathExists(path15.join(easyCodingDir, "memory", "long", "MEMORY.md"))) {
+    assets.push(relativeEasyCodingPath("memory", "long", "MEMORY.md"));
+  }
+  const shortMemoryFiles = await listMarkdownFiles(path15.join(easyCodingDir, "memory", "short"));
+  assets.push(...shortMemoryFiles.map((file) => relativeEasyCodingPath("memory", "short", file)));
+  for (const dir of ["spec", "prototype"]) {
+    if (await hasAnyDirectoryEntry(path15.join(easyCodingDir, dir))) {
+      assets.push(relativeEasyCodingPath(dir));
+    }
+  }
+  return assets.sort();
+}
+async function listMarkdownFiles(dir) {
+  if (!await isDirectory(dir)) {
+    return [];
+  }
+  const entries = await readdir5(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;
+}
+function relativeEasyCodingPath(...segments) {
+  return path15.posix.join(EASY_CODING_DIR, ...segments);
+}
+function relativeConfigPath() {
+  return path15.posix.join(EASY_CODING_DIR, CONFIG_FILE);
+}
+function relativeProjectInitTaskPath() {
+  return path15.posix.join(EASY_CODING_DIR, TASKS_DIR, PROJECT_INIT_TASK_ID, "task.json");
+}
+
 // src/commands/init.ts
 async function init(opts) {
   renderBanner();
@@ -804,10 +1681,16 @@ async function init(opts) {
     );
   }
   const platforms = await resolvePlatforms(opts, ["claude-code"]);
+  const artifacts = [];
   for (const platform of platforms) {
-    await CONFIGURATORS[platform](cwd);
+    artifacts.push(...await CONFIGURATORS[platform](cwd));
   }
   await writeRuntimeScaffold(cwd, platforms);
+  await writeInstallManifest(cwd, {
+    harnessVersion: VERSION,
+    agents: platforms,
+    artifacts
+  });
   await writeProjectInitTask(cwd, platforms, {
     initSource: installState.kind === "legacy" ? "legacy-easy-coding" : "fresh",
     legacyAssets: installState.kind === "legacy" ? installState.legacyAssets : void 0,
@@ -818,17 +1701,17 @@ async function init(opts) {
     (platform) => `${PLATFORM_META[platform].label}: ${PLATFORM_META[platform].skillTrigger}ec-init`
   ).join("\n");
   note(triggers, "Next step");
-  outro2(chalk3.green("easy-coding harness installed. Open your agent and run ec-init."));
+  outro3(chalk4.green("easy-coding harness installed. Open your agent and run ec-init."));
 }
 
 // src/commands/status.ts
-import path15 from "path";
-import chalk4 from "chalk";
+import path18 from "path";
+import chalk5 from "chalk";
 
 // src/utils/compare-versions.ts
-import path13 from "path";
+import path16 from "path";
 function normalize(version) {
-  const [core] = version.split("-");
+  const [core] = String(version ?? "").split("-");
   return core.split(".").map((part) => {
     const parsed = Number.parseInt(part, 10);
     return Number.isNaN(parsed) ? 0 : parsed;
@@ -850,11 +1733,16 @@ function isVersionBehind(installed, current = VERSION) {
   return compareVersions(installed, current) === -1;
 }
 async function checkForUpgrade(cwd) {
-  const configPath = path13.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  const configPath = path16.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
   if (!await pathExists(configPath)) {
     return;
   }
-  const config = await readConfigYaml(configPath);
+  let config;
+  try {
+    config = await readConfigYaml(configPath);
+  } catch {
+    return;
+  }
   const installed = String(config.harness_version ?? "");
   if (installed && isVersionBehind(installed)) {
     process.stderr.write(
@@ -865,15 +1753,15 @@ async function checkForUpgrade(cwd) {
 }
 
 // src/utils/session.ts
-import { readdir as readdir4 } from "fs/promises";
-import path14 from "path";
+import { readdir as readdir6 } from "fs/promises";
+import path17 from "path";
 var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 function getSessionDir(cwd) {
-  return path14.join(cwd, EASY_CODING_DIR, SESSIONS_DIR);
+  return path17.join(cwd, EASY_CODING_DIR, SESSIONS_DIR);
 }
 function getSessionFilePath(cwd, ppid) {
   const pid = ppid ?? process.ppid;
-  return path14.join(getSessionDir(cwd), `${pid}.json`);
+  return path17.join(getSessionDir(cwd), `${pid}.json`);
 }
 async function readSessionFile(cwd, ppid) {
   const content = await readTextIfExists(getSessionFilePath(cwd, ppid));
@@ -887,7 +1775,7 @@ async function readSessionFile(cwd, ppid) {
 async function status() {
   renderBanner();
   const cwd = process.cwd();
-  const configPath = path15.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  const configPath = path18.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
   if (!await pathExists(configPath)) {
     throw new Error("No easy-coding harness found in this project.");
   }
@@ -897,20 +1785,20 @@ async function status() {
   const activeTasks = tasks.filter((item) => isActiveTask(item.task));
   const session = await readSessionFile(cwd);
   const versionRelation = compareVersions(config.harness_version, VERSION);
-  console.log(chalk4.bold("Harness"));
+  console.log(chalk5.bold("Harness"));
   console.log(`  version: ${config.harness_version}`);
   console.log(`  cli: ${VERSION}`);
   if (versionRelation === -1) {
-    console.log(chalk4.yellow("  upgrade: available"));
+    console.log(chalk5.yellow("  upgrade: available"));
   } else if (versionRelation === 1) {
-    console.log(chalk4.red("  upgrade: CLI is older than project harness"));
+    console.log(chalk5.red("  upgrade: CLI is older than project harness"));
   } else {
     console.log("  upgrade: up to date");
   }
   console.log(`  agents: ${config.agents.join(", ") || "(none)"}`);
-  console.log(`  project: ${config.project.name} (${config.project.mode})`);
+  console.log(`  project: ${config.project.name}`);
   console.log("");
-  console.log(chalk4.bold("Session"));
+  console.log(chalk5.bold("Session"));
   if (session?.current_task) {
     const taskPath = getTaskJsonPath(cwd, session.current_task);
     if (await pathExists(taskPath)) {
@@ -925,7 +1813,7 @@ async function status() {
     console.log("  no active session");
   }
   console.log("");
-  console.log(chalk4.bold("Tasks"));
+  console.log(chalk5.bold("Tasks"));
   console.log(`  total: ${tasks.length}`);
   for (const [taskStatus, count] of Object.entries(taskCounts)) {
     console.log(`  ${taskStatus}: ${count}`);
@@ -940,53 +1828,69 @@ async function status() {
 }
 
 // src/commands/upgrade.ts
-import path16 from "path";
-import { cancel as cancel2, confirm as confirm2, outro as outro3 } from "@clack/prompts";
-import chalk5 from "chalk";
+import path19 from "path";
+import { cancel as cancel3, confirm as confirm3, outro as outro4 } from "@clack/prompts";
+import chalk6 from "chalk";
 async function upgrade(opts) {
   renderBanner();
   const cwd = process.cwd();
-  const configPath = path16.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
+  const configPath = path19.join(cwd, EASY_CODING_DIR, CONFIG_FILE);
   if (!await pathExists(configPath)) {
     throw new Error("No .easy-coding/config.yaml found. Run easy-coding init first.");
   }
   const config = await readConfigYaml(configPath);
-  const relation = compareVersions(config.harness_version, VERSION);
+  const installedVersion = String(config.harness_version ?? "");
+  const hasAgents = Array.isArray(config.agents) && config.agents.length > 0;
+  if (!installedVersion || !hasAgents) {
+    throw new Error(
+      "config.yaml is missing required harness fields (harness_version / agents). This project predates the current config layout. Run `easy-coding clear` then `easy-coding init` to migrate \u2014 your tasks, spec, and memory are preserved."
+    );
+  }
+  const relation = compareVersions(installedVersion, VERSION);
   if (relation === 0) {
-    outro3(chalk5.green(`easy-coding harness is already up to date (${VERSION}).`));
+    outro4(chalk6.green(`easy-coding harness is already up to date (${VERSION}).`));
     return;
   }
   if (relation === 1) {
     throw new Error(
-      `Project harness version ${config.harness_version} is newer than CLI ${VERSION}. Update the CLI first.`
+      `Project harness version ${installedVersion} is newer than CLI ${VERSION}. Update the CLI first.`
     );
   }
   const summary = [
-    `Upgrade: ${config.harness_version} -> ${VERSION}`,
+    `Upgrade: ${installedVersion || "unknown"} -> ${VERSION}`,
     `Installed agents: ${config.agents.join(", ")}`,
-    "Will overwrite managed skills, hooks, agents, and generated main-constraint regions.",
-    "Will not touch tasks, memory, state, spec, or project knowledge files."
+    "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 not touch memory, state, spec, or project knowledge files."
   ].join("\n");
   if (opts.dryRun) {
     console.log(summary);
     return;
   }
   if (!opts.yes) {
-    const shouldUpgrade = await confirm2({
+    const shouldUpgrade = await confirm3({
       message: "Apply this harness upgrade?",
       initialValue: true
     });
     if (typeof shouldUpgrade === "symbol" || !shouldUpgrade) {
-      cancel2("Upgrade cancelled.");
+      cancel3("Upgrade cancelled.");
       return;
     }
   }
+  const artifacts = [];
   for (const platform of config.agents) {
-    await CONFIGURATORS[platform](cwd);
+    artifacts.push(...await CONFIGURATORS[platform](cwd));
   }
+  await writeRuntimeScaffold(cwd, config.agents);
+  await writeInstallManifest(cwd, {
+    harnessVersion: VERSION,
+    agents: config.agents,
+    artifacts
+  });
   await ensureEasyCodingSessionsIgnored(cwd);
   await updateHarnessVersion(configPath, VERSION);
-  outro3(chalk5.green(`easy-coding harness upgraded to ${VERSION}.`));
+  await setPendingInitSince(cwd, VERSION);
+  outro4(chalk6.green(`easy-coding harness upgraded to ${VERSION}.`));
 }
 
 // src/cli.ts
@@ -995,7 +1899,7 @@ function withErrorHandling(fn) {
     try {
       await fn(opts);
     } catch (error) {
-      console.error(chalk6.red("Error:"), error instanceof Error ? error.message : error);
+      console.error(chalk7.red("Error:"), error instanceof Error ? error.message : error);
       if (process.env.EC_DEBUG && error instanceof Error) {
         console.error(error.stack);
       }
@@ -1010,5 +1914,6 @@ program.command("init").description("Initialize easy-coding harness in current p
 program.command("add-agent").description("Add agent platform support to an existing project").option("--agent <list>", "Comma-separated platforms to add").action(withErrorHandling(addAgent));
 program.command("upgrade").description("Upgrade harness files to current CLI version").option("--dry-run", "Preview changes without applying").option("-y, --yes", "Skip confirmation").action(withErrorHandling(upgrade));
 program.command("status").description("Show installed agents, version, and tasks").action(withErrorHandling(status));
+program.command("clear").description("Remove installed harness files (skills, hooks, config); keep tasks, spec, memory").option("--dry-run", "Preview what would be removed without deleting").option("-y, --yes", "Skip confirmation").action(withErrorHandling(clear));
 program.parse();
 //# sourceMappingURL=cli.js.map