@aipper/aiws 0.0.1

package/src/commands/codex-install-prompts.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { loadTemplate } from "../spec.js";
+import { UserError } from "../errors.js";
+import { copyFile, ensureDir, pathExists, readText, writeText } from "../fs.js";
+import { normalizeNewlines } from "../hash.js";
+import { findManagedBlock, upsertManagedBlock } from "../managed-blocks.js";
+import { codexBackupPathFor, codexBackupStamp, listTemplateCodexPrompts, resolveCodexPromptsDir } from "../codex-prompts.js";
+
+/**
+ * @param {{ templateId: string, promptsDir?: string, force?: boolean, dryRun?: boolean }} options
+ */
+export async function codexInstallPromptsCommand(options) {
+  const templateId = String(options.templateId || "workspace");
+  const tpl = await loadTemplate(templateId);
+
+  const promptsDir = resolveCodexPromptsDir(options.promptsDir);
+  const dryRun = options.dryRun === true;
+  if (!dryRun) await ensureDir(promptsDir);
+
+  const promptFiles = await listTemplateCodexPrompts(tpl);
+
+  /** @type {string[]} */
+  const created = [];
+  /** @type {string[]} */
+  const updated = [];
+  /** @type {string[]} */
+  const overwritten = [];
+  let backupStamp = "";
+
+  for (const pf of promptFiles) {
+    const { filename, blockId, templateText, innerText } = pf;
+    const destAbs = path.join(promptsDir, filename);
+    if (!(await pathExists(destAbs))) {
+      if (!dryRun) await writeText(destAbs, templateText);
+      created.push(filename);
+      continue;
+    }
+
+    const currentText = normalizeNewlines(await readText(destAbs));
+    const existingBlock = findManagedBlock(currentText, blockId);
+    if (!existingBlock) {
+      if (!options.force) {
+        throw new UserError("Codex prompt file exists and is not AIWS-managed; refusing to overwrite.", {
+          details: `File: ${destAbs}\nHint: re-run with --force to overwrite (a backup will be created).`,
+        });
+      }
+      if (!backupStamp) backupStamp = codexBackupStamp();
+      const backup = codexBackupPathFor(promptsDir, filename, backupStamp);
+      if (!dryRun) {
+        await copyFile(destAbs, backup);
+        await writeText(destAbs, templateText);
+      }
+      overwritten.push(filename);
+      continue;
+    }
+
+    const res = upsertManagedBlock(currentText, blockId, innerText, { insertIfMissing: false });
+    if (res.changed) {
+      if (!dryRun) await writeText(destAbs, res.nextText);
+      updated.push(filename);
+    }
+  }
+
+  console.log(`${dryRun ? "✓ (dry-run)" : "✓"} aiws codex install-prompts: ${promptsDir}`);
+  if (created.length > 0) console.log(`created: ${created.join(", ")}`);
+  if (updated.length > 0) console.log(`updated: ${updated.join(", ")}`);
+  if (overwritten.length > 0) console.log(`overwritten: ${overwritten.join(", ")}`);
+}

