engly 1.2.0 → 1.4.1

package/dist/cli.js

@@ -13,131 +13,10 @@ async function configCommand(_option, _value) {
   notImplemented("config");
 }
 
-// src/commands/disable.ts
-async function disableCommand() {
-  notImplemented("disable");
-}
-
-// src/commands/enable.ts
-async function enableCommand() {
-  notImplemented("enable");
-}
-
-// src/commands/init.ts
-import { join as join5 } from "path";
+// src/commands/set-enabled.ts
+import { join as join7 } from "path";
 import * as p from "@clack/prompts";
 
-// src/adapters/detect.ts
-import { access } from "fs/promises";
-import { dirname, join } from "path";
-async function anyExists(cwd, paths) {
-  for (const path of paths) {
-    try {
-      await access(join(cwd, path));
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function anyExistsUpward(cwd, paths) {
-  let dir = cwd;
-  while (true) {
-    if (await anyExists(dir, paths)) return true;
-    const parent = dirname(dir);
-    if (parent === dir) return false;
-    dir = parent;
-  }
-}
-
-// src/adapters/claude.ts
-var claude = {
-  id: "claude",
-  name: "Claude Code",
-  delivery: "import",
-  detect: (cwd) => anyExists(cwd, ["CLAUDE.md", ".claude"]),
-  // Claude Code reads AGENTS.md only when there is no CLAUDE.md, .claude/CLAUDE.md or
-  // CLAUDE.local.md in the working directory or any directory above it.
-  instructionFile: async (cwd) => {
-    if (await anyExistsUpward(cwd, ["CLAUDE.md", ".claude/CLAUDE.md", "CLAUDE.local.md"])) return "CLAUDE.md";
-    return await anyExists(cwd, ["AGENTS.md"]) ? "AGENTS.md" : "CLAUDE.md";
-  },
-  skillDirs: [".claude/skills"],
-  sizeLimit: {
-    maxLines: 200,
-    warning: "Claude Code follows long instruction files less closely."
-  }
-};
-
-// src/adapters/codex.ts
-var codex = {
-  id: "codex",
-  name: "Codex",
-  delivery: "embedded",
-  detect: (cwd) => anyExists(cwd, [".codex", "AGENTS.md"]),
-  instructionFile: () => "AGENTS.md",
-  skillDirs: [".agents/skills"],
-  sizeLimit: {
-    // Real limit is 32 KiB for all AGENTS.md files combined (spec §9.6).
-    maxBytes: 24 * 1024,
-    warning: "Codex may stop reading long instruction files.\nThe Engly block could be cut off."
-  }
-};
-
-// src/adapters/copilot.ts
-var copilot = {
-  id: "copilot",
-  name: "GitHub Copilot",
-  delivery: "embedded",
-  detect: (cwd) => anyExists(cwd, [".github/copilot-instructions.md", ".github/instructions"]),
-  instructionFile: () => ".github/copilot-instructions.md",
-  skillDirs: [".agents/skills", ".claude/skills", ".github/skills"]
-};
-
-// src/adapters/cursor.ts
-var cursor = {
-  id: "cursor",
-  name: "Cursor",
-  delivery: "own-file",
-  detect: (cwd) => anyExists(cwd, [".cursor", ".cursorrules"]),
-  instructionFile: () => ".cursor/rules/engly.mdc",
-  skillDirs: [".agents/skills", ".cursor/skills", ".claude/skills"]
-};
-
-// src/adapters/opencode.ts
-var opencode = {
-  id: "opencode",
-  name: "OpenCode",
-  delivery: "embedded",
-  detect: (cwd) => anyExists(cwd, ["opencode.json", "opencode.jsonc", ".opencode"]),
-  instructionFile: () => "AGENTS.md",
-  skillDirs: [".agents/skills", ".claude/skills", ".opencode/skills"]
-};
-
-// src/adapters/types.ts
-var TOOL_IDS = ["claude", "codex", "opencode", "cursor", "copilot"];
-
-// src/adapters/index.ts
-var adapters = { claude, codex, opencode, cursor, copilot };
-var IMPLEMENTED_TOOLS = ["claude"];
-function skillTargets(tools) {
-  const chosen = [];
-  const byChoices = [...tools].sort((a, b) => adapters[a].skillDirs.length - adapters[b].skillDirs.length);
-  for (const tool of byChoices) {
-    const dirs = adapters[tool].skillDirs;
-    const [preferred] = dirs;
-    if (preferred && !dirs.some((dir) => chosen.includes(dir))) chosen.push(preferred);
-  }
-  return chosen;
-}
-async function detectTools(cwd) {
-  const found = [];
-  for (const adapter of Object.values(adapters)) {
-    if (await adapter.detect(cwd)) found.push(adapter.id);
-  }
-  return found;
-}
-
 // src/core/block.ts
 var START_MARKER_PREFIX = "<!-- engly:start";
 var END_MARKER = "<!-- engly:end -->";
@@ -176,6 +55,13 @@ function findBlock(text) {
 function hasBlock(text) {
   return findBlock(text) !== null;
 }
+function readBlock(text) {
+  const range = findBlock(text);
+  if (!range) return null;
+  const inner = text.slice(range.start, range.end);
+  const afterStart = inner.indexOf("-->") + 3;
+  return stripOneEol(inner.slice(afterStart, inner.length - END_MARKER.length), "both");
+}
 function buildBlock(content, version, eol = "\n") {
   const body = content.replace(/\r\n/g, "\n").replace(/\n+$/, "");
   const lines = [startMarker(version), ...body === "" ? [] : body.split("\n"), END_MARKER];
@@ -197,9 +83,33 @@ function upsertBlock(text, content, options) {
   const separator = endsWithEol(text) ? eol : eol + eol;
   return { text: text + separator + block + eol, action: "appended" };
 }
+function removeBlock(text) {
+  const range = findBlock(text);
+  if (!range) return { text, removed: false };
+  let before = text.slice(0, range.start);
+  let after = stripOneEol(text.slice(range.end), "start");
+  if (before === "") {
+    after = stripOneEol(after, "start");
+  } else if (/(\r?\n)\r?\n$/.test(before)) {
+    before = stripOneEol(before, "end");
+  }
+  return { text: before + after, removed: true };
+}
 function endsWithEol(text) {
   return text.endsWith("\n");
 }
+function stripOneEol(text, side) {
+  let result = text;
+  if (side === "start" || side === "both") {
+    if (result.startsWith("\r\n")) result = result.slice(2);
+    else if (result.startsWith("\n")) result = result.slice(1);
+  }
+  if (side === "end" || side === "both") {
+    if (result.endsWith("\r\n")) result = result.slice(0, -2);
+    else if (result.endsWith("\n")) result = result.slice(0, -1);
+  }
+  return result;
+}
 function indexesOf(text, search) {
   const result = [];
   let index = text.indexOf(search);
@@ -212,18 +122,18 @@ function indexesOf(text, search) {
 
 // src/core/config.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 
 // src/core/paths.ts
 import { existsSync, readFileSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 var cachedRoot;
 function packageRoot() {
   if (cachedRoot) return cachedRoot;
-  let dir = dirname2(fileURLToPath(import.meta.url));
+  let dir = dirname(fileURLToPath(import.meta.url));
   while (true) {
-    const pkgPath = join2(dir, "package.json");
+    const pkgPath = join(dir, "package.json");
     if (existsSync(pkgPath)) {
       const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
       if (pkg.name === "engly") {
@@ -231,17 +141,23 @@ function packageRoot() {
         return dir;
       }
     }
-    const parent = dirname2(dir);
+    const parent = dirname(dir);
     if (parent === dir) throw new Error("Could not locate the engly package root.");
     dir = parent;
   }
 }
 function templatesDir() {
-  return join2(packageRoot(), "templates");
+  return join(packageRoot(), "templates");
+}
+var cachedInfo;
+function packageInfo() {
+  if (cachedInfo) return cachedInfo;
+  const pkg = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf8"));
+  cachedInfo = { name: pkg.name, version: pkg.version };
+  return cachedInfo;
 }
 function packageVersion() {
-  const pkg = JSON.parse(readFileSync(join2(packageRoot(), "package.json"), "utf8"));
-  return pkg.version;
+  return packageInfo().version;
 }
 var ENGLY_DIR = ".engly";
 var CONFIG_FILE = `${ENGLY_DIR}/config.json`;
@@ -268,7 +184,7 @@ var ConfigError = class extends Error {
   }
 };
 function configPath(cwd) {
-  return join3(cwd, CONFIG_FILE);
+  return join2(cwd, CONFIG_FILE);
 }
 async function readConfig(cwd, version) {
   let raw;
@@ -291,7 +207,7 @@ async function readConfig(cwd, version) {
 }
 async function writeConfig(cwd, config) {
   const path = configPath(cwd);
-  await mkdir(dirname3(path), { recursive: true });
+  await mkdir(dirname2(path), { recursive: true });
   await writeFile(path, `${JSON.stringify(validateConfig(config), null, 2)}
 `, "utf8");
 }
@@ -315,8 +231,8 @@ function validateConfig(config) {
 }
 
 // src/core/fs.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+import { access, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3 } from "path";
 async function readTextIfExists(path) {
   try {
     return await readFile2(path, "utf8");
@@ -326,22 +242,132 @@ async function readTextIfExists(path) {
   }
 }
 async function writeText(path, content) {
-  await mkdir2(dirname4(path), { recursive: true });
+  await mkdir2(dirname3(path), { recursive: true });
   await writeFile2(path, content, "utf8");
 }
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-// src/core/git.ts
-import { spawnSync } from "child_process";
-function git(cwd, args) {
-  const result = spawnSync("git", args, { cwd, stdio: "ignore" });
-  if (result.error) return null;
-  return result.status;
+// src/core/install.ts
+import { rm, rmdir } from "fs/promises";
+import { dirname as dirname5, join as join5 } from "path";
+
+// src/adapters/detect.ts
+import { access as access2 } from "fs/promises";
+import { dirname as dirname4, join as join3 } from "path";
+async function anyExists(cwd, paths) {
+  for (const path of paths) {
+    try {
+      await access2(join3(cwd, path));
+      return true;
+    } catch {
+    }
+  }
+  return false;
 }
-function gitStatus(cwd, relativePath) {
-  if (git(cwd, ["rev-parse", "--is-inside-work-tree"]) !== 0) return "no-git";
-  if (git(cwd, ["ls-files", "--error-unmatch", "--", relativePath]) === 0) return "tracked";
-  if (git(cwd, ["check-ignore", "-q", "--", relativePath]) === 0) return "ignored";
-  return "untracked";
+async function anyExistsUpward(cwd, paths) {
+  let dir = cwd;
+  while (true) {
+    if (await anyExists(dir, paths)) return true;
+    const parent = dirname4(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+
+// src/adapters/claude.ts
+var claude = {
+  id: "claude",
+  name: "Claude Code",
+  delivery: "import",
+  detect: (cwd) => anyExists(cwd, ["CLAUDE.md", ".claude"]),
+  // Claude Code reads AGENTS.md only when there is no CLAUDE.md, .claude/CLAUDE.md or
+  // CLAUDE.local.md in the working directory or any directory above it.
+  instructionFile: async (cwd) => {
+    if (await anyExistsUpward(cwd, ["CLAUDE.md", ".claude/CLAUDE.md", "CLAUDE.local.md"])) return "CLAUDE.md";
+    return await anyExists(cwd, ["AGENTS.md"]) ? "AGENTS.md" : "CLAUDE.md";
+  },
+  instructionFiles: ["CLAUDE.md", "AGENTS.md"],
+  skillDirs: [".claude/skills"],
+  sizeLimit: {
+    maxLines: 200,
+    warning: "Claude Code follows long instruction files less closely."
+  }
+};
+
+// src/adapters/codex.ts
+var codex = {
+  id: "codex",
+  name: "Codex",
+  delivery: "embedded",
+  detect: (cwd) => anyExists(cwd, [".codex", "AGENTS.md"]),
+  instructionFile: () => "AGENTS.md",
+  skillDirs: [".agents/skills"],
+  sizeLimit: {
+    // Real limit is 32 KiB for all AGENTS.md files combined (spec §9.6).
+    maxBytes: 24 * 1024,
+    warning: "Codex may stop reading long instruction files.\nThe Engly block could be cut off."
+  }
+};
+
+// src/adapters/copilot.ts
+var copilot = {
+  id: "copilot",
+  name: "GitHub Copilot",
+  delivery: "embedded",
+  detect: (cwd) => anyExists(cwd, [".github/copilot-instructions.md", ".github/instructions"]),
+  instructionFile: () => ".github/copilot-instructions.md",
+  skillDirs: [".agents/skills", ".claude/skills", ".github/skills"]
+};
+
+// src/adapters/cursor.ts
+var cursor = {
+  id: "cursor",
+  name: "Cursor",
+  delivery: "own-file",
+  detect: (cwd) => anyExists(cwd, [".cursor", ".cursorrules"]),
+  instructionFile: () => ".cursor/rules/engly.mdc",
+  skillDirs: [".agents/skills", ".cursor/skills", ".claude/skills"]
+};
+
+// src/adapters/opencode.ts
+var opencode = {
+  id: "opencode",
+  name: "OpenCode",
+  delivery: "embedded",
+  detect: (cwd) => anyExists(cwd, ["opencode.json", "opencode.jsonc", ".opencode"]),
+  instructionFile: () => "AGENTS.md",
+  skillDirs: [".agents/skills", ".claude/skills", ".opencode/skills"]
+};
+
+// src/adapters/types.ts
+var TOOL_IDS = ["claude", "codex", "opencode", "cursor", "copilot"];
+
+// src/adapters/index.ts
+var adapters = { claude, codex, opencode, cursor, copilot };
+var IMPLEMENTED_TOOLS = ["claude"];
+function skillTargets(tools) {
+  const chosen = [];
+  const byChoices = [...tools].sort((a, b) => adapters[a].skillDirs.length - adapters[b].skillDirs.length);
+  for (const tool of byChoices) {
+    const dirs = adapters[tool].skillDirs;
+    const [preferred] = dirs;
+    if (preferred && !dirs.some((dir) => chosen.includes(dir))) chosen.push(preferred);
+  }
+  return chosen;
+}
+async function detectTools(cwd) {
+  const found = [];
+  for (const adapter of Object.values(adapters)) {
+    if (await adapter.detect(cwd)) found.push(adapter.id);
+  }
+  return found;
 }
 
 // src/core/instructions.ts
@@ -363,6 +389,179 @@ async function readSkill(name) {
   return readFile3(join4(templatesDir(), "skills", name, "SKILL.md"), "utf8");
 }
 
+// src/core/install.ts
+async function writeInstructions(cwd, config) {
+  await writeText(join5(cwd, INSTRUCTIONS_FILE), await renderInstructions(config));
+}
+async function installSkills(cwd, tools) {
+  for (const dir of skillTargets(tools)) {
+    for (const skill of SKILL_NAMES) {
+      await writeText(join5(cwd, dir, skill, "SKILL.md"), await readSkill(skill));
+    }
+  }
+}
+async function skillStatus(cwd, tools) {
+  const folders = [];
+  for (const dir of skillTargets(tools)) {
+    const missing = [];
+    for (const skill of SKILL_NAMES) {
+      if (!await pathExists(join5(cwd, dir, skill, "SKILL.md"))) missing.push(skill);
+    }
+    folders.push({ dir, missing });
+  }
+  return folders;
+}
+async function removeSkills(cwd) {
+  const dirs = new Set(Object.values(adapters).flatMap((adapter) => adapter.skillDirs));
+  const removed = [];
+  for (const dir of dirs) {
+    let removedHere = false;
+    for (const skill of SKILL_NAMES) {
+      const path = join5(cwd, dir, skill);
+      if (!await pathExists(path)) continue;
+      await rm(path, { recursive: true, force: true });
+      removed.push(join5(dir, skill));
+      removedHere = true;
+    }
+    if (removedHere) await removeEmptyDirs(cwd, dir);
+  }
+  return removed;
+}
+async function hasInstalledSkills(cwd) {
+  const dirs = new Set(Object.values(adapters).flatMap((adapter) => adapter.skillDirs));
+  for (const dir of dirs) {
+    for (const skill of SKILL_NAMES) {
+      if (await pathExists(join5(cwd, dir, skill))) return true;
+    }
+  }
+  return false;
+}
+async function removeEmptyDirs(cwd, relativeDir) {
+  let dir = relativeDir;
+  for (let level = 0; level < 2 && dir !== "."; level++) {
+    try {
+      await rmdir(join5(cwd, dir));
+    } catch {
+      return;
+    }
+    dir = dirname5(dir);
+  }
+}
+
+// src/core/project.ts
+import { join as join6 } from "path";
+function blockContent(enabled) {
+  return enabled ? `@${INSTRUCTIONS_FILE}` : "";
+}
+async function inspectAgentFile(cwd, file) {
+  const path = join6(cwd, file);
+  const text = await readTextIfExists(path);
+  if (text === null) return { file, path, text: "", state: "missing" };
+  try {
+    const content = readBlock(text);
+    if (content === null) return { file, path, text, state: "no-block" };
+    return { file, path, text, state: content.trim() === "" ? "inactive" : "active" };
+  } catch (error) {
+    if (error instanceof BlockError) return { file, path, text, state: "broken", error: error.message };
+    throw error;
+  }
+}
+async function candidateFiles(cwd, tools) {
+  const files = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    if (!IMPLEMENTED_TOOLS.includes(tool)) continue;
+    const adapter = adapters[tool];
+    for (const file of adapter.instructionFiles ?? [await adapter.instructionFile(cwd)]) files.add(file);
+  }
+  return [...files];
+}
+async function inspectAgentFiles(cwd, tools) {
+  const files = [];
+  for (const file of await candidateFiles(cwd, tools)) {
+    const inspected = await inspectAgentFile(cwd, file);
+    if (inspected.state !== "missing") files.push(inspected);
+  }
+  return files;
+}
+async function findBlocks(cwd, tools) {
+  const files = await inspectAgentFiles(cwd, tools);
+  for (const file of files) {
+    if (file.state === "broken") throw new BlockError(`${file.file}: ${file.error}`);
+  }
+  return files.filter((file) => file.state === "active" || file.state === "inactive");
+}
+async function requireConfig(cwd, version) {
+  const config = await readConfig(cwd, version);
+  if (!config) throw new Error('Engly is not installed here. Run "engly init" first.');
+  return config;
+}
+function configuredTools(config) {
+  const tools = config?.tools.filter((tool) => IMPLEMENTED_TOOLS.includes(tool)) ?? [];
+  return tools.length > 0 ? tools : [...IMPLEMENTED_TOOLS];
+}
+
+// src/commands/set-enabled.ts
+async function setEnabled(cwd, enabled) {
+  const version = packageVersion();
+  const word = enabled ? "enabled" : "disabled";
+  p.intro(`Engly  v${version}`);
+  const config = await requireConfig(cwd, version);
+  const tools = configuredTools(config);
+  const blocks = await findBlocks(cwd, tools);
+  if (blocks.length === 0) {
+    const files = (await candidateFiles(cwd, tools)).join(" or ");
+    p.log.warn(`No Engly block found in ${files}. Run "engly init" to add it.`);
+    p.outro("Nothing changed.");
+    process.exitCode = 1;
+    return;
+  }
+  const pending = blocks.filter((block) => block.state === "active" !== enabled);
+  if (pending.length === 0 && config.enabled === enabled) {
+    p.outro(`Engly is already ${word}.`);
+    return;
+  }
+  for (const block of pending) {
+    const { text } = upsertBlock(block.text, blockContent(enabled), { version: config.version });
+    await writeText(block.path, text);
+  }
+  if (enabled && !await pathExists(join7(cwd, INSTRUCTIONS_FILE))) {
+    await writeInstructions(cwd, config);
+  }
+  config.enabled = enabled;
+  await writeConfig(cwd, config);
+  const where = pending.length > 0 ? ` in ${pending.map((block) => block.file).join(" and ")}` : "";
+  p.log.success(`\u2713 Engly ${word}${where}`);
+  p.outro("Takes effect in your next agent session.");
+}
+
+// src/commands/disable.ts
+async function disableCommand() {
+  await setEnabled(process.cwd(), false);
+}
+
+// src/commands/enable.ts
+async function enableCommand() {
+  await setEnabled(process.cwd(), true);
+}
+
+// src/commands/init.ts
+import { join as join8 } from "path";
+import * as p2 from "@clack/prompts";
+
+// src/core/git.ts
+import { spawnSync } from "child_process";
+function git(cwd, args) {
+  const result = spawnSync("git", args, { cwd, stdio: "ignore" });
+  if (result.error) return null;
+  return result.status;
+}
+function gitStatus(cwd, relativePath) {
+  if (git(cwd, ["rev-parse", "--is-inside-work-tree"]) !== 0) return "no-git";
+  if (git(cwd, ["ls-files", "--error-unmatch", "--", relativePath]) === 0) return "tracked";
+  if (git(cwd, ["check-ignore", "-q", "--", relativePath]) === 0) return "ignored";
+  return "untracked";
+}
+
 // src/core/size.ts
 function checkSize(text, limit) {
   if (!limit) return null;
@@ -381,7 +580,7 @@ function checkSize(text, limit) {
 var CancelledError = class extends Error {
 };
 function guard(value) {
-  if (p.isCancel(value)) throw new CancelledError();
+  if (p2.isCancel(value)) throw new CancelledError();
   return value;
 }
 async function initCommand(options) {
@@ -389,21 +588,20 @@ async function initCommand(options) {
     await runInit(options);
   } catch (error) {
     if (error instanceof CancelledError) {
-      p.cancel("Cancelled. Nothing was changed.");
+      p2.cancel("Cancelled. Nothing was changed.");
       process.exitCode = 1;
       return;
     }
     throw error;
   }
 }
-async function runInit(options) {
-  const cwd = process.cwd();
+async function runInit(options, cwd = process.cwd()) {
   const version = packageVersion();
   const interactive = !options.yes;
   if (interactive && !process.stdin.isTTY) {
     throw new Error('No interactive terminal detected. Run "engly init --yes" to use the defaults.');
   }
-  p.intro(`Engly  v${version} \u2013 your English coach for AI prompts`);
+  p2.intro(`Engly  v${version} \u2013 your English coach for AI prompts`);
   const config = await readConfig(cwd, version) ?? defaultConfig(version);
   config.version = version;
   const tools = await chooseTools(cwd, options);
@@ -413,9 +611,9 @@ async function runInit(options) {
   config.style = await chooseStyle(options, config.style);
   const adapter = adapters.claude;
   const agentFile = await adapter.instructionFile(cwd);
-  const agentPath = join5(cwd, agentFile);
+  const agentPath = join8(cwd, agentFile);
   if (agentFile === "AGENTS.md") {
-    p.log.info("No CLAUDE.md found. Using AGENTS.md, which Claude Code reads when there is no CLAUDE.md.");
+    p2.log.info("No CLAUDE.md found. Using AGENTS.md, which Claude Code reads when there is no CLAUDE.md.");
   }
   const current = await readTextIfExists(agentPath);
   const blockExists = current !== null && hasBlock(current);
@@ -426,10 +624,10 @@ async function runInit(options) {
     if (placement === "skip") apply = false;
     else position = placement;
   }
-  const planned = upsertBlock(current ?? "", `@${INSTRUCTIONS_FILE}`, { version, position });
+  const planned = upsertBlock(current ?? "", blockContent(true), { version, position });
   if (apply && interactive) {
     const choice = guard(
-      await p.select({
+      await p2.select({
         message: `Add Engly block to:
 ${agentFile}  (${adapter.name})  \u2192 ${describePlan(current, planned.action)}`,
         options: [
@@ -444,22 +642,18 @@ ${agentFile}  (${adapter.name})  \u2192 ${describePlan(current, planned.action)}
     await warnIfInGit(cwd, agentFile, interactive);
   }
   const done = [];
-  await writeText(join5(cwd, INSTRUCTIONS_FILE), await renderInstructions(config));
+  await writeInstructions(cwd, config);
   if (apply) {
     await writeText(agentPath, planned.text);
     done.push(`\u2713 ${agentFile} ${current === null ? "created" : "updated"}`);
   }
-  for (const dir of skillTargets(tools)) {
-    for (const skill of SKILL_NAMES) {
-      await writeText(join5(cwd, dir, skill, "SKILL.md"), await readSkill(skill));
-    }
-  }
+  await installSkills(cwd, tools);
   done.push(`\u2713 Skills installed: ${SKILL_NAMES.join(", ")}`);
   config.tools = tools;
   config.enabled = true;
   await writeConfig(cwd, config);
-  p.log.success(done.join("\n"));
-  p.outro(
+  p2.log.success(done.join("\n"));
+  p2.outro(
     apply ? "Done! Your next prompt will be coached." : `Skills installed. Run "engly init" again to add the Engly block to ${agentFile}.`
   );
 }
@@ -477,7 +671,7 @@ async function chooseTools(cwd, options) {
   const defaults = initial.length > 0 ? initial : [...IMPLEMENTED_TOOLS];
   if (options.yes) return defaults;
   return guard(
-    await p.multiselect({
+    await p2.multiselect({
       message: "Which AI tools do you use?",
       options: TOOL_IDS.map((id) => ({
         value: id,
@@ -493,7 +687,7 @@ async function chooseTools(cwd, options) {
 function keepImplemented(tools) {
   const skipped = tools.filter((tool) => !IMPLEMENTED_TOOLS.includes(tool));
   if (skipped.length > 0) {
-    p.log.warn(`Not supported yet, skipped: ${skipped.map((tool) => adapters[tool].name).join(", ")}`);
+    p2.log.warn(`Not supported yet, skipped: ${skipped.map((tool) => adapters[tool].name).join(", ")}`);
   }
   return tools.filter((tool) => IMPLEMENTED_TOOLS.includes(tool));
 }
@@ -506,7 +700,7 @@ async function chooseStyle(options, current) {
   }
   if (options.yes) return current;
   return guard(
-    await p.select({
+    await p2.select({
       message: "How detailed should the feedback be?",
       initialValue: current,
       options: [
@@ -526,13 +720,13 @@ async function choosePlacement(file, size, interactive) {
   const message = `${file} is ${size.label}
 \u26A0 ${size.warning}`;
   if (!interactive) {
-    p.log.warn(`${message}
+    p2.log.warn(`${message}
 The Engly block goes near the top.`);
     return "top";
   }
-  p.log.warn(message);
+  p2.log.warn(message);
   return guard(
-    await p.select({
+    await p2.select({
       message: "Where should the block go?",
       options: [
         { value: "top", label: "Near the top \u2013 recommended" },
@@ -548,12 +742,12 @@ async function warnIfInGit(cwd, file, interactive) {
   const title = status === "tracked" ? `${file} is tracked by git.` : `${file} is not ignored by git.`;
   const warning = "\u26A0 Your teammates will also be coached if you commit it.";
   if (!interactive) {
-    p.log.warn(`${title}
+    p2.log.warn(`${title}
 ${warning}`);
     return;
   }
   const choice = guard(
-    await p.select({
+    await p2.select({
       message: `${title}
 ${warning}`,
       options: [
@@ -566,30 +760,243 @@ ${warning}`,
 }
 
 // src/commands/remove.ts
-async function removeCommand() {
-  notImplemented("remove");
+import { rm as rm2 } from "fs/promises";
+import { join as join9 } from "path";
+import * as p3 from "@clack/prompts";
+async function removeCommand(options) {
+  await runRemove(process.cwd(), options);
+}
+async function runRemove(cwd, options) {
+  const version = packageVersion();
+  p3.intro(`Engly  v${version}`);
+  let config = null;
+  try {
+    config = await readConfig(cwd, version);
+  } catch (error) {
+    if (!(error instanceof ConfigError)) throw error;
+  }
+  const blocks = await findBlocks(cwd, config ? configuredTools(config) : [...IMPLEMENTED_TOOLS]);
+  const hasEnglyDir = await pathExists(join9(cwd, ENGLY_DIR));
+  const hasSkills = await hasInstalledSkills(cwd);
+  if (blocks.length === 0 && !hasEnglyDir && !hasSkills) {
+    p3.outro("Nothing to remove.");
+    return;
+  }
+  const plan = [
+    ...blocks.map((block) => `The Engly block in ${block.file}`),
+    ...hasEnglyDir ? [`The ${ENGLY_DIR}/ folder (settings and instructions)`] : [],
+    ...hasSkills ? [`The skills: ${SKILL_NAMES.join(", ")}`] : []
+  ];
+  if (!options.yes) {
+    if (!process.stdin.isTTY) {
+      throw new Error('No interactive terminal detected. Run "engly remove --yes" to remove without asking.');
+    }
+    const confirmed = await p3.confirm({
+      message: `Remove Engly from this project?
+${plan.map((line) => `  \u2022 ${line}`).join("\n")}`
+    });
+    if (p3.isCancel(confirmed) || !confirmed) {
+      p3.cancel("Cancelled. Nothing was changed.");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const done = [];
+  for (const block of blocks) {
+    await writeText(block.path, removeBlock(block.text).text);
+    done.push(`\u2713 Engly block removed from ${block.file}`);
+  }
+  if (hasSkills) {
+    await removeSkills(cwd);
+    done.push(`\u2713 Skills removed: ${SKILL_NAMES.join(", ")}`);
+  }
+  if (hasEnglyDir) {
+    await rm2(join9(cwd, ENGLY_DIR), { recursive: true, force: true });
+    done.push(`\u2713 ${ENGLY_DIR}/ removed`);
+  }
+  p3.log.success(done.join("\n"));
+  p3.outro("Engly removed. Everything outside the Engly block was left untouched.");
 }
 
 // src/commands/status.ts
+import { join as join10 } from "path";
+import * as p4 from "@clack/prompts";
 async function statusCommand() {
-  notImplemented("status");
+  await runStatus(process.cwd());
+}
+async function runStatus(cwd) {
+  const version = packageVersion();
+  p4.intro(`Engly  v${version}`);
+  let config = null;
+  let configError = null;
+  try {
+    config = await readConfig(cwd, version);
+  } catch (error) {
+    if (!(error instanceof ConfigError)) throw error;
+    configError = error.message;
+  }
+  const tools = configuredTools(config);
+  const files = await inspectAgentFiles(cwd, tools);
+  const withBlock = files.filter((file) => file.state === "active" || file.state === "inactive");
+  const broken = files.filter((file) => file.state === "broken");
+  const hasInstructions = await pathExists(join10(cwd, INSTRUCTIONS_FILE));
+  const skills = config ? await skillStatus(cwd, tools) : [];
+  const installed = config !== null || configError !== null || withBlock.length > 0 || broken.length > 0 || hasInstructions || await hasInstalledSkills(cwd);
+  if (!installed) {
+    p4.outro('Engly is not installed in this project. Run "engly init".');
+    return;
+  }
+  const active = withBlock.some((file) => file.state === "active");
+  const status = withBlock.length === 0 ? "off (no Engly block in the agent files)" : active ? "enabled" : "disabled";
+  const rows = [["Status", status]];
+  if (config) {
+    rows.push(
+      ["Version", config.version],
+      ["Style", config.style],
+      ["Level", config.level],
+      ["Language", config.language],
+      ["Tools", tools.map((tool) => adapters[tool].name).join(", ")]
+    );
+  }
+  rows.push(["Files", fileLines(files, hasInstructions)]);
+  if (skills.length > 0) {
+    rows.push([
+      "Skills",
+      skills.map((folder) => `${folder.dir} ${folder.missing.length === 0 ? "\u2713" : "\u2717"}`).join("\n")
+    ]);
+  }
+  p4.note(formatRows(rows), "Engly status");
+  const warnings = await collectWarnings({ cwd, version, config, configError, tools, withBlock, broken, skills });
+  for (const warning of warnings) p4.log.warn(warning);
+  p4.outro(warnings.length === 0 ? "All good." : `${warnings.length} warning${warnings.length === 1 ? "" : "s"}.`);
+}
+async function collectWarnings(input) {
+  const { cwd, version, config, configError, tools, withBlock, broken, skills } = input;
+  const warnings = [];
+  if (configError) {
+    warnings.push(`${configError} Fix it by hand, or run "engly init" to write a new one.`);
+  } else if (!config) {
+    warnings.push(`${CONFIG_FILE} is missing. Run "engly init" to write it again.`);
+  } else if (config.version !== version) {
+    warnings.push(`This project uses Engly v${config.version} and the CLI is v${version}. Run "engly update".`);
+  }
+  for (const file of broken) warnings.push(`${file.file}: ${file.error}`);
+  if (withBlock.length === 0 && broken.length === 0) {
+    const names = (await candidateFiles(cwd, tools)).join(" or ");
+    warnings.push(`No Engly block found in ${names}, so nothing is coached. Run "engly init" to add it.`);
+  }
+  const active = withBlock.some((file) => file.state === "active");
+  if (config && withBlock.length > 0 && config.enabled !== active) {
+    warnings.push(
+      `${CONFIG_FILE} says Engly is ${config.enabled ? "enabled" : "disabled"}, but the block is ${active ? "active" : "empty"}. Run "engly ${config.enabled ? "enable" : "disable"}" to sync them.`
+    );
+  }
+  if (active && !await pathExists(join10(cwd, INSTRUCTIONS_FILE))) {
+    warnings.push(`${INSTRUCTIONS_FILE} is missing, but the block imports it. Run "engly update".`);
+  }
+  for (const folder of skills) {
+    if (folder.missing.length > 0) {
+      warnings.push(`Missing skills in ${folder.dir}: ${folder.missing.join(", ")}. Run "engly update".`);
+    }
+  }
+  for (const file of withBlock) {
+    const size = sizeWarning(file, tools);
+    if (size) warnings.push(size);
+  }
+  return warnings;
+}
+function sizeWarning(file, tools) {
+  for (const tool of tools) {
+    const adapter = adapters[tool];
+    if (!adapter.instructionFiles?.includes(file.file)) continue;
+    const report = checkSize(file.text, adapter.sizeLimit);
+    if (report) return `${file.file} is ${report.label}. ${report.warning.replace(/\n/g, " ")}`;
+  }
+  return null;
+}
+function fileLines(files, hasInstructions) {
+  const lines = files.map((file) => {
+    switch (file.state) {
+      case "active":
+        return `${file.file} \u2713 (block active)`;
+      case "inactive":
+        return `${file.file} \u2713 (block empty, coach off)`;
+      case "broken":
+        return `${file.file} \u2717 (broken markers)`;
+      default:
+        return `${file.file} \u2013 (no Engly block)`;
+    }
+  });
+  lines.push(`${INSTRUCTIONS_FILE} ${hasInstructions ? "\u2713" : "\u2717"}`);
+  return lines.join("\n");
+}
+function formatRows(rows) {
+  const width = Math.max(...rows.map(([label]) => label.length)) + 2;
+  return rows.map(
+    ([label, value]) => value.split("\n").map((line, index) => `${index === 0 ? `${label}:`.padEnd(width) : " ".repeat(width)}${line}`).join("\n")
+  ).join("\n");
 }
 
 // src/commands/update.ts
+import * as p5 from "@clack/prompts";
 async function updateCommand() {
-  notImplemented("update");
+  await runUpdate(process.cwd());
+}
+async function runUpdate(cwd) {
+  const version = packageVersion();
+  p5.intro(`Engly  v${version}`);
+  const config = await requireConfig(cwd, version);
+  const previous = config.version;
+  const tools = configuredTools(config);
+  const blocks = await findBlocks(cwd, tools);
+  config.version = version;
+  await writeInstructions(cwd, config);
+  await installSkills(cwd, tools);
+  const done = ["\u2713 .engly/engly.md and skills refreshed"];
+  for (const block of blocks) {
+    const { text } = upsertBlock(block.text, blockContent(config.enabled), { version });
+    if (text === block.text) {
+      done.push(`\u2713 ${block.file} block is up to date`);
+      continue;
+    }
+    await writeText(block.path, text);
+    done.push(`\u2713 ${block.file} block updated`);
+  }
+  await writeConfig(cwd, config);
+  p5.log.success(done.join("\n"));
+  if (blocks.length === 0) {
+    const files = (await candidateFiles(cwd, tools)).join(" or ");
+    p5.log.warn(`No Engly block found in ${files}. Run "engly init" to add it.`);
+  }
+  if (!config.enabled) {
+    p5.log.warn('Engly is disabled. Run "engly enable" to turn it on.');
+  }
+  p5.log.info(
+    "This updates the files in this project. To update the engly CLI itself, run: npm install -g engly@latest"
+  );
+  p5.outro(previous === version ? `Already on v${version}.` : `Updated from v${previous} to v${version}.`);
+}
+
+// src/core/update-check.ts
+import updateNotifier from "update-notifier";
+function notifyIfUpdateAvailable() {
+  try {
+    updateNotifier({ pkg: packageInfo() }).notify();
+  } catch {
+  }
 }
 
 // src/cli.ts
+notifyIfUpdateAvailable();
 var program = new Command();
-program.name("engly").description("Your English coach for AI prompts. One command. Every agent. Always on. Zero cost.").version(packageVersion());
+program.name("engly").description("Your English coach for AI prompts. One command. Every agent. Always on.").version(packageVersion());
 program.command("init").description("Install Engly in the current project").option("--tools <tools>", "comma-separated agents: claude,codex,opencode,cursor,copilot").option("--style <style>", "feedback style: light or detailed").option("-y, --yes", "accept all defaults without asking").option("--no-apply", "only install the skills, don't touch the agent files").action(initCommand);
 program.command("update").description("Update the skills and regenerate the Engly block").action(updateCommand);
 program.command("enable").description("Turn the coach on permanently").action(enableCommand);
 program.command("disable").description("Turn the coach off permanently, without uninstalling").action(disableCommand);
 program.command("config").description('Change an option, e.g. "engly config level B2"').argument("<option>", "language, level or style").argument("<value>", "new value").action(configCommand);
 program.command("status").description("Show where Engly is installed and whether it is active").action(statusCommand);
-program.command("remove").description("Remove the Engly block, skills and config").action(removeCommand);
+program.command("remove").description("Remove the Engly block, skills and config").option("-y, --yes", "remove without asking").action(removeCommand);
 try {
   await program.parseAsync();
 } catch (error) {