@nalvietnam/avatar-cli 1.0.0 → 1.1.0

package/dist/index.js

@@ -124,6 +124,7 @@ import { promises as fs2 } from "fs";
 import { join as join4 } from "path";
 
 // src/lib/template-bundle-loader.ts
+import { existsSync } from "fs";
 import { dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath } from "url";
 
@@ -139,8 +140,20 @@ function renderTemplate(source, variables) {
 
 // src/lib/template-bundle-loader.ts
 var HERE = dirname2(fileURLToPath(import.meta.url));
-var TEMPLATES_ROOT = join3(HERE, "..", "src", "templates");
-var HOOKS_ROOT = join3(HERE, "..", "src", "hooks");
+var PACKAGE_ROOT = findPackageRoot(HERE);
+var TEMPLATES_ROOT = join3(PACKAGE_ROOT, "src", "templates");
+var HOOKS_ROOT = join3(PACKAGE_ROOT, "src", "hooks");
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    if (existsSync(join3(dir, "package.json"))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      throw new Error(`Cannot locate package root from ${startDir}`);
+    }
+    dir = parent;
+  }
+}
 async function loadTemplate(name) {
   return await readText(join3(TEMPLATES_ROOT, `${name}.tpl`));
 }
@@ -153,6 +166,27 @@ async function loadHook(name) {
 }
 
 // src/lib/project-tree-scaffolder.ts