package/src/commands/codex-install-skills.js

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { loadTemplate } from "../spec.js";
+import { UserError } from "../errors.js";
+import { copyFile, ensureDir, pathExists, readText, writeText } from "../fs.js";
+import { normalizeNewlines } from "../hash.js";
+import { findManagedBlock, upsertManagedBlock } from "../managed-blocks.js";
+import { codexSkillsBackupPathFor, codexSkillsBackupStamp, listTemplateCodexSkills, resolveCodexSkillsDir } from "../codex-skills.js";
+
+/**
+ * @param {{ templateId: string, skillsDir?: string, force?: boolean, dryRun?: boolean }} options
+ */
+export async function codexInstallSkillsCommand(options) {
+  const templateId = String(options.templateId || "workspace");
+  const tpl = await loadTemplate(templateId);
+
+  const skillsDir = resolveCodexSkillsDir(options.skillsDir);
+  const dryRun = options.dryRun === true;
+  if (!dryRun) await ensureDir(skillsDir);
+
+  const skillFiles = await listTemplateCodexSkills(tpl);
+
+  /** @type {string[]} */
+  const created = [];
+  /** @type {string[]} */
+  const updated = [];
+  /** @type {string[]} */
+  const overwritten = [];
+  let backupStamp = "";
+
+  for (const sf of skillFiles) {
+    const destAbs = path.join(skillsDir, sf.skillName, "SKILL.md");
+    if (!(await pathExists(destAbs))) {
+      if (!dryRun) await writeText(destAbs, sf.managedText);
+      created.push(sf.skillName);
+      continue;
+    }
+
+    const currentText = normalizeNewlines(await readText(destAbs));
+    const existingBlock = findManagedBlock(currentText, sf.blockId);
+    if (!existingBlock) {
+      if (!options.force) {
+        throw new UserError("Codex skill exists and is not AIWS-managed; refusing to overwrite.", {
+          details: `File: ${destAbs}\nHint: re-run with --force to overwrite (a backup will be created).`,
+        });
+      }
+      if (!backupStamp) backupStamp = codexSkillsBackupStamp();
+      const backup = codexSkillsBackupPathFor(skillsDir, sf.skillName, backupStamp);
+      if (!dryRun) {
+        await copyFile(destAbs, backup);
+        await writeText(destAbs, sf.managedText);
+      }
+      overwritten.push(sf.skillName);
+      continue;
+    }
+
+    const res = upsertManagedBlock(currentText, sf.blockId, sf.innerText, { insertIfMissing: false });
+    if (res.changed) {
+      if (!dryRun) await writeText(destAbs, res.nextText);
+      updated.push(sf.skillName);
+    }
+  }
+
+  console.log(`${dryRun ? "✓ (dry-run)" : "✓"} aiws codex install-skills: ${skillsDir}`);
+  if (created.length > 0) console.log(`created: ${created.join(", ")}`);
+  if (updated.length > 0) console.log(`updated: ${updated.join(", ")}`);
+  if (overwritten.length > 0) console.log(`overwritten: ${overwritten.join(", ")}`);
+}
+

package/src/commands/codex-status-prompts.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import { loadTemplate } from "../spec.js";
+import { normalizeNewlines } from "../hash.js";
+import { findManagedBlock } from "../managed-blocks.js";
+import { pathExists, readText } from "../fs.js";
+import { listTemplateCodexPrompts, resolveCodexPromptsDir } from "../codex-prompts.js";
+
+/**
+ * @param {{ templateId: string, promptsDir?: string }} options
+ */
+export async function codexStatusPromptsCommand(options) {
+  const templateId = String(options.templateId || "workspace");
+  const tpl = await loadTemplate(templateId);
+
+  const promptsDir = resolveCodexPromptsDir(options.promptsDir);
+  const promptFiles = await listTemplateCodexPrompts(tpl);
+
+  /** @type {Array<{ filename: string, status: "ok" | "missing" | "unmanaged" | "outdated" }>} */
+  const rows = [];
+
+  for (const pf of promptFiles) {
+    const destAbs = path.join(promptsDir, pf.filename);
+    if (!(await pathExists(destAbs))) {
+      rows.push({ filename: pf.filename, status: "missing" });
+      continue;
+    }
+
+    const currentText = normalizeNewlines(await readText(destAbs));
+    const block = findManagedBlock(currentText, pf.blockId);
+    if (!block) {
+      rows.push({ filename: pf.filename, status: "unmanaged" });
+      continue;
+    }
+
+    rows.push({ filename: pf.filename, status: block.innerText === pf.innerText ? "ok" : "outdated" });
+  }
+
+  const counts = rows.reduce(
+    (acc, r) => {
+      acc[r.status]++;
+      return acc;
+    },
+    /** @type {{ ok: number, missing: number, unmanaged: number, outdated: number }} */ ({ ok: 0, missing: 0, unmanaged: 0, outdated: 0 }),
+  );
+
+  console.log(`✓ aiws codex status: ${promptsDir}`);
+  console.log(`ok=${counts.ok} missing=${counts.missing} unmanaged=${counts.unmanaged} outdated=${counts.outdated}`);
+  for (const r of rows) {
+    console.log(`${r.status}\t${r.filename}`);
+  }
+  if (counts.missing > 0 || counts.outdated > 0) {
+    console.log("Next: aiws codex install-prompts");
+  }
+}
+

package/src/commands/codex-status-skills.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import { loadTemplate } from "../spec.js";
+import { normalizeNewlines } from "../hash.js";
+import { findManagedBlock } from "../managed-blocks.js";
+import { pathExists, readText } from "../fs.js";
+import { listTemplateCodexSkills, resolveCodexSkillsDir } from "../codex-skills.js";
+
+/**
+ * @param {{ templateId: string, skillsDir?: string }} options
+ */
+export async function codexStatusSkillsCommand(options) {
+  const templateId = String(options.templateId || "workspace");
+  const tpl = await loadTemplate(templateId);
+
+  const skillsDir = resolveCodexSkillsDir(options.skillsDir);
+  const skillFiles = await listTemplateCodexSkills(tpl);
+
+  /** @type {Array<{ name: string, status: "ok" | "missing" | "unmanaged" | "outdated" }>} */
+  const rows = [];
+
+  for (const sf of skillFiles) {
+    const destAbs = path.join(skillsDir, sf.skillName, "SKILL.md");
+    if (!(await pathExists(destAbs))) {
+      rows.push({ name: sf.skillName, status: "missing" });
+      continue;
+    }
+
+    const currentText = normalizeNewlines(await readText(destAbs));
+    const block = findManagedBlock(currentText, sf.blockId);
+    if (!block) {
+      rows.push({ name: sf.skillName, status: "unmanaged" });
+      continue;
+    }
+    rows.push({ name: sf.skillName, status: block.innerText === sf.innerText ? "ok" : "outdated" });
+  }
+
+  const counts = rows.reduce(
+    (acc, r) => {
+      acc[r.status]++;
+      return acc;
+    },
+    /** @type {{ ok: number, missing: number, unmanaged: number, outdated: number }} */ ({ ok: 0, missing: 0, unmanaged: 0, outdated: 0 }),
+  );
+
+  console.log(`✓ aiws codex status-skills: ${skillsDir}`);
+  console.log(`ok=${counts.ok} missing=${counts.missing} unmanaged=${counts.unmanaged} outdated=${counts.outdated}`);
+  for (const r of rows) {
+    console.log(`${r.status}\t${r.name}`);
+  }
+  if (counts.missing > 0 || counts.outdated > 0) {
+    console.log("Next: aiws codex install-skills");
+  }
+}
+