+async function backupIfExists(path) {
+  if (!await pathExists(path)) return null;
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const basePath = `${path}.avatar-backup-${ts}`;
+  let backupPath = basePath;
+  let counter = 1;
+  while (await pathExists(backupPath)) {
+    backupPath = `${basePath}-${counter}`;
+    counter++;
+    if (counter > 5) {
+      throw new Error(`Could not find free backup name for ${path}`);
+    }
+  }
+  await fs2.rename(path, backupPath);
+  return backupPath;
+}
+async function writeWithBackup(path, content, mode) {
+  const backup = await backupIfExists(path);
+  await writeTextAtomic(path, content, mode);
+  return backup;
+}
 var CLAUDE_SUBDIRS = ["project", "state", "_pending", "_backup"];
 var PROJECT_KNOWLEDGE_TEMPLATES = [
   "project/tech-stack.md",
@@ -194,20 +228,23 @@ async function writeProjectKnowledgeFiles(projectRoot, vars) {
     primaryUseCases: "(ch\u01B0a scan)",
     domainGlossary: "(ch\u01B0a scan)"
   };
+  const backups = [];
   for (const tpl of PROJECT_KNOWLEDGE_TEMPLATES) {
     const content = await renderTemplateByName(tpl, baseVars);
-    const relative2 = tpl.replace(/^project\//, "");
-    const outPath = join4(projectRoot, ".claude", "project", relative2);
-    await writeTextAtomic(outPath, content);
+    const relative4 = tpl.replace(/^project\//, "");
+    const outPath = join4(projectRoot, ".claude", "project", relative4);
+    const backup = await writeWithBackup(outPath, content);
+    if (backup) backups.push(backup);
   }
+  return backups;
 }
 async function writeRootClaudeMd(projectRoot, vars) {
   const content = await renderTemplateByName("CLAUDE.md", vars);
-  await writeTextAtomic(join4(projectRoot, "CLAUDE.md"), content);
+  return await writeWithBackup(join4(projectRoot, "CLAUDE.md"), content);
 }
 async function writeProjectSettings(projectRoot, vars) {
   const content = await renderTemplateByName("settings.json", vars);
-  await writeTextAtomic(join4(projectRoot, ".claude", "settings.json"), content);
+  return await writeWithBackup(join4(projectRoot, ".claude", "settings.json"), content);
 }
 async function appendGitignoreEntries(projectRoot) {
   const path = join4(projectRoot, ".gitignore");
@@ -441,7 +478,7 @@ async function applyFixes(checks) {
 }
 
 // src/commands/init.ts
-import { join as join8, resolve } from "path";
+import { basename, join as join13, relative as relative2, resolve } from "path";
 import { confirm, input, select } from "@inquirer/prompts";
 import boxen2 from "boxen";
 
@@ -459,15 +496,406 @@ async function appendAuditEntry(action, detail) {
   await fs4.appendFile(AUDIT_LOG_PATH, line, "utf8");
 }
 
-// src/lib/team-pack-submodule-manager.ts
+// src/lib/avatar-ascii-banner.ts
+import chalk2 from "chalk";
+var BANNER_LINES = [
+  " \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551",
+  "\u255A\u2550\u255D  \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D  \u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D"
+];
+var GRADIENT_STOPS = [
+  [217, 79, 30],
+  // cam-cháy (#d94f1e)
+  [200, 70, 80],
+  // cam-hồng
+  [170, 70, 140],
+  // hồng-tím
+  [125, 88, 217]
+  // tím (#7d58d9)
+];
+function lerpChannel(a, b, t) {
+  return Math.round(a + (b - a) * t);
+}
+function gradientAt(t) {
+  const clamped = Math.max(0, Math.min(1, t));
+  const scaled = clamped * (GRADIENT_STOPS.length - 1);
+  const lo = Math.floor(scaled);
+  const hi = Math.min(GRADIENT_STOPS.length - 1, lo + 1);
+  const localT = scaled - lo;
+  const a = GRADIENT_STOPS[lo];
+  const b = GRADIENT_STOPS[hi];
+  return [
+    lerpChannel(a[0], b[0], localT),
+    lerpChannel(a[1], b[1], localT),
+    lerpChannel(a[2], b[2], localT)
+  ];
+}
+function renderAvatarBanner(opts) {
+  const isTty = process.stdout.isTTY ?? false;
+  const supportsColor = isTty && chalk2.level > 0;
+  if (!supportsColor) {
+    return [...BANNER_LINES, ...opts?.tagline ? ["", opts.tagline] : []].join("\n");
+  }
+  const colored = BANNER_LINES.map((line, idx) => {
+    const t = BANNER_LINES.length === 1 ? 0 : idx / (BANNER_LINES.length - 1);
+    const [r, g, b] = gradientAt(t);
+    return chalk2.rgb(r, g, b).bold(line);
+  });
+  if (opts?.tagline) {
+    colored.push("");
+    colored.push(chalk2.dim(opts.tagline));
+  }
+  return colored.join("\n");
+}
+function printAvatarBanner(opts) {
+  process.stdout.write(`
+${renderAvatarBanner(opts)}
+
+`);
+}
+
+// src/lib/execute-gh-repo-create.ts
+import { spawnSync as spawnSync2 } from "child_process";
+var RepoAlreadyExistsError = class extends Error {
+  constructor(fullName) {
+    super(`Repo "${fullName}" \u0111\xE3 t\u1ED3n t\u1EA1i tr\xEAn GitHub. \u0110\u1ED5i t\xEAn ho\u1EB7c x\xF3a repo c\u0169.`);
+    this.name = "RepoAlreadyExistsError";
+  }
+};
+function executeGhRepoCreate(input2) {
+  const fullName = `${input2.org}/${input2.name}`;
+  const args = [
+    "repo",
+    "create",
+    fullName,
+    `--${input2.visibility}`,
+    "--source",
+    input2.folder,
+    "--remote",
+    "origin",
+    "--push"
+  ];
+  const r = spawnSync2("gh", args, { stdio: "inherit" });
+  if (r.status !== 0) {
+    if (r.status === 1) {
+      throw new RepoAlreadyExistsError(fullName);
+    }
+    throw new Error(`gh repo create th\u1EA5t b\u1EA1i (exit ${r.status})`);
+  }
+  return {
+    sshUrl: `git@github.com:${fullName}.git`,
+    httpsUrl: `https://github.com/${fullName}.git`
+  };
+}
+
+// src/lib/resolve-github-username-default.ts
+import { spawnSync as spawnSync3 } from "child_process";
+function resolveGithubUsernameDefault() {
+  const r = spawnSync3("gh", ["api", "user", "--jq", ".login"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (r.status !== 0) {
+    throw new Error(`Kh\xF4ng l\u1EA5y \u0111\u01B0\u1EE3c GitHub username: ${r.stderr?.trim()}`);
+  }
+  return r.stdout.trim();
+}
+
+// src/lib/validate-repo-name-and-visibility.ts
+var REPO_NAME_REGEX = /^[a-zA-Z0-9._-]{1,100}$/;
+var InvalidRepoNameError = class extends Error {
+  constructor(name) {
+    super(
+      `T\xEAn repo "${name}" kh\xF4ng h\u1EE3p l\u1EC7. Ch\u1EC9 d\xF9ng ch\u1EEF/s\u1ED1/d\u1EA5u ch\u1EA5m/g\u1EA1ch/underscore, d\xE0i 1-100 k\xFD t\u1EF1.`
+    );
+    this.name = "InvalidRepoNameError";
+  }
+};
+function validateRepoName(name) {
+  if (!REPO_NAME_REGEX.test(name)) {
+    throw new InvalidRepoNameError(name);
+  }
+}
+function validateRepoVisibility(v) {
+  if (v !== "private" && v !== "public") {
+    throw new Error(`Visibility ph\u1EA3i l\xE0 "private" ho\u1EB7c "public", nh\u1EADn: "${v}"`);
+  }
+}
+
+// src/lib/create-github-remote-from-folder.ts
+function createGithubRemoteFromFolder(input2) {
+  validateRepoName(input2.name);
+  validateRepoVisibility(input2.visibility);
+  const org = input2.org ?? resolveGithubUsernameDefault();
+  log.info(`T\u1EA1o GitHub repo ${org}/${input2.name} (${input2.visibility})...`);
+  const urls = executeGhRepoCreate({
+    folder: input2.folder,
+    org,
+    name: input2.name,
+    visibility: input2.visibility
+  });
+  log.success(`\u0110\xE3 t\u1EA1o: ${urls.sshUrl}`);
+  return urls;
+}
+
+// src/lib/check-gh-cli-auth-status.ts
+import { spawnSync as spawnSync4 } from "child_process";
+function checkGhCliAuthStatus() {
+  const r = spawnSync4("gh", ["auth", "status"], { stdio: "ignore" });
+  if (r.error && r.error.code === "ENOENT") {
+    return "not-installed";
+  }
+  return r.status === 0 ? "authenticated" : "not-authenticated";
+}
+
+// src/lib/detect-package-manager.ts
+import { spawnSync as spawnSync5 } from "child_process";
+
+// src/lib/detect-host-platform.ts
+import { platform } from "os";
+function detectHostPlatform() {
+  const p = platform();
+  if (p === "darwin" || p === "linux" || p === "win32") return p;
+  return "unsupported";
+}
+
+// src/lib/detect-package-manager.ts
+function hasBinary(name) {
+  const platform2 = detectHostPlatform();
+  const probe = platform2 === "win32" ? "where" : "command";
+  const args = platform2 === "win32" ? [name] : ["-v", name];
+  const r = spawnSync5(probe, args, {
+    shell: platform2 !== "win32",
+    stdio: "ignore"
+  });
+  return r.status === 0;
+}
+function detectPackageManager() {
+  const platform2 = detectHostPlatform();
+  const candidates = platform2 === "darwin" ? ["brew"] : platform2 === "win32" ? ["winget"] : platform2 === "linux" ? ["apt", "dnf", "pacman"] : [];
+  for (const pm of candidates) {
+    if (hasBinary(pm)) return pm;
+  }
+  return null;
+}
+
+// src/lib/install-gh-cli-via-package-manager.ts
+import { spawnSync as spawnSync6 } from "child_process";
+var INSTALL_COMMANDS = {
+  brew: { cmd: "brew", args: ["install", "gh"] },
+  apt: { cmd: "sudo", args: ["apt-get", "install", "-y", "gh"] },
+  dnf: { cmd: "sudo", args: ["dnf", "install", "-y", "gh"] },
+  pacman: { cmd: "sudo", args: ["pacman", "-S", "--noconfirm", "github-cli"] },
+  winget: { cmd: "winget", args: ["install", "--id", "GitHub.cli", "-e", "--silent"] }
+};
+function installGhCliViaPackageManager(pm) {
+  const spec = INSTALL_COMMANDS[pm];
+  log.info(`\u0110ang c\xE0i gh CLI qua ${pm}...`);
+  const r = spawnSync6(spec.cmd, spec.args, { stdio: "inherit" });
+  if (r.status !== 0) {
+    throw new Error(`C\xE0i gh CLI th\u1EA5t b\u1EA1i qua ${pm} (exit ${r.status}). C\xE0i tay r\u1ED3i ch\u1EA1y l\u1EA1i.`);
+  }
+  log.success("\u0110\xE3 c\xE0i gh CLI");
+}
+
+// src/lib/trigger-gh-cli-auth-login.ts
+import { spawnSync as spawnSync7 } from "child_process";
+function triggerGhCliAuthLogin() {
+  log.info("Kh\u1EDFi \u0111\u1ED9ng \u0111\u0103ng nh\u1EADp GitHub qua gh CLI (browser s\u1EBD m\u1EDF)...");
+  const r = spawnSync7(
+    "gh",
+    ["auth", "login", "--hostname", "github.com", "--web", "--git-protocol", "ssh"],
+    { stdio: "inherit" }
+  );
+  if (r.status !== 0) {
+    throw new Error(`gh auth login th\u1EA5t b\u1EA1i (exit ${r.status}). Th\u1EED 'gh auth login' tay.`);
+  }
+  log.success("\u0110\xE3 \u0111\u0103ng nh\u1EADp GitHub");
+}
+
+// src/lib/verify-git-remote-accessible.ts
+import { spawnSync as spawnSync8 } from "child_process";
+var TIMEOUT_MS = 5e3;
+var RemoteNotAccessibleError = class extends Error {
+  constructor(url, reason) {
+    super(`Kh\xF4ng truy c\u1EADp \u0111\u01B0\u1EE3c remote ${url}: ${reason}`);
+    this.name = "RemoteNotAccessibleError";
+  }
+};
+function verifyGitRemoteAccessible(url) {
+  const r = spawnSync8("git", ["ls-remote", "--exit-code", url, "HEAD"], {
+    stdio: "ignore",
+    timeout: TIMEOUT_MS
+  });
+  if (r.status === 0) return;
+  if (r.signal === "SIGTERM") throw new RemoteNotAccessibleError(url, "timeout 5s");
+  throw new RemoteNotAccessibleError(url, `git ls-remote exit ${r.status}`);
+}
+
+// src/lib/git-auth-and-install-orchestrator.ts
+async function ensureGitHubReady(remoteUrl) {
+  let state = checkGhCliAuthStatus();
+  if (state === "not-installed") {
+    log.warn("gh CLI ch\u01B0a c\xE0i. Avatar s\u1EBD t\u1EF1 c\xE0i.");
+    const pm = detectPackageManager();
+    if (!pm) {
+      throw new Error(
+        "Kh\xF4ng ph\xE1t hi\u1EC7n package manager (brew/apt/dnf/pacman/winget). C\xE0i gh CLI tay r\u1ED3i ch\u1EA1y l\u1EA1i: https://cli.github.com"
+      );
+    }
+    installGhCliViaPackageManager(pm);
+    state = checkGhCliAuthStatus();
+  }
+  if (state === "not-authenticated") {
+    log.warn("Ch\u01B0a \u0111\u0103ng nh\u1EADp GitHub.");
+    triggerGhCliAuthLogin();
+    state = checkGhCliAuthStatus();
+    if (state !== "authenticated") {
+      throw new Error("Sau gh auth login v\u1EABn ch\u01B0a authenticated. Th\u1EED l\u1EA1i.");
+    }
+  }
+  log.success("gh CLI s\u1EB5n s\xE0ng");
+  if (remoteUrl) {
+    verifyGitRemoteAccessible(remoteUrl);
+    log.success(`Remote accessible: ${remoteUrl}`);
+  }
+}
+
+// src/lib/check-folder-has-git.ts
+import { existsSync as existsSync2, statSync } from "fs";
 import { join as join7 } from "path";
-var TEAM_PACK_REPO_URL = "https://github.com/LukeNALS/team-ai-pack.git";
+function checkFolderHasGit(folderPath) {
+  const gitPath = join7(folderPath, ".git");
+  if (!existsSync2(gitPath)) return false;
+  const stat = statSync(gitPath);
+  return stat.isDirectory() || stat.isFile();
+}
+
+// src/lib/create-initial-git-commit.ts
+import { simpleGit as simpleGit2 } from "simple-git";
+var INITIAL_COMMIT_MESSAGE = "chore: initial commit";
+async function createInitialGitCommit(folderPath) {
+  const g = simpleGit2({ baseDir: folderPath });
+  const isRepo = await g.checkIsRepo().catch(() => false);
+  if (!isRepo) {
+    await g.init();
+  }
+  try {
+    await g.branch(["-M", "main"]);
+  } catch {
+  }
+  await g.add(".");
+  const status = await g.status();
+  const hasCommits = (await g.raw(["rev-list", "-n", "1", "--all"]).catch(() => "")).trim();
+  if (hasCommits) return;
+  if (status.files.length === 0) {
+    await g.commit(INITIAL_COMMIT_MESSAGE, void 0, { "--allow-empty": null });
+  } else {
+    await g.commit(INITIAL_COMMIT_MESSAGE);
+  }
+}
+
+// src/lib/detect-folder-tech-stack.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join8 } from "path";
+var SIGNATURES = {
+  node: ["package.json"],
+  python: ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"],
+  go: ["go.mod"],
+  rust: ["Cargo.toml"],
+  java: ["pom.xml", "build.gradle", "build.gradle.kts"],
+  ruby: ["Gemfile"]
+};
+function detectFolderTechStack(folderPath) {
+  const matched = [];
+  for (const [stack, files] of Object.entries(SIGNATURES)) {
+    if (files.some((f) => existsSync3(join8(folderPath, f)))) {
+      matched.push(stack);
+    }
+  }
+  return matched.length > 0 ? matched : ["generic"];
+}
+
+// src/lib/gitignore-template-loader.ts
+import { readFileSync } from "fs";
+import { dirname as dirname3, join as join9 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname = dirname3(fileURLToPath2(import.meta.url));
+var CANDIDATE_DIRS = [
+  join9(__dirname, "..", "templates", "gitignore"),
+  join9(__dirname, "..", "..", "src", "templates", "gitignore")
+];
+var AVATAR_MARKER_START = "# === avatar ===";
+var AVATAR_MARKER_END = "# === /avatar ===";
+function readTemplate(stack) {
+  for (const dir of CANDIDATE_DIRS) {
+    try {
+      return readFileSync(join9(dir, `${stack}.txt`), "utf8");
+    } catch {
+    }
+  }
+  throw new Error(`Kh\xF4ng t\xECm th\u1EA5y template gitignore cho stack "${stack}"`);
+}
+function composeGitignoreContent(stacks) {
+  const all = ["generic", ...stacks.filter((s) => s !== "generic")];
+  const sections = all.map((s) => `# --- ${s} ---
+${readTemplate(s).trim()}`);
+  return [AVATAR_MARKER_START, ...sections, AVATAR_MARKER_END, ""].join("\n");
+}
+
+// src/lib/write-or-merge-gitignore.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join10 } from "path";
+function writeOrMergeGitignore(folderPath, avatarBlock) {
+  const path = join10(folderPath, ".gitignore");
+  if (!existsSync4(path)) {
+    writeFileSync(path, avatarBlock, "utf8");
+    return;
+  }
+  const existing = readFileSync2(path, "utf8");
+  const startIdx = existing.indexOf(AVATAR_MARKER_START);
+  const endIdx = existing.indexOf(AVATAR_MARKER_END);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + AVATAR_MARKER_END.length);
+    writeFileSync(path, `${before.trimEnd()}
+
+${avatarBlock}${after.trimStart()}`, "utf8");
+    return;
+  }
+  writeFileSync(path, `${existing.trimEnd()}
+
+${avatarBlock}`, "utf8");
+}
+
+// src/lib/git-bootstrap-orchestrator.ts
+async function bootstrapGitInFolder(folderPath) {
+  const hadGit = checkFolderHasGit(folderPath);
+  const stacks = detectFolderTechStack(folderPath);
+  log.info(`Tech stack detected: ${stacks.join(", ")}`);
+  writeOrMergeGitignore(folderPath, composeGitignoreContent(stacks));
+  log.success(".gitignore \u0111\xE3 ghi (Avatar block)");
+  if (!hadGit) {
+    log.info(`Bootstrap git cho ${folderPath}...`);
+    await createInitialGitCommit(folderPath);
+    log.success("\u0110\xE3 git init + initial commit");
+  } else {
+    log.dim("Folder \u0111\xE3 c\xF3 .git \u2014 skip init.");
+  }
+}
+
+// src/lib/team-pack-submodule-manager.ts
+import { join as join11 } from "path";
+var TEAM_PACK_REPO_URL = process.env.AVATAR_TEAM_PACK_REPO_URL ?? "https://github.com/LukeNALS/team-ai-pack.git";
 var TEAM_PACK_RELATIVE_PATH = ".claude/pack";
 async function addTeamPackSubmodule(projectRoot, tag) {
   await addSubmodule(TEAM_PACK_REPO_URL, TEAM_PACK_RELATIVE_PATH, projectRoot);
   let target = tag ?? null;
   if (!target) {
-    target = await latestTag(join7(projectRoot, TEAM_PACK_RELATIVE_PATH));
+    target = await latestTag(join11(projectRoot, TEAM_PACK_RELATIVE_PATH));
   }
   if (target) {
     await checkoutTagInSubmodule(TEAM_PACK_RELATIVE_PATH, target, projectRoot);
@@ -475,17 +903,56 @@ async function addTeamPackSubmodule(projectRoot, tag) {
   return { pinnedTag: target };
 }
 async function readPinnedPackVersion(projectRoot) {
-  const submoduleRoot = join7(projectRoot, TEAM_PACK_RELATIVE_PATH);
+  const submoduleRoot = join11(projectRoot, TEAM_PACK_RELATIVE_PATH);
   const tag = await latestTag(submoduleRoot);
   if (tag) return tag;
   const sha = await currentCommitSha(submoduleRoot);
   return sha.slice(0, 7);
 }
 
+// src/commands/init-conflict-detection-helpers.ts
+import { readdir } from "fs/promises";
+import { join as join12 } from "path";
+async function isEmptyOrMissing(path) {
+  if (!await pathExists(path)) return true;
+  try {
+    const entries = await readdir(path);
+    const meaningful = entries.filter((e) => !e.startsWith(".") && e !== "Thumbs.db");
+    return meaningful.length === 0;
+  } catch {
+    return false;
+  }
+}
+async function findAlternativeWorkspaceName(parent, desiredName, maxAttempts = 10) {
+  for (let i = 2; i < maxAttempts; i++) {
+    const candidate = join12(parent, `${desiredName}-${i}`);
+    if (await isEmptyOrMissing(candidate)) return candidate;
+  }
+  return null;
+}
+
+// src/commands/init-scaffold-variable-builders.ts
+var AVATAR_CLI_VERSION = "1.0.1";
+function inferWorkspaceName(repoUrl) {
+  const m = repoUrl.match(/[/:]([^/]+?)(\.git)?$/);
+  const base = m?.[1] ?? "client";
+  return `avatar-${base}-workspace`;
+}
+function buildScaffoldVariables(args) {
+  return {
+    projectName: args.projectName,
+    projectDescription: args.projectDescription,
+    teamOwner: args.teamOwner,
+    avatarVersion: AVATAR_CLI_VERSION,
+    packVersion: args.packVersion,
+    lastScan: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: args.mode
+  };
+}
+
 // src/commands/init.ts
-var AVATAR_CLI_VERSION = "1.0.0";
 function registerInitCommand(program2) {
-  program2.command("init").description("Kh\u1EDFi t\u1EA1o Avatar trong d\u1EF1 \xE1n (3 mode: internal/client/library)").option("--mode <mode>", "internal | client | library").option("--skip-scan", "B\u1ECF qua b\u01B0\u1EDBc project-scanner").option("--pack-version <tag>", "Pin team-ai-pack v\xE0o version c\u1EE5 th\u1EC3").option("--client-repo <url>", "URL git c\u1EE7a client repo (mode=client)").option("--workspace-name <name>", "T\xEAn workspace (mode=client)").option("--workspace-parent <path>", "Th\u01B0 m\u1EE5c cha t\u1EA1o workspace (mode=client)").action(async (opts) => {
+  program2.command("init").description("Kh\u1EDFi t\u1EA1o Avatar \u2014 3 flow t\u1EF1 nh\u1EADn di\u1EC7n (repo / folder / new)").option("--project-status <val>", "existing-remote | existing-folder | new-project").option("--folder-path <path>", "\u0110\u01B0\u1EDDng d\u1EABn folder hi\u1EC7n c\xF3 (flow existing-folder)").option("--create-remote", "Force t\u1EA1o remote qua gh (flow existing-folder ho\u1EB7c new-project)").option("--repo-visibility <val>", "private (m\u1EB7c \u0111\u1ECBnh) | public").option("--repo-org <name>", "GitHub org/owner cho repo m\u1EDBi").option("--client-repo <url>", "URL git remote (flow existing-remote)").option("--workspace-name <name>", "T\xEAn workspace").option("--workspace-parent <path>", "Th\u01B0 m\u1EE5c cha t\u1EA1o workspace (m\u1EB7c \u0111\u1ECBnh ..)").option("--pack-version <tag>", "Pin team-ai-pack v\xE0o tag c\u1EE5 th\u1EC3").option("--team-owner <email>", "Email team owner (b\u1ECF qua prompt)").option("--description <text>", "M\xF4 t\u1EA3 1 d\xF2ng c\u1EE7a d\u1EF1 \xE1n").option("--skip-scan", "B\u1ECF qua project-scanner sau scaffold").option("--force", "B\u1ECF qua prompt khi workspace path \u0111\xE3 t\u1ED3n t\u1EA1i").option("--yes", "Auto-confirm t\u1EA5t c\u1EA3 prompt").option("--mode <mode>", "[DEPRECATED] D\xF9ng --project-status thay th\u1EBF").action(async (opts) => {
     try {
       await runInit(opts);
     } catch (err) {
@@ -495,190 +962,251 @@ function registerInitCommand(program2) {
   });
 }
 async function runInit(opts) {
+  if (!opts.yes) printAvatarBanner({ tagline: "Kh\u1EDFi t\u1EA1o Avatar trong d\u1EF1 \xE1n c\u1EE7a b\u1EA1n" });
+  if (opts.mode) {
+    log.warn("Flag --mode \u0111\xE3 deprecated t\u1EEB v1.1. D\xF9ng --project-status thay th\u1EBF.");
+  }
   const userConfig = await readUserConfig();
   if (!userConfig || isTokenExpired(userConfig)) {
-    log.error("Ch\u01B0a \u0111\u0103ng nh\u1EADp ho\u1EB7c token \u0111\xE3 h\u1EBFt h\u1EA1n. Ch\u1EA1y 'avatar login' tr\u01B0\u1EDBc.");
+    log.error("Ch\u01B0a \u0111\u0103ng nh\u1EADp ho\u1EB7c token h\u1EBFt h\u1EA1n. Ch\u1EA1y 'avatar login' tr\u01B0\u1EDBc.");
     process.exit(1);
   }
-  const mode = opts.mode ?? await promptMode();
-  if (mode === "internal") {
-    await runInitInternal(opts, userConfig.email);
-  } else {
-    await runInitClientOrLibrary(opts, mode, userConfig.email);
+  const status = opts.projectStatus ?? await promptProjectStatus();
+  switch (status) {
+    case "existing-remote":
+      await runInitFromExistingRemote(opts, userConfig.email);
+      break;
+    case "existing-folder":
+      await runInitFromExistingFolder(opts, userConfig.email);
+      break;
+    case "new-project":
+      await runInitFromScratch(opts, userConfig.email);
+      break;
   }
 }
-async function promptMode() {
+async function promptProjectStatus() {
   return await select({
-    message: "\u0110\xE2y l\xE0 lo\u1EA1i d\u1EF1 \xE1n g\xEC?",
+    message: "T\xECnh tr\u1EA1ng d\u1EF1 \xE1n c\u1EE7a b\u1EA1n?",
     choices: [
-      {
-        name: "N\u1ED9i b\u1ED9 NAL (Avatar files commit c\xF9ng code)",
-        value: "internal"
-      },
-      { name: "Client (Pattern A \u2014 t\xE1ch workspace)", value: "client" },
-      { name: "Library/SDK public (t\xE1ch workspace)", value: "library" }
+      { name: "1. \u0110\xE3 c\xF3 repo git remote (URL c\xF3 s\u1EB5n)", value: "existing-remote" },
+      { name: "2. \u0110\xE3 c\xF3 folder code local", value: "existing-folder" },
+      { name: "3. D\u1EF1 \xE1n m\u1EDBi ho\xE0n to\xE0n", value: "new-project" }
     ]
   });
 }
-async function runInitInternal(opts, ownerEmail) {
-  const projectRoot = process.cwd();
-  if (!await isGitRepo(projectRoot)) {
-    throw new Error("Mode internal c\u1EA7n d\u1EF1 \xE1n \u0111\xE3 l\xE0 git repo. Ch\u1EA1y 'git init' tr\u01B0\u1EDBc r\u1ED3i th\u1EED l\u1EA1i.");
-  }
-  if (await pathExists(join8(projectRoot, ".claude"))) {
-    throw new Error(
-      ".claude/ \u0111\xE3 t\u1ED3n t\u1EA1i. Avatar kh\xF4ng override. X\xF3a th\u1EE7 c\xF4ng ho\u1EB7c d\xF9ng mode kh\xE1c."
-    );
-  }
-  const teamOwner = await promptTeamOwner(ownerEmail);
-  const projectName = projectNameOf(projectRoot);
-  const projectDescription = await input({
-    message: "M\xF4 t\u1EA3 ng\u1EAFn 1 d\xF2ng c\u1EE7a d\u1EF1 \xE1n:",
-    default: `Avatar-managed project: ${projectName}`
+async function runInitFromExistingRemote(opts, ownerEmail) {
+  const remoteUrl = opts.clientRepo ?? await input({
+    message: "URL git c\u1EE7a repo:",
+    validate: (v) => v.length > 0 ? true : "URL b\u1EAFt bu\u1ED9c"
   });
-  const sp = spinner(`Th\xEAm submodule team-ai-pack t\u1EEB ${TEAM_PACK_REPO_URL}...`);
-  let pinnedTag = null;
-  try {
-    const result = await addTeamPackSubmodule(projectRoot, opts.packVersion);
-    pinnedTag = result.pinnedTag;
-    sp.succeed(`\u0110\xE3 pin team-ai-pack v\xE0o ${pinnedTag ?? "HEAD"}`);
-  } catch (err) {
-    sp.fail("Add submodule th\u1EA5t b\u1EA1i");
-    throw err;
-  }
-  const vars = buildScaffoldVariables({
-    projectName,
-    projectDescription,
+  await ensureGitHubReady(remoteUrl);
+  const teamOwner = opts.teamOwner ?? await promptTeamOwner(ownerEmail);
+  const inferredName = inferWorkspaceName(remoteUrl);
+  const workspaceName = opts.workspaceName ?? await input({ message: "T\xEAn workspace:", default: inferredName });
+  const workspaceParent = resolve(opts.workspaceParent ?? "..");
+  const workspacePath = await resolveWorkspacePath(workspaceParent, workspaceName, opts.force);
+  await scaffoldWorkspaceWithSrcSubmodule({
+    workspacePath,
+    workspaceName,
+    srcRemoteUrl: remoteUrl,
     teamOwner,
-    packVersion: pinnedTag ?? "HEAD",
-    mode: "internal"
+    description: opts.description ?? `Avatar workspace cho ${remoteUrl}`,
+    packVersion: opts.packVersion,
+    autoYes: opts.yes,
+    flow: "existing-remote"
   });
-  await createClaudeDirTree(projectRoot);
-  await writeProjectKnowledgeFiles(projectRoot, vars);
-  await writeRootClaudeMd(projectRoot, vars);
-  await writeProjectSettings(projectRoot, vars);
-  await appendGitignoreEntries(projectRoot);
-  await installGitHook(join8(projectRoot, ".git"), "post-merge");
-  log.success("C\xE0i git hook post-merge");
-  await appendAuditEntry("init", `mode=internal,project=${projectName}`);
-  await maybeCommit(projectRoot, "internal");
-  printInitSuccessBox(projectRoot, "internal");
-}
-async function runInitClientOrLibrary(opts, mode, ownerEmail) {
-  const teamOwner = await promptTeamOwner(ownerEmail);
-  const clientRepoUrl = opts.clientRepo ?? await input({
-    message: "URL git c\u1EE7a client repo:",
-    validate: (v) => v.length > 0 ? true : "URL b\u1EAFt bu\u1ED9c"
+}
+async function runInitFromExistingFolder(opts, ownerEmail) {
+  const folderPath = resolve(
+    opts.folderPath ?? await input({
+      message: "\u0110\u01B0\u1EDDng d\u1EABn folder hi\u1EC7n c\xF3:",
+      validate: (v) => v.length > 0 ? true : "Path b\u1EAFt bu\u1ED9c"
+    })
+  );
+  await bootstrapGitInFolder(folderPath);
+  const remoteUrl = await getOrCreateOriginRemote(folderPath, opts);
+  const teamOwner = opts.teamOwner ?? await promptTeamOwner(ownerEmail);
+  const inferredName = opts.workspaceName ?? `${basename(folderPath)}-avatar-workspace`;
+  const workspaceName = opts.workspaceName ?? await input({ message: "T\xEAn workspace:", default: inferredName });
+  const workspaceParent = resolve(opts.workspaceParent ?? "..");
+  const workspacePath = await resolveWorkspacePath(workspaceParent, workspaceName, opts.force);
+  await scaffoldWorkspaceWithSrcSubmodule({
+    workspacePath,
+    workspaceName,
+    srcRemoteUrl: remoteUrl ?? folderPath,
+    // fallback local path nếu user từ chối tạo remote
+    teamOwner,
+    description: opts.description ?? `Avatar workspace cho folder ${folderPath}`,
+    packVersion: opts.packVersion,
+    autoYes: opts.yes,
+    flow: "existing-folder"
   });
-  const inferredName = inferWorkspaceName(clientRepoUrl);
-  const workspaceName = opts.workspaceName ?? await input({
-    message: "T\xEAn workspace:",
-    default: inferredName
+}
+async function runInitFromScratch(opts, ownerEmail) {
+  await ensureGitHubReady();
+  const projectName = opts.workspaceName ?? await input({
+    message: "T\xEAn d\u1EF1 \xE1n:",
+    validate: (v) => v.length > 0 ? true : "T\xEAn b\u1EAFt bu\u1ED9c"
   });
-  const workspaceParent = resolve(opts.workspaceParent ?? "..");
-  const workspacePath = join8(workspaceParent, workspaceName);
-  if (await pathExists(workspacePath)) {
-    throw new Error(`Workspace path \u0111\xE3 t\u1ED3n t\u1EA1i: ${workspacePath}`);
-  }
+  const visibility = opts.repoVisibility ?? await select({
+    message: "Visibility?",
+    choices: [
+      { name: "private (m\u1EB7c \u0111\u1ECBnh)", value: "private" },
+      { name: "public", value: "public" }
+    ]
+  });
+  const teamOwner = opts.teamOwner ?? await promptTeamOwner(ownerEmail);
+  const workspaceParent = resolve(opts.workspaceParent ?? ".");
+  const workspacePath = await resolveWorkspacePath(workspaceParent, projectName, opts.force);
+  const srcPath = join13(workspacePath, "src");
   await ensureDir(workspacePath);
+  await ensureDir(srcPath);
+  await bootstrapGitInFolder(srcPath);
+  const urls = createGithubRemoteFromFolder({
+    folder: srcPath,
+    name: projectName,
+    visibility,
+    org: opts.repoOrg
+  });
   await git(workspacePath).init();
-  const sp = spinner("Add submodule client repo + team-ai-pack...");
+  const sp = spinner("Add submodule src/ + team-ai-pack...");
   try {
-    await git(workspacePath).subModule(["add", clientRepoUrl, "src"]);
+    await git(workspacePath).subModule(["add", urls.sshUrl, "src"]);
     const result = await addTeamPackSubmodule(workspacePath, opts.packVersion);
-    sp.succeed(`Workspace pin team-ai-pack v\xE0o ${result.pinnedTag ?? "HEAD"}`);
-    const vars = buildScaffoldVariables({
-      projectName: workspaceName,
-      projectDescription: `Avatar ${mode} workspace for ${clientRepoUrl}`,
+    sp.succeed(`Pin team-ai-pack v\xE0o ${result.pinnedTag ?? "HEAD"}`);
+    await finalizeWorkspaceScaffold({
+      workspacePath,
+      workspaceName: projectName,
       teamOwner,
+      description: opts.description ?? `D\u1EF1 \xE1n m\u1EDBi: ${projectName}`,
       packVersion: result.pinnedTag ?? "HEAD",
-      mode
+      autoYes: opts.yes,
+      flow: "new-project"
     });
-    await createClaudeDirTree(workspacePath);
-    await writeProjectKnowledgeFiles(workspacePath, vars);
-    await writeRootClaudeMd(workspacePath, vars);
-    await writeProjectSettings(workspacePath, vars);
-    await appendGitignoreEntries(workspacePath);
-    await ensureDir(join8(workspacePath, "notes"));
-    await ensureDir(join8(workspacePath, "scripts"));
-    await installGitHook(join8(workspacePath, ".git"), "post-merge");
-    await installGitHook(join8(workspacePath, "src", ".git"), "pre-push");
-    log.success("C\xE0i post-merge (workspace) + pre-push (src/)");
-    await appendAuditEntry("init", `mode=${mode},workspace=${workspaceName}`);
-    await maybeCommitWorkspace(workspacePath);
-    printInitSuccessBox(workspacePath, mode);
   } catch (err) {
     sp.fail("Init workspace th\u1EA5t b\u1EA1i");
     throw err;
   }
 }
-function projectNameOf(projectRoot) {
-  return projectRoot.split("/").filter(Boolean).pop() ?? "avatar-project";
-}
-function inferWorkspaceName(repoUrl) {
-  const m = repoUrl.match(/[/:]([^/]+?)(\.git)?$/);
-  const base = m?.[1] ?? "client";
-  return `avatar-${base}-workspace`;
-}
-async function promptTeamOwner(currentUserEmail) {
-  return await input({
-    message: "Team owner email:",
-    default: currentUserEmail
+async function getOrCreateOriginRemote(folderPath, opts) {
+  const remotes = await git(folderPath).getRemotes(true);
+  const origin = remotes.find((r) => r.name === "origin");
+  if (origin?.refs.push) {
+    log.success(`Folder \u0111\xE3 c\xF3 remote origin: ${origin.refs.push}`);
+    return origin.refs.push;
+  }
+  const shouldCreate = opts.createRemote ?? await confirm({
+    message: "Folder ch\u01B0a c\xF3 remote. T\u1EA1o GitHub repo ngay \u0111\u1EC3 share team?",
+    default: true
+  });
+  if (!shouldCreate) {
+    log.warn("Ti\u1EBFp t\u1EE5c v\u1EDBi local path. Workspace ch\u1EC9 ch\u1EA1y \u0111\u01B0\u1EE3c tr\xEAn m\xE1y b\u1EA1n.");
+    return void 0;
+  }
+  await ensureGitHubReady();
+  const visibility = opts.repoVisibility ?? await select({
+    message: "Visibility?",
+    choices: [
+      { name: "private (m\u1EB7c \u0111\u1ECBnh)", value: "private" },
+      { name: "public", value: "public" }
+    ]
+  });
+  const repoName = await input({
+    message: "T\xEAn repo:",
+    default: basename(folderPath)
+  });
+  const urls = createGithubRemoteFromFolder({
+    folder: folderPath,
+    name: repoName,
+    visibility,
+    org: opts.repoOrg
   });
+  return urls.sshUrl;
 }
-function buildScaffoldVariables(args) {
-  return {
-    projectName: args.projectName,
-    projectDescription: args.projectDescription,
+async function scaffoldWorkspaceWithSrcSubmodule(args) {
+  await ensureDir(args.workspacePath);
+  await git(args.workspacePath).init();
+  const sp = spinner("Add submodule src/ + team-ai-pack...");
+  try {
+    await git(args.workspacePath).subModule(["add", args.srcRemoteUrl, "src"]);
+    const result = await addTeamPackSubmodule(args.workspacePath, args.packVersion);
+    sp.succeed(`Pin team-ai-pack v\xE0o ${result.pinnedTag ?? "HEAD"}`);
+    await finalizeWorkspaceScaffold({
+      workspacePath: args.workspacePath,
+      workspaceName: args.workspaceName,
+      teamOwner: args.teamOwner,
+      description: args.description,
+      packVersion: result.pinnedTag ?? "HEAD",
+      autoYes: args.autoYes,
+      flow: args.flow
+    });
+  } catch (err) {
+    sp.fail("Init workspace th\u1EA5t b\u1EA1i");
+    throw err;
+  }
+}
+async function finalizeWorkspaceScaffold(args) {
+  const vars = buildScaffoldVariables({
+    projectName: args.workspaceName,
+    projectDescription: args.description,
     teamOwner: args.teamOwner,
-    avatarVersion: AVATAR_CLI_VERSION,
     packVersion: args.packVersion,
-    lastScan: (/* @__PURE__ */ new Date()).toISOString(),
-    mode: args.mode
-  };
-}
-async function maybeCommit(projectRoot, mode) {
-  const wantCommit = await confirm({
-    message: "Commit ngay c\xE1c file Avatar \u0111\xE3 t\u1EA1o?",
-    default: true
-  });
-  if (!wantCommit) return;
-  const g = git(projectRoot);
-  await g.add([".claude/", "CLAUDE.md", ".gitignore", ".gitmodules"]);
-  await g.commit(`chore: initialize Avatar in ${mode} mode`);
-  log.success("\u0110\xE3 commit");
-}
-async function maybeCommitWorkspace(workspacePath) {
-  const wantCommit = await confirm({
-    message: "Commit workspace ngay?",
-    default: true
+    mode: "client"
   });
+  await createClaudeDirTree(args.workspacePath);
+  await writeProjectKnowledgeFiles(args.workspacePath, vars);
+  await writeRootClaudeMd(args.workspacePath, vars);
+  await writeProjectSettings(args.workspacePath, vars);
+  await appendGitignoreEntries(args.workspacePath);
+  await ensureDir(join13(args.workspacePath, "notes"));
+  await ensureDir(join13(args.workspacePath, "scripts"));
+  await installGitHook(join13(args.workspacePath, ".git"), "post-merge");
+  await installGitHook(join13(args.workspacePath, ".git", "modules", "src"), "pre-push");
+  log.success("C\xE0i post-merge (workspace) + pre-push (src/)");
+  await appendAuditEntry("init", `flow=${args.flow},workspace=${args.workspaceName}`);
+  await maybeCommitWorkspace(args.workspacePath, args.autoYes);
+  printInitSuccessBox(args.workspacePath, args.flow);
+}
+async function resolveWorkspacePath(parent, desiredName, force) {
+  const desired = join13(parent, desiredName);
+  if (await isEmptyOrMissing(desired)) return desired;
+  const alternative = await findAlternativeWorkspaceName(parent, desiredName);
+  if (!alternative) {
+    throw new Error(`Kh\xF4ng t\xECm \u0111\u01B0\u1EE3c workspace path kh\u1EA3 d\u1EE5ng trong ${parent}`);
+  }
+  log.warn(`Workspace path "${desired}" \u0111\xE3 c\xF3 n\u1ED9i dung.`);
+  if (force) {
+    log.info(`--force: d\xF9ng ${alternative}`);
+    return alternative;
+  }
+  const useAlt = await confirm({ message: `D\xF9ng "${alternative}" thay th\u1EBF?`, default: true });
+  if (!useAlt) throw new Error("H\u1EE7y init. Ch\u1EA1y l\u1EA1i v\u1EDBi --workspace-name kh\xE1c.");
+  return alternative;
+}
+async function promptTeamOwner(currentUserEmail) {
+  return await input({ message: "Team owner email:", default: currentUserEmail });
+}
+async function maybeCommitWorkspace(workspacePath, autoYes) {
+  const wantCommit = autoYes ?? await confirm({ message: "Commit workspace ngay?", default: true });
   if (!wantCommit) return;
   const g = git(workspacePath);
   await g.add(["CLAUDE.md", ".claude/", ".gitignore", ".gitmodules", "notes/", "scripts/"]);
-  await g.commit("chore: initialize Avatar workspace for client");
+  await g.commit("chore: initialize Avatar workspace");
   log.success("\u0110\xE3 commit workspace");
 }
-function printInitSuccessBox(rootPath, mode) {
-  const lines = [];
-  if (mode === "internal") {
-    lines.push(`${chalk.green("\u2713")} Avatar \u0111\xE3 s\u1EB5n s\xE0ng trong d\u1EF1 \xE1n`);
-    lines.push("");
-    lines.push(`  ${chalk.cyan("claude")}                    M\u1EDF Claude Code`);
-    lines.push(`  ${chalk.cyan("avatar status")}             Xem snapshot`);
-    lines.push(`  ${chalk.cyan("avatar sync")}               Pull team-ai-pack m\u1EDBi`);
-  } else {
-    lines.push(`${chalk.green("\u2713")} Workspace s\u1EB5n s\xE0ng: ${rootPath}`);
-    lines.push("");
-    lines.push(`  ${chalk.cyan(`cd ${rootPath}`)}`);
-    lines.push(`  ${chalk.cyan("claude")}                    M\u1EDF Claude Code \u1EDF workspace root`);
-    lines.push("");
-    lines.push(`  ${chalk.cyan("avatar commit --src")}       Commit code kh\xE1ch l\xEAn client remote`);
-    lines.push(
-      `  ${chalk.cyan("avatar commit --avatar")}    Commit Avatar state l\xEAn workspace remote`
-    );
-    lines.push(`  ${chalk.cyan("avatar sync")}               Sync team pack`);
-  }
+function printInitSuccessBox(rootPath, flow) {
+  const lines = [
+    `${chalk.green("\u2713")} Workspace s\u1EB5n s\xE0ng: ${relative2(process.cwd(), rootPath) || rootPath}`,
+    `  ${chalk.dim(`(flow: ${flow})`)}`,
+    "",
+    `  ${chalk.cyan(`cd ${rootPath}`)}`,
+    `  ${chalk.cyan("claude")}                    M\u1EDF Claude Code \u1EDF workspace root`,
+    "",
+    `  ${chalk.cyan("avatar commit --src")}       Commit code l\xEAn remote src`,
+    `  ${chalk.cyan("avatar commit --avatar")}    Commit Avatar state`,
+    `  ${chalk.cyan("avatar sync")}               Pull team-ai-pack m\u1EDBi`,
+    `  ${chalk.cyan("avatar uninstall")}          G\u1EE1 Avatar (gi\u1EEF code)`
+  ];
   process.stdout.write(`${boxen2(lines.join("\n"), { padding: 1, borderStyle: "round" })}
 `);
 }
@@ -804,6 +1332,7 @@ function registerLoginCommand(program2) {
   });
 }
 async function runLogin(opts) {
+  printAvatarBanner({ tagline: "\u0110\u0103ng nh\u1EADp Google SSO \xB7 workspace @nal.vn" });
   if (opts.reset) {
     await clearUserConfig();
     await appendAuditEntry("login_reset");
@@ -904,22 +1433,22 @@ function registerSecretsCommand(program2) {
 
 // src/commands/status.ts
 import { promises as fs6 } from "fs";
-import { join as join10 } from "path";
+import { join as join15 } from "path";
 import boxen4 from "boxen";
 
 // src/lib/pack-backup-manager.ts
 import { promises as fs5 } from "fs";
-import { join as join9 } from "path";
+import { join as join14 } from "path";
 var BACKUP_DIR_NAME = "_backup";
 async function listBackups(projectRoot) {
-  const dir = join9(projectRoot, ".claude", BACKUP_DIR_NAME);
+  const dir = join14(projectRoot, ".claude", BACKUP_DIR_NAME);
   if (!await pathExists(dir)) return [];
   const entries = await fs5.readdir(dir, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
 }
 
 // src/commands/status.ts
-var AVATAR_CLI_VERSION2 = "1.0.0";
+var AVATAR_CLI_VERSION2 = "1.0.1";
 function registerStatusCommand(program2) {
   program2.command("status").description("Snapshot t\u1EE9c th\xEC: project, pack version, pending, backup").option("--json", "Output JSON cho script").action(async (opts) => {
     try {
@@ -938,7 +1467,7 @@ function registerStatusCommand(program2) {
 }
 async function gatherStatus(cwd) {
   const projectName = cwd.split("/").filter(Boolean).pop() ?? "unknown";
-  const claudeRoot = join10(cwd, ".claude");
+  const claudeRoot = join15(cwd, ".claude");
   const hasAvatar = await pathExists(claudeRoot);
   if (!hasAvatar) {
     return {
@@ -951,8 +1480,8 @@ async function gatherStatus(cwd) {
       hasAvatar: false
     };
   }
-  const packVersion = await isGitRepo(join10(claudeRoot, "pack")) ? await readPinnedPackVersion(cwd).catch(() => null) : null;
-  const pendingDir = join10(claudeRoot, "_pending");
+  const packVersion = await isGitRepo(join15(claudeRoot, "pack")) ? await readPinnedPackVersion(cwd).catch(() => null) : null;
+  const pendingDir = join15(claudeRoot, "_pending");
   const pendingCount = await pathExists(pendingDir) ? (await fs6.readdir(pendingDir)).filter((n) => n.endsWith(".diff.md")).length : 0;
   const backupCount = (await listBackups(cwd)).length;
   const techStackSummary = await readTechStackFirstLine(claudeRoot);
@@ -967,7 +1496,7 @@ async function gatherStatus(cwd) {
   };
 }
 async function readTechStackFirstLine(claudeRoot) {
-  const techStackPath = join10(claudeRoot, "project", "tech-stack.md");
+  const techStackPath = join15(claudeRoot, "project", "tech-stack.md");
   if (!await pathExists(techStackPath)) return "(no tech-stack.md)";
   const content = await readText(techStackPath);
   const firstNonHeaderLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#") && !l.startsWith(">"));
@@ -1000,10 +1529,259 @@ function registerToolsCommand(program2) {
   tools.command("remove <tool-id>").description("G\u1EE1 tool kh\u1ECFi ~/.claude.json (optional uninstall binary)").option("--keep-secrets", "Kh\xF4ng x\xF3a secrets kh\u1ECFi keychain").option("--keep-binary", "Kh\xF4ng uninstall npm global binary").action(notImplementedYet("tools remove", "Milestone 09"));
 }
 
+// src/commands/uninstall.ts
+import { relative as relative3 } from "path";
+import { confirm as confirm2 } from "@inquirer/prompts";
+import boxen5 from "boxen";
+
+// src/lib/create-uninstall-backup-snapshot.ts
+import { cp, mkdir, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join16 } from "path";
+var UNINSTALL_BACKUPS_DIR = join16(homedir2(), ".avatar", "uninstall-backups");
+async function createUninstallBackupSnapshot(projectRoot, artifacts, avatarVersion) {
+  const projectName = basename2(projectRoot);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupDir = join16(UNINSTALL_BACKUPS_DIR, `${projectName}-${timestamp}`);
+  await mkdir(backupDir, { recursive: true, mode: 448 });
+  if (artifacts.claudeDir) {
+    await cp(artifacts.claudeDir, join16(backupDir, ".claude"), { recursive: true });
+  }
+  if (artifacts.claudeMd) {
+    await cp(artifacts.claudeMd, join16(backupDir, "CLAUDE.md"));
+  }
+  if (artifacts.postMergeHook || artifacts.prePushHook) {
+    const hooksBackupDir = join16(backupDir, "hooks");
+    await mkdir(hooksBackupDir, { recursive: true });
+    if (artifacts.postMergeHook) {
+      await cp(artifacts.postMergeHook, join16(hooksBackupDir, "post-merge"));
+    }
+    if (artifacts.prePushHook) {
+      await cp(artifacts.prePushHook, join16(hooksBackupDir, "pre-push"));
+    }
+  }
+  const manifest = {
+    projectName,
+    projectPath: projectRoot,
+    timestamp,
+    avatarVersion,
+    artifacts: {
+      claudeDir: !!artifacts.claudeDir,
+      claudeMd: !!artifacts.claudeMd,
+      postMergeHook: !!artifacts.postMergeHook,
+      prePushHook: !!artifacts.prePushHook
+    }
+  };
+  await writeFile(join16(backupDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+  return backupDir;
+}
+
+// src/lib/detect-avatar-project-artifacts.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join17 } from "path";
+function existsOrNull(path) {
+  return existsSync5(path) ? path : null;
+}
+function detectAvatarProjectArtifacts(projectRoot) {
+  const claudeDir = existsOrNull(join17(projectRoot, ".claude"));
+  const claudeMd = existsOrNull(join17(projectRoot, "CLAUDE.md"));
+  const postMergeHook = existsOrNull(join17(projectRoot, ".git", "hooks", "post-merge"));
+  const prePushHook = existsOrNull(
+    join17(projectRoot, ".git", "modules", "src", "hooks", "pre-push")
+  );
+  const gitignorePath = existsOrNull(join17(projectRoot, ".gitignore"));
+  const gitmodulesPath = existsOrNull(join17(projectRoot, ".gitmodules"));
+  const notesDir = existsOrNull(join17(projectRoot, "notes"));
+  const scriptsDir = existsOrNull(join17(projectRoot, "scripts"));
+  const hasAnyArtifact = !!(claudeDir || claudeMd || postMergeHook || prePushHook);
+  return {
+    hasAnyArtifact,
+    claudeDir,
+    claudeMd,
+    postMergeHook,
+    prePushHook,
+    gitignorePath,
+    gitmodulesPath,
+    notesDir,
+    scriptsDir
+  };
+}
+
+// src/lib/execute-uninstall-deletion.ts
+import { readFile, rm, writeFile as writeFile2 } from "fs/promises";
+async function executeUninstallDeletion(artifacts, flags) {
+  if (artifacts.claudeDir) {
+    if (flags.keepSubmodule) {
+      const { readdir: readdir2 } = await import("fs/promises");
+      const { join: join18 } = await import("path");
+      const entries = await readdir2(artifacts.claudeDir);
+      for (const entry of entries) {
+        if (entry === "pack") continue;
+        await rm(join18(artifacts.claudeDir, entry), { recursive: true, force: true });
+      }
+    } else {
+      await rm(artifacts.claudeDir, { recursive: true, force: true });
+    }
+  }
+  if (artifacts.claudeMd) {
+    await rm(artifacts.claudeMd, { force: true });
+  }
+  if (!flags.keepHooks) {
+    if (artifacts.postMergeHook) await rm(artifacts.postMergeHook, { force: true });
+    if (artifacts.prePushHook) await rm(artifacts.prePushHook, { force: true });
+  }
+  if (artifacts.gitignorePath) {
+    await stripAvatarBlockFromGitignore(artifacts.gitignorePath);
+  }
+  if (artifacts.gitmodulesPath && !flags.keepSubmodule) {
+    await removeSubmoduleEntry(artifacts.gitmodulesPath, ".claude/pack");
+  }
+  for (const dir of [artifacts.notesDir, artifacts.scriptsDir]) {
+    if (!dir) continue;
+    const { readdir: readdir2 } = await import("fs/promises");
+    const entries = await readdir2(dir);
+    if (entries.length === 0) {
+      await rm(dir, { recursive: true, force: true });
+    }
+  }
+}
+async function stripAvatarBlockFromGitignore(path) {
+  const content = await readFile(path, "utf8");
+  const startIdx = content.indexOf(AVATAR_MARKER_START);
+  const endIdx = content.indexOf(AVATAR_MARKER_END);
+  if (startIdx === -1 || endIdx === -1) return;
+  const before = content.slice(0, startIdx);
+  const after = content.slice(endIdx + AVATAR_MARKER_END.length);
+  const cleaned = `${before.trimEnd()}
+${after.trimStart()}`.trim();
+  if (cleaned.length === 0) {
+    await rm(path, { force: true });
+  } else {
+    await writeFile2(path, `${cleaned}
+`, "utf8");
+  }
+}
+async function removeSubmoduleEntry(gitmodulesPath, submodulePath) {
+  const content = await readFile(gitmodulesPath, "utf8");
+  const lines = content.split("\n");
+  const result = [];
+  let skip = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("[submodule") && line.includes(submodulePath)) {
+      skip = true;
+      continue;
+    }
+    if (skip && line.trim().startsWith("[submodule")) {
+      skip = false;
+    }
+    if (!skip) result.push(line);
+  }
+  const cleaned = result.join("\n").trim();
+  if (cleaned.length === 0) {
+    await rm(gitmodulesPath, { force: true });
+  } else {
+    await writeFile2(gitmodulesPath, `${cleaned}
+`, "utf8");
+  }
+}
+
+// src/commands/uninstall.ts
+var CLI_VERSION = "1.1.0";
+function registerUninstallCommand(program2) {
+  program2.command("uninstall").description("G\u1EE1 Avatar kh\u1ECFi project \u2014 backup t\u1EF1 \u0111\u1ED9ng (M11)").option("--yes", "Skip confirm prompt").option("--no-backup", "Kh\xF4ng t\u1EA1o backup tr\u01B0\u1EDBc khi x\xF3a (nguy hi\u1EC3m)").option("--keep-submodule", "Gi\u1EEF submodule .claude/pack/").option("--keep-hooks", "Gi\u1EEF git hooks post-merge, pre-push").option("--dry-run", "Hi\u1EC3n th\u1ECB danh s\xE1ch s\u1EBD x\xF3a, kh\xF4ng th\u1EF1c thi").action(async (opts) => {
+    try {
+      await runUninstall(opts);
+    } catch (err) {
+      log.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+}
+async function runUninstall(opts) {
+  const projectRoot = process.cwd();
+  const artifacts = detectAvatarProjectArtifacts(projectRoot);
+  if (!artifacts.hasAnyArtifact) {
+    log.info("Project ch\u01B0a c\xE0i Avatar \u2014 kh\xF4ng c\xF3 g\xEC \u0111\u1EC3 g\u1EE1.");
+    return;
+  }
+  printUninstallSummary(projectRoot, artifacts, opts);
+  if (opts.dryRun) {
+    log.dim("--dry-run: k\u1EBFt th\xFAc, kh\xF4ng x\xF3a.");
+    return;
+  }
+  if (!opts.yes) {
+    const ok = await confirm2({
+      message: "Ti\u1EBFp t\u1EE5c g\u1EE1 Avatar?",
+      default: false
+    });
+    if (!ok) {
+      log.info("\u0110\xE3 h\u1EE7y.");
+      return;
+    }
+  }
+  let backupPath = null;
+  if (!opts.noBackup) {
+    backupPath = await createUninstallBackupSnapshot(projectRoot, artifacts, CLI_VERSION);
+    log.success(`Backup t\u1EA1o t\u1EA1i: ${backupPath}`);
+  }
+  await executeUninstallDeletion(artifacts, {
+    keepSubmodule: opts.keepSubmodule,
+    keepHooks: opts.keepHooks
+  });
+  await appendAuditEntry("uninstall", `project=${projectRoot},backup=${backupPath ?? "skipped"}`);
+  printUninstallSuccessBox(backupPath);
+}
+function printUninstallSummary(projectRoot, artifacts, opts) {
+  log.info(`Project: ${projectRoot}`);
+  log.plain("");
+  log.plain("C\xE1c artifact s\u1EBD g\u1EE1:");
+  if (artifacts.claudeDir)
+    log.plain(`  ${chalk.red("\u2717")} ${relative3(projectRoot, artifacts.claudeDir) || ".claude/"}`);
+  if (artifacts.claudeMd) log.plain(`  ${chalk.red("\u2717")} CLAUDE.md`);
+  if (artifacts.postMergeHook && !opts.keepHooks) {
+    log.plain(`  ${chalk.red("\u2717")} .git/hooks/post-merge`);
+  }
+  if (artifacts.prePushHook && !opts.keepHooks) {
+    log.plain(`  ${chalk.red("\u2717")} .git/modules/src/hooks/pre-push`);
+  }
+  if (artifacts.gitignorePath) log.plain(`  ${chalk.yellow("\u270E")} .gitignore (g\u1EE1 Avatar block)`);
+  if (artifacts.gitmodulesPath && !opts.keepSubmodule) {
+    log.plain(`  ${chalk.yellow("\u270E")} .gitmodules (g\u1EE1 entry .claude/pack)`);
+  }
+  log.plain("");
+  log.plain("Kh\xF4ng \u0111\u1EE5ng:");
+  log.plain(`  ${chalk.green("\u2713")} src/ (code kh\xE1ch)`);
+  log.plain(`  ${chalk.green("\u2713")} Git history`);
+  log.plain(`  ${chalk.green("\u2713")} ~/.avatar/config.json (token SSO)`);
+  log.plain(`  ${chalk.green("\u2713")} Secrets trong keychain`);
+  log.plain("");
+}
+function printUninstallSuccessBox(backupPath) {
+  const lines = [`${chalk.green("\u2713")} Avatar \u0111\xE3 \u0111\u01B0\u1EE3c g\u1EE1 kh\u1ECFi project`];
+  if (backupPath) {
+    lines.push("");
+    lines.push(`  ${chalk.dim("Backup:")} ${backupPath}`);
+    lines.push(`  ${chalk.dim("Restore:")} ${chalk.cyan(`cp -r "${backupPath}"/* .`)}`);
+  }
+  process.stdout.write(`${boxen5(lines.join("\n"), { padding: 1, borderStyle: "round" })}
+`);
+}
+
 // src/index.ts
-var CLI_VERSION = "1.0.0";
+var CLI_VERSION2 = "1.1.0";
 var program = new Command();
-program.name("avatar").description("AI harness CLI for NAL Vietnam engineering").version(CLI_VERSION, "-v, --version", "Hi\u1EC3n th\u1ECB phi\xEAn b\u1EA3n Avatar CLI");
+program.name("avatar").description("AI harness CLI for NAL Vietnam engineering").version(CLI_VERSION2, "-v, --version", "Hi\u1EC3n th\u1ECB phi\xEAn b\u1EA3n Avatar CLI").addHelpText(
+  "beforeAll",
+  () => `
+${renderAvatarBanner({ tagline: `v${CLI_VERSION2} \xB7 AI harness CLI for NAL Vietnam` })}
+
+`
+);
+var isVersionCall = process.argv.includes("-v") || process.argv.includes("--version");
+if (isVersionCall) {
+  printAvatarBanner({ tagline: `v${CLI_VERSION2} \xB7 AI harness CLI for NAL Vietnam` });
+  process.exit(0);
+}
 registerLoginCommand(program);
 registerInitCommand(program);
 registerSyncCommand(program);
@@ -1016,6 +1794,7 @@ registerCommitCommand(program);
 registerToolsCommand(program);
 registerSecretsCommand(program);
 registerMcpRunCommand(program);
+registerUninstallCommand(program);
 program.parseAsync(process.argv).catch((err) => {
   const msg = err instanceof Error ? err.message : String(err);
   process.stderr.write(`\u2717 L\u1ED7i kh\xF4ng x\u1EED l\xFD \u0111\u01B0\u1EE3c: ${msg}