package/src/commands/codex-uninstall-prompts.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { loadTemplate } from "../spec.js";
+import { normalizeNewlines } from "../hash.js";
+import { findManagedBlock } from "../managed-blocks.js";
+import { copyFile, pathExists, readText } from "../fs.js";
+import { codexBackupPathFor, codexBackupStamp, listTemplateCodexPrompts, resolveCodexPromptsDir } from "../codex-prompts.js";
+
+/**
+ * @param {{ templateId: string, promptsDir?: string }} options
+ */
+export async function codexUninstallPromptsCommand(options) {
+  const templateId = String(options.templateId || "workspace");
+  const tpl = await loadTemplate(templateId);
+
+  const promptsDir = resolveCodexPromptsDir(options.promptsDir);
+  const promptFiles = await listTemplateCodexPrompts(tpl);
+
+  const backupStamp = codexBackupStamp();
+  const backupDir = path.join(promptsDir, ".aiws", "backups", "codex-prompts", backupStamp);
+
+  /** @type {string[]} */
+  const removed = [];
+  /** @type {string[]} */
+  const skippedUnmanaged = [];
+  /** @type {string[]} */
+  const missing = [];
+
+  for (const pf of promptFiles) {
+    const destAbs = path.join(promptsDir, pf.filename);
+    if (!(await pathExists(destAbs))) {
+      missing.push(pf.filename);
+      continue;
+    }
+
+    const currentText = normalizeNewlines(await readText(destAbs));
+    const block = findManagedBlock(currentText, pf.blockId);
+    if (!block) {
+      skippedUnmanaged.push(pf.filename);
+      continue;
+    }
+
+    const backup = codexBackupPathFor(promptsDir, pf.filename, backupStamp);
+    await copyFile(destAbs, backup);
+    await fs.unlink(destAbs);
+    removed.push(pf.filename);
+  }
+
+  console.log(`✓ aiws codex uninstall-prompts: ${promptsDir}`);
+  if (removed.length > 0) console.log(`removed: ${removed.join(", ")}`);
+  if (removed.length > 0) console.log(`backup: ${backupDir}`);
+  if (skippedUnmanaged.length > 0) console.log(`skipped (unmanaged): ${skippedUnmanaged.join(", ")}`);
+  if (missing.length > 0) console.log(`missing: ${missing.join(", ")}`);
+}
+

package/src/commands/codex-uninstall-skills.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { loadTemplate } from "../spec.js";
+import { normalizeNewlines } from "../hash.js";
+import { findManagedBlock } from "../managed-blocks.js";
+import { copyFile, pathExists, readText } from "../fs.js";
+import { codexSkillsBackupPathFor, codexSkillsBackupStamp, listTemplateCodexSkills, resolveCodexSkillsDir } from "../codex-skills.js";
+
+/**
+ * @param {{ templateId: string, skillsDir?: string }} options
+ */
+export async function codexUninstallSkillsCommand(options) {
+  const templateId = String(options.templateId || "workspace");
+  const tpl = await loadTemplate(templateId);
+
+  const skillsDir = resolveCodexSkillsDir(options.skillsDir);
+  const skillFiles = await listTemplateCodexSkills(tpl);
+
+  const backupStamp = codexSkillsBackupStamp();
+  const backupDir = path.join(skillsDir, ".aiws", "backups", "codex-skills", backupStamp);
+
+  /** @type {string[]} */
+  const removed = [];
+  /** @type {string[]} */
+  const skippedUnmanaged = [];
+  /** @type {string[]} */
+  const missing = [];
+
+  for (const sf of skillFiles) {
+    const destDir = path.join(skillsDir, sf.skillName);
+    const destAbs = path.join(destDir, "SKILL.md");
+    if (!(await pathExists(destAbs))) {
+      missing.push(sf.skillName);
+      continue;
+    }
+
+    const currentText = normalizeNewlines(await readText(destAbs));
+    const block = findManagedBlock(currentText, sf.blockId);
+    if (!block) {
+      skippedUnmanaged.push(sf.skillName);
+      continue;
+    }
+
+    const backup = codexSkillsBackupPathFor(skillsDir, sf.skillName, backupStamp);
+    await copyFile(destAbs, backup);
+    await fs.unlink(destAbs);
+    // Only remove the directory if it's empty after removing SKILL.md.
+    try {
+      await fs.rmdir(destDir);
+    } catch {
+      // ignore
+    }
+    removed.push(sf.skillName);
+  }
+
+  console.log(`✓ aiws codex uninstall-skills: ${skillsDir}`);
+  if (removed.length > 0) console.log(`removed: ${removed.join(", ")}`);
+  if (removed.length > 0) console.log(`backup: ${backupDir}`);
+  if (skippedUnmanaged.length > 0) console.log(`skipped (unmanaged): ${skippedUnmanaged.join(", ")}`);
+  if (missing.length > 0) console.log(`missing: ${missing.join(", ")}`);
+}
+

package/src/commands/hooks-install.js

@@ -0,0 +1,93 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { resolveWorkspaceRoot } from "../workspace.js";
+import { runCommand } from "../exec.js";
+import { pathExists, readText } from "../fs.js";
+import { UserError } from "../errors.js";
+import { loadTemplate } from "../spec.js";
+import { copyTemplateFileToWorkspace } from "../template.js";
+
+/**
+ * @param {string} absPath
+ */
+async function resolveGitRoot(absPath) {
+  let res;
+  try {
+    res = await runCommand("git", ["rev-parse", "--show-toplevel"], { cwd: absPath });
+  } catch (e) {
+    throw new UserError("git is required for hooks commands.", { details: e instanceof Error ? e.message : String(e) });
+  }
+  if (res.code !== 0) {
+    throw new UserError("Not a git repository.", { details: res.stderr || res.stdout });
+  }
+  const root = String(res.stdout || "").trim();
+  if (!root) throw new UserError("Failed to resolve git repository root.");
+  return root;
+}
+
+/**
+ * @param {fs.Stats} st
+ */
+function isExecutable(st) {
+  return (st.mode & 0o111) !== 0;
+}
+
+/**
+ * Resolve template id for a repo:
+ * - Prefer `.aiws/manifest.json` if present.
+ * - Else default to `workspace`.
+ *
+ * @param {string} gitRoot
+ */
+async function resolveTemplateIdForRepo(gitRoot) {
+  const manifestPath = path.join(gitRoot, ".aiws", "manifest.json");
+  if (!(await pathExists(manifestPath))) return "workspace";
+  try {
+    const stored = JSON.parse(await readText(manifestPath));
+    const templateId = String(stored.template_id || "").trim();
+    return templateId || "workspace";
+  } catch {
+    return "workspace";
+  }
+}
+
+/**
+ * @param {{ targetPath: string }} options
+ */
+export async function hooksInstallCommand(options) {
+  const workspaceRoot = await resolveWorkspaceRoot(options.targetPath, { create: false });
+  const gitRoot = await resolveGitRoot(workspaceRoot);
+
+  const templateId = await resolveTemplateIdForRepo(gitRoot);
+  const tpl = await loadTemplate(templateId);
+
+  const hookFiles = [".githooks/pre-commit", ".githooks/pre-push"];
+  /** @type {string[]} */
+  const created = [];
+  /** @type {string[]} */
+  const chmodded = [];
+
+  for (const rel of hookFiles) {
+    const abs = path.join(gitRoot, ...rel.split("/"));
+    if (!(await pathExists(abs))) {
+      await copyTemplateFileToWorkspace({ templateDir: tpl.templateDir, workspaceRoot: gitRoot, relPosix: rel, chmod: 0o755 });
+      created.push(rel);
+      continue;
+    }
+    const st = await fs.stat(abs);
+    if (!isExecutable(st)) {
+      await fs.chmod(abs, 0o755);
+      chmodded.push(rel);
+    }
+  }
+
+  const setRes = await runCommand("git", ["config", "core.hooksPath", ".githooks"], { cwd: gitRoot });
+  if (setRes.code !== 0) {
+    throw new UserError("Failed to set git core.hooksPath.", { details: setRes.stderr || setRes.stdout });
+  }
+
+  console.log(`✓ aiws hooks install: ${gitRoot}`);
+  if (created.length > 0) console.log(`created: ${created.join(", ")}`);
+  if (chmodded.length > 0) console.log(`chmod: ${chmodded.join(", ")}`);
+}
+

package/src/commands/hooks-status.js

@@ -0,0 +1,87 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { resolveWorkspaceRoot } from "../workspace.js";
+import { runCommand } from "../exec.js";
+import { pathExists } from "../fs.js";
+import { UserError } from "../errors.js";
+
+/**
+ * @param {string} absPath
+ */
+async function resolveGitRoot(absPath) {
+  let res;
+  try {
+    res = await runCommand("git", ["rev-parse", "--show-toplevel"], { cwd: absPath });
+  } catch (e) {
+    throw new UserError("git is required for hooks commands.", { details: e instanceof Error ? e.message : String(e) });
+  }
+  if (res.code !== 0) {
+    throw new UserError("Not a git repository.", { details: res.stderr || res.stdout });
+  }
+  const root = String(res.stdout || "").trim();
+  if (!root) throw new UserError("Failed to resolve git repository root.");
+  return root;
+}
+
+/**
+ * @param {string} gitRoot
+ * @param {string} key
+ */
+async function readGitConfig(gitRoot, key) {
+  const res = await runCommand("git", ["config", "--get", key], { cwd: gitRoot });
+  if (res.code !== 0) return "";
+  return String(res.stdout || "").trim();
+}
+
+/**
+ * @param {fs.Stats} st
+ */
+function isExecutable(st) {
+  return (st.mode & 0o111) !== 0;
+}
+
+/**
+ * @param {{ targetPath: string }} options
+ */
+export async function hooksStatusCommand(options) {
+  const workspaceRoot = await resolveWorkspaceRoot(options.targetPath, { create: false });
+  const gitRoot = await resolveGitRoot(workspaceRoot);
+
+  const hooksPath = await readGitConfig(gitRoot, "core.hooksPath");
+  const normalizedHooksPath = hooksPath.replace(/[\\/]+$/, "");
+
+  const githooksDir = path.join(gitRoot, ".githooks");
+  const preCommit = path.join(githooksDir, "pre-commit");
+  const prePush = path.join(githooksDir, "pre-push");
+
+  const githooksExists = await pathExists(githooksDir);
+  const preCommitExists = await pathExists(preCommit);
+  const prePushExists = await pathExists(prePush);
+
+  let preCommitExec = false;
+  let prePushExec = false;
+  if (preCommitExists) {
+    const st = await fs.stat(preCommit);
+    preCommitExec = isExecutable(st);
+  }
+  if (prePushExists) {
+    const st = await fs.stat(prePush);
+    prePushExec = isExecutable(st);
+  }
+
+  console.log(`✓ aiws hooks status: ${gitRoot}`);
+  console.log(`core.hooksPath: ${hooksPath ? hooksPath : "(default: .git/hooks)"}`);
+  console.log(`.githooks/: ${githooksExists ? "ok" : "missing"}`);
+  console.log(`.githooks/pre-commit: ${preCommitExists ? (preCommitExec ? "ok" : "not-executable") : "missing"}`);
+  console.log(`.githooks/pre-push: ${prePushExists ? (prePushExec ? "ok" : "not-executable") : "missing"}`);
+
+  const enabled = normalizedHooksPath === ".githooks";
+  if (!enabled) {
+    console.log("Next: aiws hooks install .");
+    return;
+  }
+  if (!githooksExists || !preCommitExists || !prePushExists || !preCommitExec || !prePushExec) {
+    console.log("Next: aiws hooks install .");
+    return;
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,93 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { loadTemplate } from "../spec.js";
+import { expandManifestEntries, copyTemplateFileToWorkspace, applyManagedBlocksFromTemplate } from "../template.js";
+import { loadAiwsPackage } from "../aiws-package.js";
+import { writeWorkspaceManifest } from "../manifest.js";
+import { resolveWorkspaceRoot } from "../workspace.js";
+import { joinRel, normalizeRel } from "../path-utils.js";
+import { pathExists } from "../fs.js";
+import { BackupSession } from "../backup.js";
+
+/**
+ * @param {{ targetPath: string, templateId: string }} options
+ */
+export async function initCommand(options) {
+  const workspaceRoot = await resolveWorkspaceRoot(options.targetPath, { create: true });
+  const tpl = await loadTemplate(options.templateId);
+  const aiws = await loadAiwsPackage();
+
+  const defaults = tpl.manifest.defaults || {};
+  const includeOptional = defaults.include_optional !== false;
+  const tools = Array.isArray(defaults.tools) ? defaults.tools.map(String) : ["claude", "opencode", "codex", "iflow"];
+
+  const required = await expandManifestEntries(tpl.templateDir, tpl.manifest.required || []);
+  const optional = includeOptional ? await expandManifestEntries(tpl.templateDir, tpl.manifest.optional || []) : [];
+  const allFiles = Array.from(new Set([...required, ...optional]));
+
+  const update = tpl.manifest.update || {};
+  const replaceFiles = new Set((update.replace_file || []).map(normalizeRel));
+  const managedBlocks = update.managed_blocks && typeof update.managed_blocks === "object" ? update.managed_blocks : {};
+
+  // If we are overwriting existing files, take a backup for rollback.
+  const backup = new BackupSession({ workspaceRoot, operation: "init" });
+  await backup.recordFile(".aiws/manifest.json");
+  for (const f of replaceFiles) {
+    if (f && f !== ".aiws/manifest.json") await backup.recordFile(f);
+  }
+  for (const f of Object.keys(managedBlocks)) await backup.recordFile(f);
+  await backup.finalize({ extra: { template_id: tpl.templateId } });
+
+  // Ensure .aiws directory (manifest will be generated at the end)
+  await fs.mkdir(path.join(workspaceRoot, ".aiws"), { recursive: true });
+
+  for (const rel of allFiles) {
+    const r = normalizeRel(rel);
+    if (!r) continue;
+    if (r === ".aiws/manifest.json") {
+      // Always generated, never copied from template.
+      continue;
+    }
+
+    if (replaceFiles.has(r)) {
+      await copyTemplateFileToWorkspace({
+        templateDir: tpl.templateDir,
+        workspaceRoot,
+        relPosix: r,
+        chmod: r.startsWith(".githooks/") ? 0o755 : undefined,
+      });
+      continue;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(managedBlocks, r)) {
+      const blockIds = Array.isArray(managedBlocks[r]) ? managedBlocks[r].map(String) : [];
+      await applyManagedBlocksFromTemplate({
+        templateDir: tpl.templateDir,
+        workspaceRoot,
+        fileRel: r,
+        blockIds,
+        insertIfMissing: true,
+      });
+      continue;
+    }
+
+    // unmanaged: only create if missing
+    const dest = joinRel(workspaceRoot, r);
+    if (await pathExists(dest)) continue;
+    await copyTemplateFileToWorkspace({ templateDir: tpl.templateDir, workspaceRoot, relPosix: r });
+  }
+
+  const now = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+  await writeWorkspaceManifest({
+    workspaceRoot,
+    templateId: tpl.templateId,
+    specVersion: tpl.specVersion,
+    aiwsVersion: aiws.version,
+    installedAt: now,
+    updatedAt: now,
+    tools,
+    templateManifest: tpl.manifest,
+  });
+
+  console.log(`✓ aiws init: ${workspaceRoot} (template=${tpl.templateId})`);
+}

package/src/commands/rollback.js

@@ -0,0 +1,13 @@
+import { resolveWorkspaceRoot } from "../workspace.js";
+import { resolveBackupRoot, rollbackFromBackup } from "../backup.js";
+
+/**
+ * @param {{ targetPath: string, stamp: string }} options
+ */
+export async function rollbackCommand(options) {
+  const workspaceRoot = await resolveWorkspaceRoot(options.targetPath, { create: false });
+  const backupRoot = await resolveBackupRoot(workspaceRoot, options.stamp);
+  await rollbackFromBackup(workspaceRoot, backupRoot);
+  console.log(`✓ aiws rollback: ${workspaceRoot} (${options.stamp})`);
+}
+