@sixsevenai/ai-dlc-installer 1.0.0

package/dist/cli.js

@@ -0,0 +1,4185 @@
+#!/usr/bin/env node
+
+// src/orchestrator/workflow.ts
+import * as path6 from "path";
+
+// src/orchestrator/types.ts
+var EXIT_SUCCESS = 0;
+var EXIT_ERROR = 1;
+var EXIT_CANCELLED = 2;
+
+// src/orchestrator/config.ts
+import * as path from "path";
+import * as fs from "fs/promises";
+import { fileURLToPath } from "url";
+var INSTALLER_VERSION = "0.1.0";
+var CLAUDE_DIRECTORY_NAME = ".claude";
+var SOURCE_LIBRARY_RELATIVE = "../../ai-dlc-library";
+async function resolveSourceDirectory() {
+  const envSource = process.env["AIDLC_SOURCE_DIR"];
+  if (envSource) {
+    try {
+      const stat5 = await fs.stat(envSource);
+      if (stat5.isDirectory()) {
+        return path.resolve(envSource);
+      }
+    } catch {
+    }
+  }
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = path.dirname(thisFile);
+  const resolved = path.resolve(thisDir, SOURCE_LIBRARY_RELATIVE);
+  try {
+    const stat5 = await fs.stat(resolved);
+    if (stat5.isDirectory()) {
+      return resolved;
+    }
+  } catch {
+  }
+  const cwdSource = path.resolve(process.cwd(), "src", "ai-dlc-library");
+  try {
+    const stat5 = await fs.stat(cwdSource);
+    if (stat5.isDirectory()) {
+      return cwdSource;
+    }
+  } catch {
+  }
+  throw new Error(
+    "Cannot locate AI-DLC library source directory. Set the AIDLC_SOURCE_DIR environment variable to the library path, or run the installer from the SixSevenAI repository root."
+  );
+}
+var WORKFLOW_STEPS = [
+  { id: "detect-platform", name: "Detect Platform", order: 1, isSkippable: false },
+  { id: "check-prerequisites", name: "Check Prerequisites", order: 2, isSkippable: false },
+  { id: "show-banner", name: "Show Banner", order: 3, isSkippable: true },
+  { id: "select-directory", name: "Select Target Directory", order: 4, isSkippable: true },
+  { id: "scan-source", name: "Scan Source Components", order: 5, isSkippable: false },
+  { id: "detect-conflicts", name: "Detect Conflicts", order: 6, isSkippable: true },
+  { id: "confirm-installation", name: "Confirm Installation", order: 7, isSkippable: true },
+  { id: "execute-installation", name: "Install Files", order: 8, isSkippable: false },
+  { id: "validate-installation", name: "Validate Installation", order: 9, isSkippable: false },
+  { id: "show-summary", name: "Show Summary", order: 10, isSkippable: false }
+];
+function shouldSkipStep(stepId, options, isInteractive) {
+  switch (stepId) {
+    case "show-banner":
+      return !isInteractive || options.quiet;
+    case "select-directory":
+      return options.target !== null;
+    case "detect-conflicts":
+      return options.force;
+    case "confirm-installation":
+      return options.force || !isInteractive;
+    default:
+      return false;
+  }
+}
+
+// src/ui/theme.ts
+import chalk from "chalk";
+import gradientString from "gradient-string";
+var TRUECOLOR_SCHEME = {
+  header: "#3B82F6",
+  accent: "#06B6D4",
+  success: "#10B981",
+  error: "#EF4444",
+  warning: "#F59E0B",
+  muted: "#6B7280"
+};
+var BASIC_SCHEME = {
+  header: "blue",
+  accent: "cyan",
+  success: "green",
+  error: "red",
+  warning: "yellow",
+  muted: "gray"
+};
+var PLAIN_SCHEME = {
+  header: "",
+  accent: "",
+  success: "",
+  error: "",
+  warning: "",
+  muted: ""
+};
+var UNICODE_SYMBOLS = {
+  pending: "\u25CB",
+  // White circle
+  running: "\u25CF",
+  // Filled circle
+  completed: "\u2713",
+  // Checkmark
+  failed: "\u2717",
+  // Cross
+  skipped: "\u2500",
+  // Horizontal line
+  bullet: "\u2022",
+  // Bullet
+  arrow: "\u25B8",
+  // Right-pointing triangle
+  boxTopLeft: "\u250C",
+  boxTopRight: "\u2510",
+  boxBottomLeft: "\u2514",
+  boxBottomRight: "\u2518",
+  boxHorizontal: "\u2500",
+  boxVertical: "\u2502",
+  boxDividerLeft: "\u251C",
+  boxDividerRight: "\u2524",
+  doubleTopLeft: "\u2554",
+  doubleTopRight: "\u2557",
+  doubleBottomLeft: "\u255A",
+  doubleBottomRight: "\u255D",
+  doubleHorizontal: "\u2550",
+  doubleVertical: "\u2551"
+};
+var ASCII_SYMBOLS = {
+  pending: "o",
+  running: "*",
+  completed: "+",
+  failed: "x",
+  skipped: "-",
+  bullet: "*",
+  arrow: ">",
+  boxTopLeft: "+",
+  boxTopRight: "+",
+  boxBottomLeft: "+",
+  boxBottomRight: "+",
+  boxHorizontal: "-",
+  boxVertical: "|",
+  boxDividerLeft: "+",
+  boxDividerRight: "+",
+  doubleTopLeft: "+",
+  doubleTopRight: "+",
+  doubleBottomLeft: "+",
+  doubleBottomRight: "+",
+  doubleHorizontal: "=",
+  doubleVertical: "|"
+};
+function selectTier(capabilities, overrides) {
+  if (overrides.forceNoColor) {
+    return "plain";
+  }
+  if (!capabilities.unicodeSupport) {
+    return "plain";
+  }
+  if (capabilities.colorSupport === "none") {
+    return "plain";
+  }
+  if (capabilities.colorSupport === "truecolor") {
+    return "full";
+  }
+  return "basic";
+}
+var ThemeEngine = class _ThemeEngine {
+  _tier;
+  _colorScheme;
+  _symbolSet;
+  _terminalWidth;
+  _forceNoColor;
+  constructor(params) {
+    this._tier = params.tier;
+    this._colorScheme = params.colorScheme;
+    this._symbolSet = params.symbolSet;
+    this._terminalWidth = params.terminalWidth;
+    this._forceNoColor = params.forceNoColor;
+  }
+  /** Current rendering tier. */
+  get tier() {
+    return this._tier;
+  }
+  /** Active color scheme. */
+  get colorScheme() {
+    return this._colorScheme;
+  }
+  /** Active symbol set. */
+  get symbolSet() {
+    return this._symbolSet;
+  }
+  /** Detected or default terminal width. */
+  get terminalWidth() {
+    return this._terminalWidth;
+  }
+  /** Whether color output is forcibly disabled. */
+  get forceNoColor() {
+    return this._forceNoColor;
+  }
+  /**
+   * Apply a semantic color to text. Returns unmodified text for Plain tier.
+   */
+  colorize(text2, color) {
+    if (this._tier === "plain") {
+      return text2;
+    }
+    const colorValue = this._colorScheme[color];
+    if (!colorValue) {
+      return text2;
+    }
+    if (this._tier === "full") {
+      return chalk.hex(colorValue)(text2);
+    }
+    const chalkFn = this.getBasicChalkFn(color);
+    return chalkFn(text2);
+  }
+  /**
+   * Apply bold styling to text. Returns unmodified text for Plain tier.
+   */
+  bold(text2) {
+    if (this._tier === "plain") {
+      return text2;
+    }
+    return chalk.bold(text2);
+  }
+  /**
+   * Apply dim styling to text. Returns unmodified text for Plain tier.
+   */
+  dim(text2) {
+    if (this._tier === "plain") {
+      return text2;
+    }
+    return chalk.dim(text2);
+  }
+  /**
+   * Apply underline styling to text. Returns unmodified text for Plain tier.
+   */
+  underline(text2) {
+    if (this._tier === "plain") {
+      return text2;
+    }
+    return chalk.underline(text2);
+  }
+  /**
+   * Apply gradient coloring to text. Full tier uses gradient-string.
+   * Basic tier applies a single accent color. Plain tier returns unmodified text.
+   */
+  applyGradient(text2, gradient) {
+    if (this._tier === "plain") {
+      return text2;
+    }
+    if (this._tier === "full") {
+      const colors = gradient?.colors ?? ["#4F46E5", "#06B6D4"];
+      const grad = gradientString(...colors);
+      return grad(text2);
+    }
+    return chalk.blue(text2);
+  }
+  /**
+   * Get the status symbol for a step status, colorized for the active tier.
+   */
+  statusSymbol(status) {
+    const symbol = this._symbolSet[status];
+    if (this._tier === "plain") {
+      return `[${symbol}]`;
+    }
+    switch (status) {
+      case "completed":
+        return this.colorize(symbol, "success");
+      case "failed":
+        return this.colorize(symbol, "error");
+      case "running":
+        return this.colorize(symbol, "accent");
+      case "skipped":
+        return this.colorize(symbol, "muted");
+      case "pending":
+        return this.colorize(symbol, "muted");
+      default:
+        return symbol;
+    }
+  }
+  /**
+   * Get a chalk function for basic (16-color) mode.
+   */
+  getBasicChalkFn(color) {
+    switch (color) {
+      case "header":
+        return chalk.blue;
+      case "accent":
+        return chalk.cyan;
+      case "success":
+        return chalk.green;
+      case "error":
+        return chalk.red;
+      case "warning":
+        return chalk.yellow;
+      case "muted":
+        return chalk.gray;
+      default:
+        return (t) => t;
+    }
+  }
+  /**
+   * Create and initialize a ThemeEngine from terminal capabilities and overrides.
+   */
+  static initialize(capabilities, overrides = { forceNoColor: false, forceColor: false }) {
+    const tier = selectTier(capabilities, overrides);
+    let colorScheme;
+    let symbolSet;
+    switch (tier) {
+      case "full":
+        colorScheme = TRUECOLOR_SCHEME;
+        symbolSet = UNICODE_SYMBOLS;
+        break;
+      case "basic":
+        colorScheme = BASIC_SCHEME;
+        symbolSet = UNICODE_SYMBOLS;
+        break;
+      case "plain":
+      default:
+        colorScheme = PLAIN_SCHEME;
+        symbolSet = ASCII_SYMBOLS;
+        break;
+    }
+    const terminalWidth = capabilities.width > 0 ? capabilities.width : 80;
+    return new _ThemeEngine({
+      tier,
+      colorScheme,
+      symbolSet,
+      terminalWidth,
+      forceNoColor: overrides.forceNoColor
+    });
+  }
+};
+
+// src/ui/banner.ts
+import figlet from "figlet";
+var DEFAULT_GRADIENT = {
+  colors: ["#4F46E5", "#06B6D4"],
+  direction: "horizontal"
+};
+var DEFAULT_FONT = "ANSI Shadow";
+var NARROW_FONT = "Small";
+function generateFigletText(text2, font) {
+  try {
+    const result = figlet.textSync(text2, {
+      font,
+      horizontalLayout: "default",
+      verticalLayout: "default"
+    });
+    return result;
+  } catch {
+    return null;
+  }
+}
+function renderFallbackBanner(version2, theme) {
+  const separator = "=".repeat(Math.min(43, theme.terminalWidth - 4));
+  const lines = [];
+  lines.push(`  ${separator}`);
+  lines.push("   SixSevenAI - AI-DLC Framework");
+  lines.push(`   Installer ${version2}`);
+  lines.push(`  ${separator}`);
+  lines.push("");
+  return lines;
+}
+function renderBanner(version2, theme, config) {
+  const title = config?.title ?? "SixSevenAI";
+  const subtitle = config?.subtitle ?? "AI-DLC Framework Installer";
+  const tier = theme.tier;
+  const width = theme.terminalWidth;
+  let font;
+  if (tier === "plain") {
+    font = config?.font ?? "Standard";
+  } else {
+    font = config?.font ?? (width >= 80 ? DEFAULT_FONT : NARROW_FONT);
+  }
+  const figletText = generateFigletText(title, font);
+  if (!figletText) {
+    return renderFallbackBanner(version2, theme);
+  }
+  const figletLines = figletText.split("\n").filter((line) => line.trim().length > 0);
+  const maxLineWidth = Math.max(...figletLines.map((line) => line.length));
+  if (maxLineWidth > width - 4) {
+    if (font !== NARROW_FONT) {
+      const narrowText = generateFigletText(title, NARROW_FONT);
+      if (narrowText) {
+        const narrowLines = narrowText.split("\n").filter((line) => line.trim().length > 0);
+        const narrowMax = Math.max(...narrowLines.map((line) => line.length));
+        if (narrowMax <= width - 4) {
+          return buildBannerOutput(narrowLines, subtitle, version2, theme);
+        }
+      }
+    }
+    return renderFallbackBanner(version2, theme);
+  }
+  return buildBannerOutput(figletLines, subtitle, version2, theme);
+}
+function buildBannerOutput(artLines, subtitle, version2, theme) {
+  const lines = [];
+  for (const artLine of artLines) {
+    const indented = `  ${artLine}`;
+    switch (theme.tier) {
+      case "full":
+        lines.push(theme.applyGradient(indented, DEFAULT_GRADIENT));
+        break;
+      case "basic":
+        lines.push(theme.colorize(indented, "header"));
+        break;
+      case "plain":
+      default:
+        lines.push(indented);
+        break;
+    }
+  }
+  lines.push("");
+  const versionStr = version2.startsWith("v") ? version2 : `v${version2}`;
+  const subtitleLine = `  ${subtitle} ${versionStr}`;
+  switch (theme.tier) {
+    case "full": {
+      const styledSubtitle = theme.dim(subtitle);
+      const styledVersion = theme.bold(theme.colorize(versionStr, "accent"));
+      lines.push(`  ${styledSubtitle} ${styledVersion}`);
+      break;
+    }
+    case "basic": {
+      const styledSubtitle = theme.dim(subtitle);
+      const styledVersion = theme.colorize(versionStr, "accent");
+      lines.push(`  ${styledSubtitle} ${styledVersion}`);
+      break;
+    }
+    case "plain":
+    default:
+      lines.push(subtitleLine);
+      break;
+  }
+  lines.push("");
+  return lines;
+}
+
+// src/ui/progress.ts
+import ora from "ora";
+
+// src/ui/types.ts
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return { milliseconds: ms, formatted: `${ms}ms` };
+  }
+  if (ms < 6e4) {
+    const seconds2 = (ms / 1e3).toFixed(1);
+    return { milliseconds: ms, formatted: `${seconds2}s` };
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = Math.round(ms % 6e4 / 1e3);
+  return { milliseconds: ms, formatted: `${minutes}m ${seconds}s` };
+}
+function mapColorSupport(level) {
+  switch (level) {
+    case 0:
+      return "none";
+    case 1:
+      return "basic";
+    case 2:
+      return "256";
+    case 3:
+      return "truecolor";
+    default:
+      return "none";
+  }
+}
+
+// src/ui/progress.ts
+var VALID_TRANSITIONS = {
+  pending: ["running", "skipped"],
+  running: ["completed", "failed"],
+  completed: [],
+  failed: [],
+  skipped: []
+};
+function isValidTransition(from, to) {
+  return VALID_TRANSITIONS[from].includes(to);
+}
+var ProgressTracker = class {
+  _steps = [];
+  _startTime = null;
+  _endTime = null;
+  _isActive = false;
+  _spinner = null;
+  /** Ordered list of top-level steps. */
+  get steps() {
+    return this._steps;
+  }
+  /** Whether tracking is in progress. */
+  get isActive() {
+    return this._isActive;
+  }
+  /**
+   * Append a top-level step. Throws if tracker is already finished.
+   */
+  addStep(config) {
+    if (this._endTime !== null) {
+      throw new Error("Cannot add steps to a finished tracker.");
+    }
+    if (this.findStep(config.id)) {
+      throw new Error(`Duplicate step ID: "${config.id}".`);
+    }
+    const children = (config.children ?? []).map((child) => {
+      if (this.findStep(child.id)) {
+        throw new Error(`Duplicate step ID: "${child.id}".`);
+      }
+      return {
+        id: child.id,
+        label: child.label,
+        status: "pending",
+        children: [],
+        startTime: null,
+        endTime: null,
+        error: null
+      };
+    });
+    this._steps.push({
+      id: config.id,
+      label: config.label,
+      status: "pending",
+      children,
+      startTime: null,
+      endTime: null,
+      error: null
+    });
+  }
+  /**
+   * Mark the tracker as active and record the start time.
+   */
+  start() {
+    this._startTime = Date.now();
+    this._isActive = true;
+  }
+  /**
+   * Transition a step from Pending to Running.
+   */
+  startStep(stepId) {
+    const step = this.requireStep(stepId);
+    this.transitionStep(step, "running");
+    step.startTime = Date.now();
+  }
+  /**
+   * Transition a step from Running to Completed.
+   */
+  completeStep(stepId) {
+    const step = this.requireStep(stepId);
+    this.transitionStep(step, "completed");
+    step.endTime = Date.now();
+  }
+  /**
+   * Transition a step from Running to Failed with error details.
+   */
+  failStep(stepId, error) {
+    const step = this.requireStep(stepId);
+    this.transitionStep(step, "failed");
+    step.endTime = Date.now();
+    step.error = error;
+  }
+  /**
+   * Transition a step from Pending to Skipped.
+   */
+  skipStep(stepId, _reason) {
+    const step = this.requireStep(stepId);
+    this.transitionStep(step, "skipped");
+  }
+  /**
+   * Mark the tracker as finished. Throws if any steps are still Running.
+   */
+  finish() {
+    const runningSteps = this.flattenSteps().filter((s) => s.status === "running");
+    if (runningSteps.length > 0) {
+      const ids = runningSteps.map((s) => s.id).join(", ");
+      throw new Error(`Cannot finish tracker while steps are running: ${ids}`);
+    }
+    this._endTime = Date.now();
+    this._isActive = false;
+    this.stopSpinner();
+  }
+  /**
+   * Get the elapsed time since tracking started.
+   */
+  getElapsedTime() {
+    if (this._startTime === null) {
+      return { milliseconds: 0, formatted: "0ms" };
+    }
+    const end = this._endTime ?? Date.now();
+    return formatDuration(end - this._startTime);
+  }
+  /**
+   * Get the completion ratio across all steps (including children).
+   */
+  getCompletionRatio() {
+    const allSteps = this.flattenSteps();
+    const completed = allSteps.filter(
+      (s) => s.status === "completed" || s.status === "skipped"
+    ).length;
+    const total = allSteps.length;
+    const percentage = total > 0 ? Math.round(completed / total * 100) : 0;
+    return { completed, total, percentage };
+  }
+  /**
+   * Render the current progress state as terminal output lines.
+   *
+   * @param theme - ThemeEngine for colors and symbols
+   * @returns Array of output lines
+   */
+  render(theme) {
+    const lines = [];
+    const width = theme.terminalWidth;
+    for (const step of this._steps) {
+      lines.push(this.renderStep(step, 0, theme, width));
+      for (const child of step.children) {
+        lines.push(this.renderStep(child, 1, theme, width));
+      }
+    }
+    return lines;
+  }
+  /**
+   * Start the ora spinner for the currently running step.
+   * Used by the render service for animated Running indicators.
+   */
+  startSpinner(text2) {
+    if (this._spinner) {
+      this._spinner.stop();
+    }
+    const runningStep = this.flattenSteps().find((s) => s.status === "running");
+    if (!runningStep) {
+      return null;
+    }
+    this._spinner = ora({
+      text: text2 ?? runningStep.label,
+      spinner: "dots"
+    });
+    this._spinner.start();
+    return this._spinner;
+  }
+  /**
+   * Stop the ora spinner if one is running.
+   */
+  stopSpinner() {
+    if (this._spinner) {
+      this._spinner.stop();
+      this._spinner = null;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Private Helpers
+  // -------------------------------------------------------------------------
+  /**
+   * Find a step by ID across all levels of the hierarchy.
+   */
+  findStep(stepId) {
+    for (const step of this._steps) {
+      if (step.id === stepId) return step;
+      for (const child of step.children) {
+        if (child.id === stepId) return child;
+      }
+    }
+    return null;
+  }
+  /**
+   * Find a step by ID, throwing if not found.
+   */
+  requireStep(stepId) {
+    const step = this.findStep(stepId);
+    if (!step) {
+      throw new Error(`Step not found: "${stepId}".`);
+    }
+    return step;
+  }
+  /**
+   * Enforce valid status transitions.
+   */
+  transitionStep(step, to) {
+    if (!isValidTransition(step.status, to)) {
+      throw new Error(
+        `Invalid transition for step "${step.id}": ${step.status} -> ${to}. Allowed: [${VALID_TRANSITIONS[step.status].join(", ")}].`
+      );
+    }
+    step.status = to;
+  }
+  /**
+   * Flatten all steps (parents + children) into a single array.
+   */
+  flattenSteps() {
+    const result = [];
+    for (const step of this._steps) {
+      result.push(step);
+      result.push(...step.children);
+    }
+    return result;
+  }
+  /**
+   * Render a single step line with indentation, symbol, label, and elapsed time.
+   */
+  renderStep(step, depth, theme, terminalWidth) {
+    const tier = theme.tier;
+    const indentSize = tier === "plain" ? 4 : 2;
+    const indent = " ".repeat(2 + depth * indentSize);
+    const symbol = theme.statusSymbol(step.status);
+    let elapsed = "";
+    if (step.startTime !== null) {
+      const end = step.endTime ?? Date.now();
+      const duration = formatDuration(end - step.startTime);
+      elapsed = duration.formatted;
+    }
+    const labelPart = `${indent}${symbol} ${step.label}`;
+    if (!elapsed) {
+      return labelPart;
+    }
+    const elapsedDisplay = theme.dim(elapsed);
+    const rawLabelLength = stripAnsi(labelPart).length;
+    const rawElapsedLength = elapsed.length;
+    const padding = Math.max(4, terminalWidth - rawLabelLength - rawElapsedLength - 2);
+    return `${labelPart}${" ".repeat(padding)}${elapsedDisplay}`;
+  }
+};
+function stripAnsi(text2) {
+  return text2.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/ui/prompts.ts
+import * as clack from "@clack/prompts";
+async function promptDirectorySelection(options, theme) {
+  const selectOptions = options.map((opt) => ({
+    value: opt.path,
+    label: opt.path,
+    hint: opt.isDefault ? "(default)" : opt.exists ? "(exists)" : "(will be created)"
+  }));
+  selectOptions.push({
+    value: "__custom__",
+    label: "Custom path...",
+    hint: "Enter a custom directory path"
+  });
+  const selected = await clack.select({
+    message: "Select installation directory:",
+    options: selectOptions,
+    initialValue: options.find((o) => o.isDefault)?.path ?? options[0]?.path
+  });
+  if (clack.isCancel(selected)) {
+    throw new UserCancellationError("Directory selection cancelled.");
+  }
+  if (selected === "__custom__") {
+    const customPath = await clack.text({
+      message: "Enter installation directory path:",
+      placeholder: process.cwd(),
+      validate: (value) => {
+        if (!value || value.trim().length === 0) {
+          return "Path cannot be empty.";
+        }
+        const isAbsolute = /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("/");
+        if (!isAbsolute) {
+          return "Path must be absolute (e.g., C:\\dev\\project or /home/user/project).";
+        }
+        return void 0;
+      }
+    });
+    if (clack.isCancel(customPath)) {
+      throw new UserCancellationError("Custom path entry cancelled.");
+    }
+    return {
+      path: customPath,
+      isCustom: true
+    };
+  }
+  return {
+    path: selected,
+    isCustom: false
+  };
+}
+async function promptConfirmation(message, defaultValue = true) {
+  const result = await clack.confirm({
+    message,
+    initialValue: defaultValue
+  });
+  if (clack.isCancel(result)) {
+    throw new UserCancellationError("Confirmation cancelled.");
+  }
+  return result;
+}
+async function promptOverwriteExisting(targetPath) {
+  const result = await clack.confirm({
+    message: `Directory "${targetPath}" already contains AI-DLC files. Overwrite?`,
+    initialValue: false
+  });
+  if (clack.isCancel(result)) {
+    throw new UserCancellationError("Overwrite confirmation cancelled.");
+  }
+  return result;
+}
+async function promptRetry() {
+  const result = await clack.confirm({
+    message: "Would you like to retry?",
+    initialValue: true
+  });
+  if (clack.isCancel(result)) {
+    return false;
+  }
+  return result;
+}
+function promptIntro(title) {
+  clack.intro(title);
+}
+function promptOutro(message) {
+  clack.outro(message);
+}
+var UserCancellationError = class extends Error {
+  code = "USER_CANCELLED";
+  constructor(message = "Operation cancelled by user.") {
+    super(message);
+    this.name = "UserCancellationError";
+  }
+};
+
+// src/ui/error-display.ts
+function renderError(content, theme) {
+  return renderPanel(content, "error", theme);
+}
+function renderPanel(content, panelType, theme) {
+  const symbols = theme.symbolSet;
+  const width = Math.min(theme.terminalWidth - 4, 75);
+  const innerWidth = width - 4;
+  const tier = theme.tier;
+  const colorFn = (text2) => {
+    return theme.colorize(text2, panelType === "error" ? "error" : "warning");
+  };
+  const lines = [];
+  const topBorder = buildHorizontalBorder(
+    symbols.boxTopLeft,
+    symbols.boxHorizontal,
+    symbols.boxTopRight,
+    width
+  );
+  lines.push(`  ${colorFn(topBorder)}`);
+  const statusSymbol = panelType === "error" ? theme.statusSymbol("failed") : tier === "plain" ? "[!]" : "\u26A0";
+  const titleText = `${statusSymbol} ${content.title}`;
+  lines.push(buildContentLine(titleText, symbols.boxVertical, innerWidth, colorFn, theme));
+  const divider = buildHorizontalBorder(
+    symbols.boxDividerLeft,
+    symbols.boxHorizontal,
+    symbols.boxDividerRight,
+    width
+  );
+  lines.push(`  ${colorFn(divider)}`);
+  lines.push(buildEmptyLine(symbols.boxVertical, innerWidth, colorFn));
+  const messageLines = wordWrap(content.message, innerWidth - 2);
+  for (const msgLine of messageLines) {
+    lines.push(buildContentLine(` ${msgLine}`, symbols.boxVertical, innerWidth, colorFn, theme));
+  }
+  if ("cause" in content && content.cause) {
+    lines.push(buildEmptyLine(symbols.boxVertical, innerWidth, colorFn));
+    const causePrefix = theme.bold("Cause:");
+    const causeLines = wordWrap(`${content.cause}`, innerWidth - 9);
+    lines.push(
+      buildContentLine(` ${causePrefix} ${causeLines[0] ?? ""}`, symbols.boxVertical, innerWidth, colorFn, theme)
+    );
+    for (let i = 1; i < causeLines.length; i++) {
+      lines.push(
+        buildContentLine(`        ${causeLines[i]}`, symbols.boxVertical, innerWidth, colorFn, theme)
+      );
+    }
+  }
+  if (content.suggestedActions.length > 0) {
+    lines.push(buildEmptyLine(symbols.boxVertical, innerWidth, colorFn));
+    lines.push(
+      buildContentLine(" Suggested actions:", symbols.boxVertical, innerWidth, colorFn, theme)
+    );
+    lines.push(buildEmptyLine(symbols.boxVertical, innerWidth, colorFn));
+    for (const action of content.suggestedActions) {
+      lines.push(...renderSuggestedAction(action, symbols.boxVertical, innerWidth, colorFn, theme));
+    }
+  }
+  lines.push(buildEmptyLine(symbols.boxVertical, innerWidth, colorFn));
+  const bottomBorder = buildHorizontalBorder(
+    symbols.boxBottomLeft,
+    symbols.boxHorizontal,
+    symbols.boxBottomRight,
+    width
+  );
+  lines.push(`  ${colorFn(bottomBorder)}`);
+  return lines;
+}
+function buildHorizontalBorder(left, horizontal, right, totalWidth) {
+  const fill = horizontal.repeat(totalWidth - 2);
+  return `${left}${fill}${right}`;
+}
+function buildContentLine(content, vertical, innerWidth, colorFn, theme) {
+  const strippedLength = stripAnsi2(content).length;
+  const padding = Math.max(0, innerWidth - strippedLength);
+  return `  ${colorFn(vertical)} ${content}${" ".repeat(padding)}${colorFn(vertical)}`;
+}
+function buildEmptyLine(vertical, innerWidth, colorFn) {
+  return `  ${colorFn(vertical)}${" ".repeat(innerWidth + 2)}${colorFn(vertical)}`;
+}
+function renderSuggestedAction(action, vertical, innerWidth, colorFn, theme) {
+  const lines = [];
+  const numberPrefix = `   ${action.step}. `;
+  const instructionLines = wordWrap(action.instruction, innerWidth - numberPrefix.length - 2);
+  lines.push(
+    buildContentLine(
+      `${numberPrefix}${instructionLines[0] ?? ""}`,
+      vertical,
+      innerWidth,
+      colorFn,
+      theme
+    )
+  );
+  const continuationIndent = " ".repeat(numberPrefix.length);
+  for (let i = 1; i < instructionLines.length; i++) {
+    lines.push(
+      buildContentLine(
+        `${continuationIndent}${instructionLines[i]}`,
+        vertical,
+        innerWidth,
+        colorFn,
+        theme
+      )
+    );
+  }
+  if (action.command) {
+    const commandText = theme.colorize(action.command, "accent");
+    lines.push(
+      buildContentLine(
+        `${continuationIndent}${commandText}`,
+        vertical,
+        innerWidth,
+        colorFn,
+        theme
+      )
+    );
+  }
+  lines.push(buildEmptyLine(vertical, innerWidth, colorFn));
+  return lines;
+}
+function wordWrap(text2, maxWidth) {
+  if (maxWidth <= 0) return [text2];
+  const words = text2.split(" ");
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    if (currentLine.length === 0) {
+      currentLine = word;
+    } else if (currentLine.length + 1 + word.length <= maxWidth) {
+      currentLine += ` ${word}`;
+    } else {
+      lines.push(currentLine);
+      currentLine = word;
+    }
+  }
+  if (currentLine.length > 0) {
+    lines.push(currentLine);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+function stripAnsi2(text2) {
+  return text2.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/ui/summary.ts
+function renderSummary(summary, nextSteps, theme) {
+  const width = theme.terminalWidth;
+  const lines = [];
+  lines.push(...renderHeaderBox(summary, theme, width));
+  lines.push("");
+  const dirLabel = summary.success ? "Installed to:" : "Target directory:";
+  lines.push(`  ${dirLabel} ${theme.colorize(summary.targetDirectory, "accent")}`);
+  lines.push("");
+  if (summary.success || summary.totalFilesCopied > 0) {
+    lines.push(...renderComponentCounts(summary.componentCounts, theme));
+    lines.push("");
+  }
+  lines.push(...renderFileStatistics(summary, theme));
+  lines.push("");
+  lines.push(`  Total time: ${theme.bold(summary.totalDuration.formatted)}`);
+  lines.push("");
+  lines.push(renderDivider(theme, width));
+  lines.push("");
+  if (nextSteps.length > 0) {
+    lines.push(...renderNextSteps(nextSteps, theme));
+    lines.push("");
+    lines.push(renderDivider(theme, width));
+  }
+  return lines;
+}
+function renderHeaderBox(summary, theme, width) {
+  const symbols = theme.symbolSet;
+  const boxWidth = Math.min(width - 4, 72);
+  const innerWidth = boxWidth - 4;
+  let statusSymbol;
+  let title;
+  let colorName;
+  if (summary.success && summary.totalFilesFailed === 0) {
+    statusSymbol = theme.statusSymbol("completed");
+    title = "Installation Complete!";
+    colorName = "success";
+  } else if (summary.success && summary.totalFilesFailed > 0) {
+    statusSymbol = theme.tier === "plain" ? "[!]" : "\u26A0";
+    title = "Installation Completed with Warnings";
+    colorName = "warning";
+  } else {
+    statusSymbol = theme.statusSymbol("failed");
+    title = "Installation Failed";
+    colorName = "error";
+  }
+  const colorFn = (text2) => theme.colorize(text2, colorName);
+  const lines = [];
+  const topBorder = `${symbols.doubleTopLeft}${symbols.doubleHorizontal.repeat(boxWidth - 2)}${symbols.doubleTopRight}`;
+  lines.push(`  ${colorFn(topBorder)}`);
+  const emptyLine = `${symbols.doubleVertical}${" ".repeat(boxWidth - 2)}${symbols.doubleVertical}`;
+  lines.push(`  ${colorFn(emptyLine)}`);
+  const titleContent = `${statusSymbol}  ${theme.bold(colorFn(title))}`;
+  const strippedTitleLength = stripAnsi3(titleContent).length;
+  const leftPad = Math.max(0, Math.floor((innerWidth - strippedTitleLength) / 2));
+  const rightPad = Math.max(0, innerWidth - strippedTitleLength - leftPad);
+  const titleLine = `${symbols.doubleVertical} ${" ".repeat(leftPad)}${titleContent}${" ".repeat(rightPad)} ${symbols.doubleVertical}`;
+  lines.push(`  ${colorFn(symbols.doubleVertical)} ${" ".repeat(leftPad)}${titleContent}${" ".repeat(rightPad)} ${colorFn(symbols.doubleVertical)}`);
+  lines.push(`  ${colorFn(emptyLine)}`);
+  const bottomBorder = `${symbols.doubleBottomLeft}${symbols.doubleHorizontal.repeat(boxWidth - 2)}${symbols.doubleBottomRight}`;
+  lines.push(`  ${colorFn(bottomBorder)}`);
+  return lines;
+}
+function renderComponentCounts(counts, theme) {
+  const bullet = theme.symbolSet.bullet;
+  const lines = [];
+  lines.push(`  ${theme.bold(theme.colorize("Components installed:", "header"))}`);
+  const items = [
+    { label: "agents", count: counts.agents },
+    { label: "skills", count: counts.skills },
+    { label: "commands", count: counts.commands },
+    { label: "TypeScript CLI files", count: counts.cliFiles },
+    { label: "configuration files", count: counts.other }
+  ];
+  for (const item of items) {
+    if (item.count > 0) {
+      const countStr = theme.colorize(String(item.count), "accent");
+      lines.push(`    ${bullet} ${countStr} ${item.label}`);
+    }
+  }
+  return lines;
+}
+function renderFileStatistics(summary, theme) {
+  const lines = [];
+  lines.push(`  ${theme.bold(theme.colorize("File statistics:", "header"))}`);
+  const copiedSymbol = theme.statusSymbol("completed");
+  lines.push(`    ${copiedSymbol} ${summary.totalFilesCopied} files copied successfully`);
+  const skippedSymbol = theme.statusSymbol("skipped");
+  if (summary.totalFilesSkipped > 0) {
+    lines.push(
+      `    ${skippedSymbol} ${summary.totalFilesSkipped} files skipped (already up-to-date)`
+    );
+  }
+  const failedSymbol = theme.statusSymbol("failed");
+  const failedText = summary.totalFilesFailed > 0 ? `${summary.totalFilesFailed} files failed` : "0 files failed";
+  lines.push(`    ${failedSymbol} ${failedText}`);
+  return lines;
+}
+function renderNextSteps(steps, theme) {
+  const lines = [];
+  lines.push(`  ${theme.bold(theme.colorize("Next steps:", "header"))}`);
+  lines.push("");
+  for (const step of steps) {
+    lines.push(`    ${step.order}. ${step.title}:`);
+    if (step.command) {
+      lines.push(`       ${theme.colorize(step.command, "accent")}`);
+    } else {
+      lines.push(`       ${step.instruction}`);
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function renderDivider(theme, width) {
+  const dividerWidth = Math.min(width - 4, 72);
+  const char = theme.symbolSet.boxHorizontal;
+  return `  ${theme.dim(char.repeat(dividerWidth))}`;
+}
+function stripAnsi3(text2) {
+  return text2.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function getDefaultNextSteps(success) {
+  if (success) {
+    return [
+      {
+        order: 1,
+        title: "Verify the installation",
+        instruction: "Run the status command to verify",
+        command: "ai-dlc status"
+      },
+      {
+        order: 2,
+        title: "Start your first AI-DLC project",
+        instruction: "Create an intent to begin",
+        command: 'ai-dlc start-intent "Your project idea"'
+      },
+      {
+        order: 3,
+        title: "View available commands",
+        instruction: "See all available commands",
+        command: "ai-dlc help"
+      },
+      {
+        order: 4,
+        title: "Read the documentation",
+        instruction: "Visit the documentation site",
+        command: "https://github.com/SixSevenAI/ai-dlc/docs"
+      }
+    ];
+  }
+  return [
+    {
+      order: 1,
+      title: "Review the error messages above",
+      instruction: "Identify the root cause of the failure",
+      command: null
+    },
+    {
+      order: 2,
+      title: "Fix the underlying issue",
+      instruction: "Address permissions, disk space, or network issues",
+      command: null
+    },
+    {
+      order: 3,
+      title: "Run the installer again",
+      instruction: "Retry the installation",
+      command: "npx @sixsevenai/ai-dlc install"
+    },
+    {
+      order: 4,
+      title: "Get help",
+      instruction: "Report an issue on GitHub",
+      command: "https://github.com/SixSevenAI/ai-dlc/issues"
+    }
+  ];
+}
+
+// src/orchestrator/error-handler.ts
+var MAX_RETRIES = 2;
+var errorCounter = 0;
+var ErrorHandler = class {
+  errors = [];
+  retryCounts = /* @__PURE__ */ new Map();
+  /**
+   * Classify an error and determine the recovery action.
+   *
+   * @param error - Raw error from any subsystem
+   * @param stepId - The workflow step where the error occurred
+   * @returns Recovery action to take
+   */
+  handleError(error, stepId) {
+    const category = classifyCategory(error);
+    const severity = classifySeverity(category);
+    const recoveryStrategy = selectRecoveryStrategy(category, severity, this.canRetry(stepId));
+    const classified = {
+      errorId: `err-${++errorCounter}`,
+      originalError: error,
+      category,
+      severity,
+      sourceStep: stepId,
+      recoveryStrategy,
+      retryCount: this.getRetryCount(stepId),
+      timestamp: /* @__PURE__ */ new Date(),
+      userMessage: buildUserMessage(category, error),
+      technicalDetail: error.stack ?? error.message
+    };
+    this.errors.push(classified);
+    return {
+      strategy: recoveryStrategy,
+      stepId,
+      userGuidance: buildUserGuidance(category, error),
+      platformGuidance: buildPlatformGuidance(category)
+    };
+  }
+  /**
+   * Check whether the specified step can be retried.
+   */
+  canRetry(stepId) {
+    return this.getRetryCount(stepId) < MAX_RETRIES;
+  }
+  /**
+   * Record a retry attempt for a step.
+   */
+  recordRetry(stepId) {
+    const current = this.retryCounts.get(stepId) ?? 0;
+    this.retryCounts.set(stepId, current + 1);
+  }
+  /**
+   * Get the current retry count for a step.
+   */
+  getRetryCount(stepId) {
+    return this.retryCounts.get(stepId) ?? 0;
+  }
+  /**
+   * Check if the workflow should abort due to accumulated errors.
+   */
+  shouldAbort() {
+    return this.errors.some((e) => e.severity === "Fatal");
+  }
+  /**
+   * Get a summary of all accumulated errors.
+   */
+  getErrorSummary() {
+    const fatalCount = this.errors.filter((e) => e.severity === "Fatal").length;
+    const recoverableCount = this.errors.filter((e) => e.severity === "Recoverable").length;
+    const warningCount = this.errors.filter((e) => e.severity === "Warning").length;
+    return {
+      totalErrors: this.errors.length,
+      fatalCount,
+      recoverableCount,
+      warningCount,
+      messages: this.errors.map((e) => e.userMessage)
+    };
+  }
+  /**
+   * Determine the appropriate exit code based on workflow state and errors.
+   */
+  getExitCode(workflow) {
+    if (workflow.status === "cancelled") {
+      return EXIT_CANCELLED;
+    }
+    if (workflow.status === "failed") {
+      return EXIT_ERROR;
+    }
+    if (this.errors.some((e) => e.severity === "Fatal")) {
+      return EXIT_ERROR;
+    }
+    return EXIT_SUCCESS;
+  }
+  /**
+   * Get all classified errors for inspection.
+   */
+  getErrors() {
+    return this.errors;
+  }
+};
+function classifyCategory(error) {
+  if (error instanceof UserCancellationError || error.name === "UserCancellationError") {
+    return "Cancellation";
+  }
+  const message = error.message.toLowerCase();
+  const code = error.code;
+  if (code === "EACCES" || code === "EPERM" || message.includes("permission denied")) {
+    return "Permission";
+  }
+  if (code === "ENOSPC" || message.includes("disk full") || message.includes("no space")) {
+    return "DiskSpace";
+  }
+  if (code === "ENOENT" || code === "ENOTDIR" || message.includes("invalid path") || message.includes("not a directory") || message.includes("does not exist")) {
+    return "InvalidPath";
+  }
+  if (message.includes("node.js") || message.includes("node version") || message.includes("npm") || message.includes("minimum required")) {
+    return "RuntimeVersion";
+  }
+  if (message.includes("validation") || message.includes("missing files") || message.includes("corrupt")) {
+    return "ValidationFailure";
+  }
+  if (message.includes("integrity") || message.includes("hash") || message.includes("source directory")) {
+    return "IntegrityError";
+  }
+  if (message.includes("conflict") || message.includes("overwrite")) {
+    return "ConflictResolution";
+  }
+  return "InternalError";
+}
+function classifySeverity(category) {
+  switch (category) {
+    case "Cancellation":
+      return "Fatal";
+    case "DiskSpace":
+      return "Fatal";
+    case "IntegrityError":
+      return "Fatal";
+    case "RuntimeVersion":
+      return "Fatal";
+    case "Permission":
+      return "Recoverable";
+    case "InvalidPath":
+      return "Recoverable";
+    case "ConflictResolution":
+      return "Recoverable";
+    case "ValidationFailure":
+      return "Fatal";
+    case "InternalError":
+      return "Fatal";
+  }
+}
+function selectRecoveryStrategy(category, severity, canRetry) {
+  if (category === "Cancellation") {
+    return "AbortImmediately";
+  }
+  if (severity === "Fatal") {
+    return "RollbackAndAbort";
+  }
+  if (severity === "Recoverable" && canRetry) {
+    return "PromptUser";
+  }
+  if (severity === "Recoverable") {
+    return "RollbackAndAbort";
+  }
+  return "SkipAndContinue";
+}
+function buildUserMessage(category, error) {
+  switch (category) {
+    case "Permission":
+      return `Permission denied: ${error.message}`;
+    case "DiskSpace":
+      return `Insufficient disk space: ${error.message}`;
+    case "InvalidPath":
+      return `Invalid path: ${error.message}`;
+    case "RuntimeVersion":
+      return `Runtime requirement not met: ${error.message}`;
+    case "ValidationFailure":
+      return `Installation validation failed: ${error.message}`;
+    case "IntegrityError":
+      return `Source integrity error: ${error.message}`;
+    case "ConflictResolution":
+      return `Conflict resolution failed: ${error.message}`;
+    case "Cancellation":
+      return "Installation cancelled by user.";
+    case "InternalError":
+      return `Unexpected error: ${error.message}`;
+  }
+}
+function buildUserGuidance(category, error) {
+  switch (category) {
+    case "Permission":
+      return "Run the installer with elevated permissions or choose a different target directory.";
+    case "DiskSpace":
+      return "Free up disk space and try again.";
+    case "InvalidPath":
+      return "Check that the target directory path is valid and the parent directory exists.";
+    case "RuntimeVersion":
+      return "Upgrade Node.js to version 18 or later. Visit https://nodejs.org/";
+    case "ValidationFailure":
+      return "Try running the installer again. If the problem persists, check file permissions.";
+    case "IntegrityError":
+      return "The AI-DLC library source may be corrupted. Re-clone the repository or re-install the package.";
+    case "ConflictResolution":
+      return "Use --force to overwrite existing files, or manually resolve conflicts.";
+    case "Cancellation":
+      return "Installation was cancelled. No changes were made.";
+    case "InternalError":
+      return "This is an unexpected error. Please report it with the --verbose output.";
+  }
+}
+function buildPlatformGuidance(category) {
+  switch (category) {
+    case "Permission":
+      return process.platform === "win32" ? 'Right-click your terminal and select "Run as Administrator".' : "Prefix the command with sudo: sudo sixsevenai install";
+    default:
+      return null;
+  }
+}
+
+// src/platform/types.ts
+function createNormalizedPath(value) {
+  return value;
+}
+var PlatformError = class extends Error {
+  code;
+  component;
+  context;
+  constructor(code, component, message, context) {
+    super(message);
+    this.name = "PlatformError";
+    this.code = code;
+    this.component = component;
+    this.context = context;
+  }
+};
+function parseSemVer(versionString) {
+  const cleaned = versionString.trim().replace(/^v/i, "");
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(cleaned);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    raw: versionString.trim()
+  };
+}
+function semVerSatisfiesMinimum(version2, minimum) {
+  if (version2.major !== minimum.major) {
+    return version2.major > minimum.major;
+  }
+  if (version2.minor !== minimum.minor) {
+    return version2.minor > minimum.minor;
+  }
+  return version2.patch >= minimum.patch;
+}
+function semVer(major, minor, patch) {
+  return {
+    major,
+    minor,
+    patch,
+    raw: `${major}.${minor}.${patch}`
+  };
+}
+
+// src/platform/detector.ts
+import * as os from "os";
+function resolveOsFamily(platform) {
+  switch (platform) {
+    case "win32":
+      return "windows";
+    case "darwin":
+      return "macos";
+    case "linux":
+      return "linux";
+    default:
+      throw new PlatformError(
+        "UNSUPPORTED_PLATFORM",
+        "PlatformDetector",
+        `Unsupported platform: "${platform}". Only Windows, macOS, and Linux are supported.`,
+        { platform }
+      );
+  }
+}
+function resolveArchitecture(arch) {
+  const archMap = {
+    x64: "x64",
+    arm64: "arm64",
+    ia32: "x86",
+    x86: "x86"
+  };
+  const name = archMap[arch];
+  if (name) {
+    return { name };
+  }
+  return { name: "x64" };
+}
+function resolveReleaseName(family, version2) {
+  switch (family) {
+    case "windows": {
+      try {
+        const osVersion = os.version();
+        if (osVersion) {
+          return osVersion;
+        }
+      } catch {
+      }
+      return `Windows NT ${version2}`;
+    }
+    case "macos": {
+      const majorMinor = version2.split(".").slice(0, 2).join(".");
+      const macVersionNames = {
+        "24": "Sequoia",
+        "23": "Sonoma",
+        "22": "Ventura",
+        "21": "Monterey",
+        "20": "Big Sur",
+        "19": "Catalina"
+      };
+      const major = version2.split(".")[0];
+      const name = macVersionNames[major];
+      return name ? `macOS ${name} ${majorMinor}` : `macOS ${majorMinor}`;
+    }
+    case "linux": {
+      try {
+        const osVersion = os.version();
+        if (osVersion) {
+          return osVersion;
+        }
+      } catch {
+      }
+      return `Linux ${version2}`;
+    }
+  }
+}
+function resolveHomeDirectory(family) {
+  if (family === "windows") {
+    const userProfile = process.env["USERPROFILE"];
+    if (userProfile) {
+      return { path: userProfile, source: "USERPROFILE" };
+    }
+  }
+  const home = process.env["HOME"];
+  if (home) {
+    return { path: home, source: "HOME" };
+  }
+  return { path: os.homedir(), source: "os.homedir" };
+}
+function resolveTempDirectory() {
+  return { path: os.tmpdir() };
+}
+var PlatformDetector = class {
+  /**
+   * Detect platform information and return an immutable PlatformSnapshot.
+   *
+   * @throws PlatformError with code UNSUPPORTED_PLATFORM if the OS is not
+   *         win32, darwin, or linux.
+   */
+  detect() {
+    const family = resolveOsFamily(process.platform);
+    const version2 = os.release();
+    const release3 = resolveReleaseName(family, version2);
+    const architecture = resolveArchitecture(process.arch);
+    const operatingSystem = {
+      family,
+      version: version2,
+      release: release3,
+      architecture
+    };
+    const homeDirectory = resolveHomeDirectory(family);
+    const tempDirectory = resolveTempDirectory();
+    return {
+      os: operatingSystem,
+      homeDirectory,
+      tempDirectory,
+      detectedAt: /* @__PURE__ */ new Date()
+    };
+  }
+};
+
+// src/platform/paths.ts
+function hasDriveLetter(path7) {
+  return /^[a-zA-Z]:[/\\]/.test(path7);
+}
+function isUncPath(path7) {
+  return /^[/\\]{2}[^/\\]/.test(path7);
+}
+function resolveSegments(segments) {
+  const resolved = [];
+  for (const segment of segments) {
+    if (segment === "." || segment === "") {
+      continue;
+    }
+    if (segment === "..") {
+      if (resolved.length > 0) {
+        resolved.pop();
+      }
+      continue;
+    }
+    resolved.push(segment);
+  }
+  return resolved;
+}
+var PathNormalizer = class {
+  /**
+   * Convert a platform-native path to normalized internal form (forward slashes).
+   *
+   * Rules:
+   * 1. Replace all backslashes with forward slashes
+   * 2. Uppercase Windows drive letters (c:/ -> C:/)
+   * 3. Preserve UNC path prefix (\\server\share -> //server/share)
+   * 4. Resolve . and .. segments
+   * 5. Strip trailing separator (except root paths like / or C:/)
+   * 6. Collapse double separators (except UNC prefix)
+   *
+   * @throws PlatformError with code INVALID_PATH for empty input
+   */
+  normalize(rawPath, os3) {
+    if (!rawPath || rawPath.trim().length === 0) {
+      throw new PlatformError(
+        "INVALID_PATH",
+        "PathNormalizer",
+        "Path cannot be empty",
+        { rawPath }
+      );
+    }
+    let path7 = rawPath;
+    path7 = path7.replace(/\\/g, "/");
+    let uncPrefix = "";
+    if (isUncPath(rawPath)) {
+      uncPrefix = "//";
+      path7 = path7.slice(2);
+    }
+    if (os3.family === "windows" && hasDriveLetter(path7)) {
+      path7 = path7[0].toUpperCase() + path7.slice(1);
+    }
+    const segments = path7.split("/");
+    let root = "";
+    if (uncPrefix) {
+      const server = segments[0];
+      const share = segments[1];
+      root = `${uncPrefix}${server}/${share}`;
+      segments.splice(0, 2);
+    } else if (hasDriveLetter(path7)) {
+      root = segments[0] + "/";
+      segments.splice(0, 1);
+    } else if (path7.startsWith("/")) {
+      root = "/";
+      segments.splice(0, 1);
+    }
+    const resolved = resolveSegments(segments);
+    let normalized = root + resolved.join("/");
+    if (!uncPrefix) {
+      normalized = normalized.replace(/\/{2,}/g, "/");
+    }
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+      const isRootPath = normalized === "/" || /^[A-Z]:\/$/.test(normalized) || /^\/\/[^/]+\/[^/]+\/?$/.test(normalized);
+      if (!isRootPath) {
+        normalized = normalized.replace(/\/+$/, "");
+      }
+    }
+    return createNormalizedPath(normalized);
+  }
+  /**
+   * Convert a normalized path back to platform-native form for OS API calls.
+   * On Windows, replaces forward slashes with backslashes.
+   * On Unix, returns as-is.
+   */
+  toNative(path7, os3) {
+    if (os3.family === "windows") {
+      return path7.replace(/\//g, "\\");
+    }
+    return path7;
+  }
+  /**
+   * Replace home directory tokens (~, $HOME, %USERPROFILE%) with the
+   * actual home directory path.
+   *
+   * Token expansion happens before normalization:
+   * - ~ or ~/ at the start of the path
+   * - $HOME at the start of the path
+   * - %USERPROFILE% at the start of the path
+   *
+   * @throws PlatformError with code INVALID_PATH for empty input
+   */
+  resolveHome(path7, homeDir) {
+    if (!path7 || path7.trim().length === 0) {
+      throw new PlatformError(
+        "INVALID_PATH",
+        "PathNormalizer",
+        "Path cannot be empty",
+        { path: path7 }
+      );
+    }
+    let resolved = path7;
+    const normalizedHome = homeDir.path.replace(/\\/g, "/");
+    if (resolved === "~") {
+      resolved = normalizedHome;
+    } else if (resolved.startsWith("~/") || resolved.startsWith("~\\")) {
+      resolved = normalizedHome + "/" + resolved.slice(2);
+    }
+    if (resolved === "$HOME") {
+      resolved = normalizedHome;
+    } else if (resolved.startsWith("$HOME/") || resolved.startsWith("$HOME\\")) {
+      resolved = normalizedHome + "/" + resolved.slice(6);
+    }
+    if (resolved === "%USERPROFILE%") {
+      resolved = normalizedHome;
+    } else if (resolved.startsWith("%USERPROFILE%/") || resolved.startsWith("%USERPROFILE%\\")) {
+      resolved = normalizedHome + "/" + resolved.slice(14);
+    }
+    const family = normalizedHome.match(/^[A-Z]:/i) ? "windows" : "linux";
+    const os3 = {
+      family,
+      version: "",
+      release: "",
+      architecture: { name: "x64" }
+    };
+    return this.normalize(resolved, os3);
+  }
+  /**
+   * Convert a relative path to absolute using the given base path.
+   * If the path is already absolute, returns it unchanged.
+   */
+  toAbsolute(path7, basePath) {
+    if (this.isAbsolute(path7)) {
+      return path7;
+    }
+    return createNormalizedPath(
+      this.stripTrailing(basePath) + "/" + path7
+    );
+  }
+  /**
+   * Convert an absolute path to relative from the given base path.
+   * If the path is not under the base, returns the original absolute path.
+   */
+  toRelative(path7, basePath) {
+    const normalBase = this.stripTrailing(basePath);
+    const normalPath = this.stripTrailing(path7);
+    if (!normalPath.startsWith(normalBase + "/") && normalPath !== normalBase) {
+      const pathParts = normalPath.split("/");
+      const baseParts = normalBase.split("/");
+      let commonLength = 0;
+      while (commonLength < pathParts.length && commonLength < baseParts.length && pathParts[commonLength] === baseParts[commonLength]) {
+        commonLength++;
+      }
+      const upCount = baseParts.length - commonLength;
+      const upSegments = Array(upCount).fill("..");
+      const downSegments = pathParts.slice(commonLength);
+      const relativeParts = [...upSegments, ...downSegments];
+      return createNormalizedPath(
+        relativeParts.length > 0 ? relativeParts.join("/") : "."
+      );
+    }
+    if (normalPath === normalBase) {
+      return createNormalizedPath(".");
+    }
+    return createNormalizedPath(normalPath.slice(normalBase.length + 1));
+  }
+  /**
+   * Join path segments, normalizing the result.
+   * The base path is used as the starting point.
+   */
+  join(base, ...segments) {
+    const allSegments = [base, ...segments].filter(Boolean);
+    const joined = allSegments.join("/");
+    const isWindows = /^[A-Z]:/i.test(base);
+    const os3 = {
+      family: isWindows ? "windows" : "linux",
+      version: "",
+      release: "",
+      architecture: { name: "x64" }
+    };
+    return this.normalize(joined, os3);
+  }
+  /**
+   * Return the parent directory path, or null for root paths.
+   */
+  parent(path7) {
+    const stripped = this.stripTrailing(path7);
+    if (stripped === "/" || /^[A-Z]:\/?$/i.test(stripped)) {
+      return null;
+    }
+    if (/^\/\/[^/]+\/[^/]+\/?$/.test(stripped)) {
+      return null;
+    }
+    const lastSlash = stripped.lastIndexOf("/");
+    if (lastSlash === -1) {
+      return null;
+    }
+    if (lastSlash === 0) {
+      return createNormalizedPath("/");
+    }
+    const parentStr = stripped.slice(0, lastSlash);
+    if (/^[A-Z]:$/i.test(parentStr)) {
+      return createNormalizedPath(parentStr + "/");
+    }
+    return createNormalizedPath(parentStr);
+  }
+  /**
+   * Extract file extension (without leading dot), or null if none.
+   */
+  extension(path7) {
+    const stripped = this.stripTrailing(path7);
+    const lastSlash = stripped.lastIndexOf("/");
+    const filename = lastSlash >= 0 ? stripped.slice(lastSlash + 1) : stripped;
+    if (filename.startsWith(".") && filename.indexOf(".", 1) === -1) {
+      return null;
+    }
+    const lastDot = filename.lastIndexOf(".");
+    if (lastDot <= 0) {
+      return null;
+    }
+    return filename.slice(lastDot + 1);
+  }
+  /**
+   * Get the default .claude directory path for the given home directory.
+   */
+  getDefaultClaudeDir(homeDir, os3) {
+    const homePath = this.normalize(homeDir.path, os3);
+    return this.join(homePath, ".claude");
+  }
+  /**
+   * Check if a normalized path is absolute.
+   */
+  isAbsolute(path7) {
+    return path7.startsWith("/") || /^[A-Z]:\//i.test(path7) || path7.startsWith("//");
+  }
+  /**
+   * Strip trailing slash from a path (preserving root paths).
+   */
+  stripTrailing(path7) {
+    if (path7 === "/" || /^[A-Z]:\/$/.test(path7) || /^\/\/[^/]+\/[^/]+\/$/.test(path7)) {
+      return path7;
+    }
+    return path7.replace(/\/+$/, "");
+  }
+};
+
+// src/platform/permissions.ts
+import * as fs2 from "fs";
+import { execSync } from "child_process";
+async function statPath(nativePath) {
+  try {
+    const stat5 = await fs2.promises.stat(nativePath);
+    return { exists: true, isDirectory: stat5.isDirectory() };
+  } catch {
+    return { exists: false, isDirectory: false };
+  }
+}
+async function checkPermission(nativePath, flag) {
+  try {
+    await fs2.promises.access(nativePath, flag);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildElevationInstructions(platform, targetPath) {
+  const family = platform.os.family;
+  switch (family) {
+    case "windows":
+      return {
+        platform: "windows",
+        command: "Run terminal as Administrator",
+        description: "Right-click your terminal and select 'Run as Administrator', then re-run the command.",
+        shellSpecificHint: "In PowerShell: Start-Process pwsh -Verb RunAs"
+      };
+    case "macos":
+      return {
+        platform: "macos",
+        command: `sudo sixsevenai install --target "${targetPath}"`,
+        description: "Prefix the command with sudo to run with root privileges.",
+        shellSpecificHint: null
+      };
+    case "linux":
+      return {
+        platform: "linux",
+        command: `sudo sixsevenai install --target "${targetPath}"`,
+        description: "Prefix the command with sudo to run with root privileges.",
+        shellSpecificHint: null
+      };
+  }
+}
+function findNearestExistingParent(nativePath) {
+  let current = nativePath;
+  while (true) {
+    try {
+      const stat5 = fs2.statSync(current);
+      if (stat5.isDirectory()) {
+        return current;
+      }
+    } catch {
+    }
+    const parent = getParentNative(current);
+    if (!parent || parent === current) {
+      return current;
+    }
+    current = parent;
+  }
+}
+function getParentNative(nativePath) {
+  const normalized = nativePath.replace(/\\/g, "/");
+  const lastSlash = normalized.lastIndexOf("/");
+  if (lastSlash <= 0) {
+    return null;
+  }
+  if (/^[A-Z]:\/?$/i.test(normalized)) {
+    return null;
+  }
+  const parent = normalized.slice(0, lastSlash);
+  if (/^[A-Z]:$/i.test(parent)) {
+    return parent + "/";
+  }
+  return parent || "/";
+}
+var PermissionChecker = class {
+  pathNormalizer = new PathNormalizer();
+  /**
+   * Check access to a path with the specified access mode.
+   * Never throws -- returns a PermissionResult with appropriate flags.
+   */
+  async checkAccess(path7, desiredAccess, platform) {
+    const nativePath = this.pathNormalizer.toNative(path7, platform.os);
+    const now = /* @__PURE__ */ new Date();
+    try {
+      const { exists, isDirectory } = await statPath(nativePath);
+      if (!exists) {
+        return {
+          targetPath: path7,
+          canRead: false,
+          canWrite: false,
+          canExecute: false,
+          exists: false,
+          isDirectory: false,
+          requiresElevation: false,
+          elevationInstructions: null,
+          checkedAt: now
+        };
+      }
+      const canRead = await checkPermission(nativePath, fs2.constants.R_OK);
+      const canWrite = await checkPermission(nativePath, fs2.constants.W_OK);
+      const canExecute = await checkPermission(nativePath, fs2.constants.X_OK);
+      let needsElevation = false;
+      switch (desiredAccess) {
+        case "read":
+          needsElevation = !canRead;
+          break;
+        case "write":
+          needsElevation = !canWrite;
+          break;
+        case "execute":
+          needsElevation = !canExecute;
+          break;
+        case "readwrite":
+          needsElevation = !canRead || !canWrite;
+          break;
+      }
+      const elevationInstructions = needsElevation ? buildElevationInstructions(platform, nativePath) : null;
+      return {
+        targetPath: path7,
+        canRead,
+        canWrite,
+        canExecute,
+        exists,
+        isDirectory,
+        requiresElevation: needsElevation,
+        elevationInstructions,
+        checkedAt: now
+      };
+    } catch {
+      return {
+        targetPath: path7,
+        canRead: false,
+        canWrite: false,
+        canExecute: false,
+        exists: false,
+        isDirectory: false,
+        requiresElevation: false,
+        elevationInstructions: null,
+        checkedAt: now
+      };
+    }
+  }
+  /**
+   * Convenience method: check write access to a path.
+   */
+  async checkWriteAccess(path7, platform) {
+    return this.checkAccess(path7, "write", platform);
+  }
+  /**
+   * Check whether a directory can be created at the given path.
+   * If the path does not exist, checks permissions on the nearest
+   * existing parent directory.
+   */
+  async checkDirectoryCreatable(path7, platform) {
+    const nativePath = this.pathNormalizer.toNative(path7, platform.os);
+    const now = /* @__PURE__ */ new Date();
+    try {
+      const { exists, isDirectory } = await statPath(nativePath);
+      if (exists) {
+        if (isDirectory) {
+          return this.checkAccess(path7, "write", platform);
+        }
+        return {
+          targetPath: path7,
+          canRead: false,
+          canWrite: false,
+          canExecute: false,
+          exists: true,
+          isDirectory: false,
+          requiresElevation: false,
+          elevationInstructions: null,
+          checkedAt: now
+        };
+      }
+      const nearestParent = findNearestExistingParent(nativePath);
+      const canWriteParent = await checkPermission(
+        nearestParent,
+        fs2.constants.W_OK
+      );
+      const needsElevation = !canWriteParent;
+      const elevationInstructions = needsElevation ? buildElevationInstructions(platform, nativePath) : null;
+      return {
+        targetPath: path7,
+        canRead: false,
+        canWrite: canWriteParent,
+        canExecute: false,
+        exists: false,
+        isDirectory: false,
+        requiresElevation: needsElevation,
+        elevationInstructions,
+        checkedAt: now
+      };
+    } catch {
+      return {
+        targetPath: path7,
+        canRead: false,
+        canWrite: false,
+        canExecute: false,
+        exists: false,
+        isDirectory: false,
+        requiresElevation: false,
+        elevationInstructions: null,
+        checkedAt: now
+      };
+    }
+  }
+  /**
+   * Detect whether the current process is running with elevated privileges.
+   *
+   * - Unix: checks process.getuid() === 0
+   * - Windows: executes `net session` via child_process.execSync
+   *
+   * Never throws. Returns false on detection failure.
+   */
+  async detectElevation(platform) {
+    try {
+      if (platform.os.family === "windows") {
+        return this.detectWindowsElevation();
+      }
+      return this.detectUnixElevation();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Detect whether symbolic links can be created on the current platform.
+   *
+   * - Unix: always supported (no restrictions)
+   * - Windows: depends on Developer Mode and/or elevation status
+   */
+  async checkSymlinkCapability(platform) {
+    if (platform.os.family !== "windows") {
+      return {
+        supported: true,
+        requiresDeveloperMode: false,
+        requiresElevation: false,
+        instructions: null
+      };
+    }
+    const isElevated = await this.detectElevation(platform);
+    if (isElevated) {
+      return {
+        supported: true,
+        requiresDeveloperMode: false,
+        requiresElevation: false,
+        instructions: null
+      };
+    }
+    const hasDeveloperMode = this.checkWindowsDeveloperMode();
+    if (hasDeveloperMode) {
+      return {
+        supported: true,
+        requiresDeveloperMode: false,
+        requiresElevation: false,
+        instructions: null
+      };
+    }
+    return {
+      supported: false,
+      requiresDeveloperMode: true,
+      requiresElevation: true,
+      instructions: "Enable Developer Mode in Windows Settings > For developers, or run the installer as Administrator."
+    };
+  }
+  /**
+   * Detect Windows elevation by running `net session`.
+   * If it succeeds, the process is elevated. If it fails with exit code 5
+   * (Access denied), the process is not elevated.
+   */
+  detectWindowsElevation() {
+    try {
+      execSync("net session", {
+        stdio: "pipe",
+        timeout: 5e3
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Detect Unix elevation by checking the effective user ID.
+   */
+  detectUnixElevation() {
+    if (typeof process.getuid === "function") {
+      return process.getuid() === 0;
+    }
+    return false;
+  }
+  /**
+   * Check if Windows Developer Mode is enabled by reading the registry.
+   */
+  checkWindowsDeveloperMode() {
+    try {
+      const result = execSync(
+        'reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\AppModelUnlock" /v AllowDevelopmentWithoutDevLicense',
+        { stdio: "pipe", timeout: 5e3 }
+      ).toString();
+      return result.includes("0x1");
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/platform/terminal.ts
+import * as os2 from "os";
+function detectEmulator() {
+  const env = process.env;
+  if (env["WT_SESSION"]) {
+    return {
+      name: "Windows Terminal",
+      version: env["WT_SESSION"] ?? null,
+      isKnown: true
+    };
+  }
+  if (env["TERM_PROGRAM"] === "vscode") {
+    return {
+      name: "VS Code Terminal",
+      version: env["TERM_PROGRAM_VERSION"] ?? null,
+      isKnown: true
+    };
+  }
+  if (env["TERM_PROGRAM"] === "iTerm.app") {
+    return {
+      name: "iTerm2",
+      version: env["TERM_PROGRAM_VERSION"] ?? null,
+      isKnown: true
+    };
+  }
+  if (env["TERM_PROGRAM"] === "Apple_Terminal") {
+    return {
+      name: "Apple Terminal",
+      version: env["TERM_PROGRAM_VERSION"] ?? null,
+      isKnown: true
+    };
+  }
+  if (env["ConEmuPID"] || env["ConEmuANSI"]) {
+    return {
+      name: "ConEmu",
+      version: null,
+      isKnown: true
+    };
+  }
+  if (env["GNOME_TERMINAL_SERVICE"] || env["GNOME_TERMINAL_SCREEN"]) {
+    return {
+      name: "GNOME Terminal",
+      version: null,
+      isKnown: true
+    };
+  }
+  if (env["TERM_PROGRAM"] === "Hyper") {
+    return {
+      name: "Hyper",
+      version: env["TERM_PROGRAM_VERSION"] ?? null,
+      isKnown: true
+    };
+  }
+  if (env["TERM_PROGRAM"] === "Alacritty" || env["ALACRITTY_LOG"]) {
+    return {
+      name: "Alacritty",
+      version: null,
+      isKnown: true
+    };
+  }
+  if (env["TERM"] === "xterm-kitty" || env["KITTY_WINDOW_ID"]) {
+    return {
+      name: "Kitty",
+      version: null,
+      isKnown: true
+    };
+  }
+  if (env["TERM_PROGRAM"] === "WezTerm") {
+    return {
+      name: "WezTerm",
+      version: env["TERM_PROGRAM_VERSION"] ?? null,
+      isKnown: true
+    };
+  }
+  if (env["TERM_PROGRAM"]) {
+    return {
+      name: env["TERM_PROGRAM"],
+      version: env["TERM_PROGRAM_VERSION"] ?? null,
+      isKnown: false
+    };
+  }
+  if (env["TERM"] && env["TERM"] !== "dumb") {
+    return {
+      name: env["TERM"],
+      version: null,
+      isKnown: false
+    };
+  }
+  return {
+    name: null,
+    version: null,
+    isKnown: false
+  };
+}
+function parseForcedColor(value) {
+  switch (value) {
+    case "0":
+      return 0 /* None */;
+    case "1":
+    case "true":
+    case "":
+      return 1 /* Basic */;
+    case "2":
+      return 2 /* Extended */;
+    case "3":
+      return 3 /* TrueColor */;
+    default:
+      return null;
+  }
+}
+var TerminalDetector = class {
+  /**
+   * Detect all terminal capabilities and return a complete profile.
+   */
+  detectProfile() {
+    return {
+      colorSupport: this.detectColorSupport(),
+      dimensions: this.detectDimensions(),
+      unicodeSupport: this.detectUnicodeSupport(),
+      interactivity: this.detectInteractivity(),
+      emulator: detectEmulator(),
+      detectedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Detect the color support level of the current terminal.
+   *
+   * Priority chain:
+   * 1. NO_COLOR env var set -> None
+   * 2. FORCE_COLOR env var set -> forced level
+   * 3. stdout is not a TTY -> None
+   * 4. COLORTERM = "truecolor" or "24bit" -> TrueColor
+   * 5. Known terminal emulator -> emulator-specific level
+   * 6. TERM = "xterm-256color" -> Extended
+   * 7. TERM contains "color" -> Basic
+   * 8. Windows version >= 10.0.14393 -> Extended minimum
+   * 9. Default -> Basic
+   */
+  detectColorSupport() {
+    const env = process.env;
+    if ("NO_COLOR" in env) {
+      return 0 /* None */;
+    }
+    if ("FORCE_COLOR" in env) {
+      const forced = parseForcedColor(env["FORCE_COLOR"] ?? "");
+      if (forced !== null) {
+        return forced;
+      }
+    }
+    if (!process.stdout.isTTY) {
+      return 0 /* None */;
+    }
+    const colorTerm = env["COLORTERM"];
+    if (colorTerm === "truecolor" || colorTerm === "24bit") {
+      return 3 /* TrueColor */;
+    }
+    const termProgram = env["TERM_PROGRAM"];
+    if (env["WT_SESSION"]) {
+      return 3 /* TrueColor */;
+    }
+    if (termProgram === "vscode") {
+      return 3 /* TrueColor */;
+    }
+    if (termProgram === "iTerm.app") {
+      return 3 /* TrueColor */;
+    }
+    if (termProgram === "Apple_Terminal") {
+      return 2 /* Extended */;
+    }
+    if (env["ConEmuANSI"] === "ON") {
+      return 2 /* Extended */;
+    }
+    if (env["GNOME_TERMINAL_SERVICE"]) {
+      return 2 /* Extended */;
+    }
+    if (env["TERM"] === "xterm-kitty" || env["KITTY_WINDOW_ID"] || termProgram === "Alacritty" || termProgram === "WezTerm" || termProgram === "Hyper") {
+      return 3 /* TrueColor */;
+    }
+    const term = env["TERM"];
+    if (term === "xterm-256color" || term === "screen-256color") {
+      return 2 /* Extended */;
+    }
+    if (term && /color/i.test(term)) {
+      return 1 /* Basic */;
+    }
+    if (process.platform === "win32") {
+      const osRelease = os2.release();
+      const versionParts = osRelease.split(".");
+      const major = parseInt(versionParts[0], 10);
+      const build = parseInt(versionParts[2], 10);
+      if (major >= 10 && build >= 14393) {
+        return 2 /* Extended */;
+      }
+    }
+    return 1 /* Basic */;
+  }
+  /**
+   * Detect terminal dimensions (columns x rows).
+   * Falls back to 80x24 if detection fails.
+   */
+  detectDimensions() {
+    const columns = process.stdout.columns;
+    const rows = process.stdout.rows;
+    return {
+      columns: columns && columns > 0 ? columns : 80,
+      rows: rows && rows > 0 ? rows : 24
+    };
+  }
+  /**
+   * Subscribe to terminal resize events.
+   * Returns a Disposable to unsubscribe.
+   */
+  onResize(callback) {
+    const handler = () => {
+      callback(this.detectDimensions());
+    };
+    process.stdout.on("resize", handler);
+    return {
+      dispose: () => {
+        process.stdout.removeListener("resize", handler);
+      }
+    };
+  }
+  /**
+   * Detect Unicode support in the terminal.
+   *
+   * Detection methods:
+   * 1. Check LANG, LC_ALL, LC_CTYPE for UTF-8 reference
+   * 2. Check for modern terminal emulators (WT_SESSION, TERM_PROGRAM)
+   * 3. On Windows, check if running in a modern terminal
+   * 4. Default to true on macOS/Linux, false on Windows CMD
+   */
+  detectUnicodeSupport() {
+    const env = process.env;
+    const localeVars = [env["LC_ALL"], env["LC_CTYPE"], env["LANG"]];
+    for (const localeVar of localeVars) {
+      if (localeVar && /utf-?8/i.test(localeVar)) {
+        return { supported: true, detectionMethod: "locale" };
+      }
+    }
+    if (env["WT_SESSION"] || env["TERM_PROGRAM"] === "vscode" || env["TERM_PROGRAM"] === "iTerm.app" || env["TERM_PROGRAM"] === "Hyper" || env["TERM_PROGRAM"] === "Alacritty" || env["TERM_PROGRAM"] === "WezTerm" || env["KITTY_WINDOW_ID"] || env["TERM"] === "xterm-kitty") {
+      return { supported: true, detectionMethod: "terminal" };
+    }
+    if (env["ConEmuANSI"] === "ON") {
+      return { supported: true, detectionMethod: "env" };
+    }
+    if (process.platform === "darwin") {
+      return { supported: true, detectionMethod: "default" };
+    }
+    if (process.platform === "linux") {
+      return { supported: true, detectionMethod: "default" };
+    }
+    if (process.platform === "win32") {
+      return { supported: false, detectionMethod: "default" };
+    }
+    return { supported: true, detectionMethod: "default" };
+  }
+  /**
+   * Detect terminal interactivity mode.
+   */
+  detectInteractivity() {
+    const isTTY = !!process.stdout.isTTY;
+    const isInteractive = !!process.stdin.isTTY;
+    const supportsRawMode = isInteractive && typeof process.stdin.setRawMode === "function";
+    return {
+      isInteractive,
+      isTTY,
+      supportsRawMode
+    };
+  }
+};
+
+// src/platform/shell.ts
+import * as fs3 from "fs";
+function resolveShellType(env, platform) {
+  if (env["PSModulePath"]) {
+    const psPath = env["PSModulePath"] ?? "";
+    const isPwshCore = psPath.includes("PowerShell") && !psPath.includes("WindowsPowerShell");
+    if (platform === "windows") {
+      return {
+        type: "powershell",
+        executablePath: isPwshCore ? "pwsh.exe" : "powershell.exe"
+      };
+    }
+    return {
+      type: "powershell",
+      executablePath: "pwsh"
+    };
+  }
+  const shell = env["SHELL"];
+  if (shell) {
+    const shellName = shell.split("/").pop()?.toLowerCase() ?? "";
+    if (shellName.includes("zsh")) {
+      return { type: "zsh", executablePath: shell };
+    }
+    if (shellName.includes("bash")) {
+      return { type: "bash", executablePath: shell };
+    }
+    if (shellName.includes("fish")) {
+      return { type: "fish", executablePath: shell };
+    }
+  }
+  if (env["MSYSTEM"]) {
+    const bashPath = env["SHELL"] ?? "bash";
+    return { type: "bash", executablePath: bashPath };
+  }
+  if (platform === "windows") {
+    const comspec = env["ComSpec"];
+    if (comspec && comspec.toLowerCase().endsWith("cmd.exe")) {
+      return { type: "cmd", executablePath: comspec };
+    }
+    return { type: "powershell", executablePath: "pwsh.exe" };
+  }
+  if (platform === "macos") {
+    return { type: "zsh", executablePath: "/bin/zsh" };
+  }
+  return { type: "bash", executablePath: "/bin/bash" };
+}
+function resolveProfilePath(shellType, platform, homePath) {
+  const home = homePath.replace(/\\/g, "/");
+  switch (shellType) {
+    case "powershell": {
+      if (platform === "windows") {
+        return `${home}/Documents/PowerShell/Microsoft.PowerShell_profile.ps1`;
+      }
+      return `${home}/.config/powershell/Microsoft.PowerShell_profile.ps1`;
+    }
+    case "bash": {
+      if (platform === "macos") {
+        return `${home}/.bash_profile`;
+      }
+      return `${home}/.bashrc`;
+    }
+    case "zsh":
+      return `${home}/.zshrc`;
+    case "fish":
+      return `${home}/.config/fish/config.fish`;
+    case "cmd":
+      return null;
+    case "unknown":
+      return null;
+  }
+}
+function buildPathModificationCommand(shellType, directory, profilePath) {
+  switch (shellType) {
+    case "powershell":
+      return `$env:PATH = "${directory}" + [System.IO.Path]::PathSeparator + $env:PATH`;
+    case "bash":
+    case "zsh":
+      return `export PATH="${directory}:$PATH"`;
+    case "fish":
+      return `set -gx PATH "${directory}" $PATH`;
+    case "cmd":
+      return `set PATH=${directory};%PATH%`;
+    case "unknown":
+      return null;
+  }
+}
+function detectShellVersion(shellType, env) {
+  switch (shellType) {
+    case "bash": {
+      return env["BASH_VERSION"] ?? null;
+    }
+    case "zsh": {
+      return env["ZSH_VERSION"] ?? null;
+    }
+    case "fish": {
+      return env["FISH_VERSION"] ?? null;
+    }
+    case "powershell": {
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+var ShellDetector = class {
+  pathNormalizer = new PathNormalizer();
+  /**
+   * Detect the active shell and its profile configuration.
+   */
+  async detectShell(platform) {
+    const osFamily = platform.os.family;
+    const env = process.env;
+    const { type, executablePath } = resolveShellType(env, osFamily);
+    const rawProfilePath = resolveProfilePath(
+      type,
+      osFamily,
+      platform.homeDirectory.path
+    );
+    let profilePath = null;
+    let profileExists = false;
+    if (rawProfilePath) {
+      profilePath = this.pathNormalizer.normalize(rawProfilePath, platform.os);
+      const nativePath = this.pathNormalizer.toNative(profilePath, platform.os);
+      try {
+        profileExists = fs3.existsSync(nativePath);
+      } catch {
+        profileExists = false;
+      }
+    }
+    const version2 = detectShellVersion(type, env);
+    const pathModCommand = buildPathModificationCommand(
+      type,
+      "{directory}",
+      rawProfilePath
+    );
+    const pathSeparator = osFamily === "windows" ? ";" : ":";
+    return {
+      type,
+      version: version2,
+      executablePath,
+      profilePath,
+      profileExists,
+      pathSeparator,
+      pathModificationCommand: pathModCommand
+    };
+  }
+  /**
+   * Generate a shell-specific command to add a directory to PATH.
+   * The returned command can be run immediately in the current session.
+   */
+  getPathModificationCommand(shell, directory) {
+    const nativeDir = shell.pathSeparator === ";" ? directory.replace(/\//g, "\\") : directory;
+    const command = buildPathModificationCommand(
+      shell.type,
+      nativeDir,
+      shell.profilePath
+    );
+    return command ?? `# Unable to generate PATH command for ${shell.type} shell`;
+  }
+  /**
+   * Generate a command to open the shell's profile file for editing.
+   * Returns null if the shell has no profile file.
+   */
+  getProfileEditCommand(shell) {
+    if (!shell.profilePath) {
+      return null;
+    }
+    const profileStr = shell.profilePath;
+    switch (shell.type) {
+      case "powershell":
+        return `code "${profileStr}" # or notepad "${profileStr}"`;
+      case "bash":
+      case "zsh":
+      case "fish":
+        return `${process.env["EDITOR"] ?? "nano"} "${profileStr}"`;
+      case "cmd":
+        return null;
+      case "unknown":
+        return null;
+    }
+  }
+};
+
+// src/platform/runtime.ts
+import { execSync as execSync2 } from "child_process";
+var MINIMUM_NODE_VERSION = semVer(18, 0, 0);
+var MINIMUM_NPM_VERSION = semVer(9, 0, 0);
+var COMMAND_TIMEOUT_MS = 1e4;
+function execCommand(command) {
+  try {
+    const result = execSync2(command, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: COMMAND_TIMEOUT_MS
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+function resolveExecutablePath(toolName) {
+  const isWindows = process.platform === "win32";
+  const command = isWindows ? `where ${toolName}` : `which ${toolName}`;
+  const result = execCommand(command);
+  if (!result) return null;
+  return result.split(/\r?\n/)[0].trim();
+}
+var RuntimeValidator = class {
+  /**
+   * Run all runtime validation checks and return a complete RuntimeReport.
+   */
+  async validate(minimumNode, minimumNpm) {
+    const errors = [];
+    const node = this.checkNodeVersion(minimumNode);
+    if (!node.meetsMinimum) {
+      errors.push({
+        tool: "node",
+        errorType: "version_too_low",
+        message: `Node.js ${node.version.raw} is below the minimum required ${minimumNode.raw}.`,
+        fix: `Upgrade Node.js to ${minimumNode.raw} or later. Visit https://nodejs.org/ or use nvm: nvm install ${minimumNode.major}`
+      });
+    }
+    let npm = null;
+    try {
+      npm = await this.checkNpmVersion(minimumNpm);
+      if (!npm.meetsMinimum) {
+        errors.push({
+          tool: "npm",
+          errorType: "version_too_low",
+          message: `npm ${npm.version.raw} is below the minimum required ${minimumNpm.raw}.`,
+          fix: `Upgrade npm: npm install -g npm@latest`
+        });
+      }
+    } catch {
+      errors.push({
+        tool: "npm",
+        errorType: "not_found",
+        message: "npm is not installed or not available on PATH.",
+        fix: "Install Node.js (which includes npm) from https://nodejs.org/ or install npm separately."
+      });
+    }
+    let git = null;
+    try {
+      const gitResult = await this.checkGitVersion();
+      git = gitResult;
+    } catch {
+    }
+    let globalBinDir = null;
+    if (npm) {
+      try {
+        globalBinDir = await this.resolveGlobalBinDir({
+          type: "unknown",
+          version: null,
+          executablePath: "",
+          profilePath: null,
+          profileExists: false,
+          pathSeparator: process.platform === "win32" ? ";" : ":",
+          pathModificationCommand: null
+        });
+        if (!globalBinDir.isOnPath) {
+          errors.push({
+            tool: "npm",
+            errorType: "not_on_path",
+            message: `npm global bin directory (${globalBinDir.path}) is not on PATH.`,
+            fix: globalBinDir.pathFixCommand ?? `Add ${globalBinDir.path} to your PATH environment variable.`
+          });
+        }
+      } catch {
+      }
+    }
+    const allRequirementsMet = node.meetsMinimum && (npm?.meetsMinimum ?? false) && (globalBinDir?.isOnPath ?? false);
+    return {
+      node,
+      npm,
+      git,
+      globalBinDir,
+      allRequirementsMet,
+      errors,
+      validatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Check Node.js version against the minimum requirement.
+   * This is synchronous since we read from process.version.
+   */
+  checkNodeVersion(minimum) {
+    const rawVersion = process.version;
+    const version2 = parseSemVer(rawVersion);
+    if (!version2) {
+      return {
+        tool: "node",
+        version: semVer(0, 0, 0),
+        executablePath: process.execPath,
+        meetsMinimum: false,
+        minimumRequired: minimum
+      };
+    }
+    return {
+      tool: "node",
+      version: version2,
+      executablePath: process.execPath,
+      meetsMinimum: semVerSatisfiesMinimum(version2, minimum),
+      minimumRequired: minimum
+    };
+  }
+  /**
+   * Check npm version against the minimum requirement.
+   * Executes `npm --version` via child_process.
+   */
+  async checkNpmVersion(minimum) {
+    const rawVersion = execCommand("npm --version");
+    if (!rawVersion) {
+      throw new Error("npm is not available");
+    }
+    const version2 = parseSemVer(rawVersion);
+    if (!version2) {
+      throw new Error(`Unable to parse npm version: ${rawVersion}`);
+    }
+    const executablePath = resolveExecutablePath("npm") ?? "npm";
+    return {
+      tool: "npm",
+      version: version2,
+      executablePath,
+      meetsMinimum: semVerSatisfiesMinimum(version2, minimum),
+      minimumRequired: minimum
+    };
+  }
+  /**
+   * Check git version. Git is not strictly required but is reported.
+   */
+  async checkGitVersion() {
+    const rawVersion = execCommand("git --version");
+    if (!rawVersion) {
+      throw new Error("git is not available");
+    }
+    const versionMatch = /(\d+\.\d+\.\d+)/.exec(rawVersion);
+    if (!versionMatch) {
+      throw new Error(`Unable to parse git version: ${rawVersion}`);
+    }
+    const version2 = parseSemVer(versionMatch[1]);
+    if (!version2) {
+      throw new Error(`Unable to parse git version: ${versionMatch[1]}`);
+    }
+    const executablePath = resolveExecutablePath("git") ?? "git";
+    return {
+      tool: "git",
+      version: version2,
+      executablePath,
+      meetsMinimum: true,
+      minimumRequired: semVer(0, 0, 0)
+    };
+  }
+  /**
+   * Resolve the npm global bin directory and check if it is on PATH.
+   *
+   * On Unix: `npm config get prefix` returns the prefix, bin dir is `{prefix}/bin`
+   * On Windows: `npm config get prefix` returns the prefix, which IS the bin dir
+   */
+  async resolveGlobalBinDir(shell) {
+    const prefix = execCommand("npm config get prefix");
+    if (!prefix) {
+      throw new Error("Unable to resolve npm global bin directory");
+    }
+    const isWindows = process.platform === "win32";
+    const binDir = isWindows ? prefix.replace(/\\/g, "/") : prefix.replace(/\\/g, "/") + "/bin";
+    const normalizedBinDir = createNormalizedPath(binDir);
+    const pathEnv = process.env["PATH"] ?? process.env["Path"] ?? "";
+    const pathDirs = pathEnv.split(shell.pathSeparator);
+    const isOnPath = pathDirs.some((dir) => {
+      const normalizedDir = dir.replace(/\\/g, "/").replace(/\/+$/, "");
+      return normalizedDir.toLowerCase() === binDir.toLowerCase() || normalizedDir.toLowerCase() === binDir.replace(/\/bin$/, "").toLowerCase();
+    });
+    let pathFixCommand = null;
+    if (!isOnPath) {
+      if (isWindows) {
+        pathFixCommand = `$env:PATH = "${binDir.replace(/\//g, "\\")}" + ";" + $env:PATH`;
+      } else {
+        pathFixCommand = `export PATH="${binDir}:$PATH"`;
+      }
+    }
+    return {
+      path: normalizedBinDir,
+      isOnPath,
+      pathFixCommand
+    };
+  }
+  /**
+   * Check if an arbitrary tool is available on PATH.
+   */
+  async checkToolAvailable(toolName) {
+    const executablePath = resolveExecutablePath(toolName);
+    return {
+      available: executablePath !== null,
+      path: executablePath
+    };
+  }
+};
+
+// src/platform/facade.ts
+function safeTerminalProfile() {
+  return {
+    colorSupport: 0 /* None */,
+    dimensions: { columns: 80, rows: 24 },
+    unicodeSupport: { supported: false, detectionMethod: "default" },
+    interactivity: { isInteractive: false, isTTY: false, supportsRawMode: false },
+    emulator: { name: null, version: null, isKnown: false },
+    detectedAt: /* @__PURE__ */ new Date()
+  };
+}
+function safeShellEnvironment() {
+  return {
+    type: "unknown",
+    version: null,
+    executablePath: "",
+    profilePath: null,
+    profileExists: false,
+    pathSeparator: process.platform === "win32" ? ";" : ":",
+    pathModificationCommand: null
+  };
+}
+function safeRuntimeReport() {
+  return {
+    node: {
+      tool: "node",
+      version: semVer(0, 0, 0),
+      executablePath: process.execPath,
+      meetsMinimum: false,
+      minimumRequired: MINIMUM_NODE_VERSION
+    },
+    npm: null,
+    git: null,
+    globalBinDir: null,
+    allRequirementsMet: false,
+    errors: [
+      {
+        tool: "runtime",
+        errorType: "not_found",
+        message: "Runtime validation failed unexpectedly.",
+        fix: "Ensure Node.js >= 18.0.0 and npm >= 9.0.0 are installed."
+      }
+    ],
+    validatedAt: /* @__PURE__ */ new Date()
+  };
+}
+var PlatformFacade = class {
+  platformDetector;
+  pathNormalizer;
+  permissionChecker;
+  terminalDetector;
+  shellDetector;
+  runtimeValidator;
+  constructor() {
+    this.platformDetector = new PlatformDetector();
+    this.pathNormalizer = new PathNormalizer();
+    this.permissionChecker = new PermissionChecker();
+    this.terminalDetector = new TerminalDetector();
+    this.shellDetector = new ShellDetector();
+    this.runtimeValidator = new RuntimeValidator();
+  }
+  /**
+   * Detect all platform capabilities in a single coordinated call.
+   *
+   * Detection flow:
+   * 1. PlatformDetector.detect() -- FATAL on failure
+   * 2. TerminalDetector.detectProfile() -- parallel with step 3
+   * 3. ShellDetector.detectShell(snapshot) -- parallel with step 2
+   * 4. RuntimeValidator.validate() -- depends on step 3
+   * 5. Assemble PlatformEnvironment
+   *
+   * @throws PlatformError with code UNSUPPORTED_PLATFORM if OS detection fails
+   */
+  async detectAll() {
+    const platform = this.platformDetector.detect();
+    const [terminal, shell] = await Promise.all([
+      this.safeDetectTerminal(),
+      this.safeDetectShell(platform)
+    ]);
+    const runtime = await this.safeValidateRuntime();
+    const permissionChecker = this.permissionChecker;
+    const pathNormalizer = this.pathNormalizer;
+    return {
+      platform,
+      terminal,
+      shell,
+      runtime,
+      permissions: {
+        checkWriteAccess: (path7) => permissionChecker.checkWriteAccess(path7, platform),
+        checkDirectoryCreatable: (path7) => permissionChecker.checkDirectoryCreatable(path7, platform)
+      },
+      paths: pathNormalizer
+    };
+  }
+  /**
+   * Safely detect terminal profile. Returns safe defaults on failure.
+   */
+  async safeDetectTerminal() {
+    try {
+      return this.terminalDetector.detectProfile();
+    } catch {
+      return safeTerminalProfile();
+    }
+  }
+  /**
+   * Safely detect shell environment. Returns safe defaults on failure.
+   */
+  async safeDetectShell(platform) {
+    try {
+      return await this.shellDetector.detectShell(platform);
+    } catch {
+      return safeShellEnvironment();
+    }
+  }
+  /**
+   * Safely validate runtime. Returns safe defaults on failure.
+   */
+  async safeValidateRuntime() {
+    try {
+      return await this.runtimeValidator.validate(
+        MINIMUM_NODE_VERSION,
+        MINIMUM_NPM_VERSION
+      );
+    } catch {
+      return safeRuntimeReport();
+    }
+  }
+};
+
+// src/engine/manifest.ts
+import * as fs4 from "fs/promises";
+import * as path2 from "path";
+var CATEGORY_RULES = [
+  { pattern: /^agents[/\\]/, type: "agents" },
+  { pattern: /^skills[/\\]/, type: "skills" },
+  { pattern: /^commands[/\\]/, type: "commands" },
+  { pattern: /^cli[/\\]/, type: "cli" },
+  { pattern: /^typescript[/\\]/, type: "cli" },
+  { pattern: /^workflows[/\\]/, type: "workflows" },
+  { pattern: /^metadata[/\\]/, type: "metadata" }
+];
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  "__pycache__",
+  "coverage"
+]);
+function classifyComponent(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  for (const rule of CATEGORY_RULES) {
+    if (rule.pattern.test(normalized)) {
+      return rule.type;
+    }
+  }
+  return "metadata";
+}
+async function walkDirectory(rootDir, currentDir) {
+  const entries = [];
+  let dirEntries;
+  try {
+    dirEntries = await fs4.readdir(currentDir, { withFileTypes: true });
+  } catch {
+    return entries;
+  }
+  for (const dirEntry of dirEntries) {
+    const fullPath = path2.join(currentDir, dirEntry.name);
+    if (dirEntry.isDirectory()) {
+      if (IGNORED_DIRECTORIES.has(dirEntry.name)) {
+        continue;
+      }
+      const subEntries = await walkDirectory(rootDir, fullPath);
+      entries.push(...subEntries);
+    } else if (dirEntry.isFile()) {
+      const relativePath = path2.relative(rootDir, fullPath);
+      const componentType = classifyComponent(relativePath);
+      try {
+        const stat5 = await fs4.stat(fullPath);
+        entries.push({
+          relativePath,
+          fileName: dirEntry.name,
+          componentType,
+          sizeBytes: stat5.size
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+  return entries;
+}
+async function scanSourceDirectory(sourceDirectory) {
+  try {
+    const stat5 = await fs4.stat(sourceDirectory);
+    if (!stat5.isDirectory()) {
+      throw new Error(
+        `Source path is not a directory: ${sourceDirectory}`
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Source path")) {
+      throw error;
+    }
+    throw new Error(
+      `Source directory does not exist or is not accessible: ${sourceDirectory}`
+    );
+  }
+  const entries = await walkDirectory(sourceDirectory, sourceDirectory);
+  const countsByType = countComponentsByType(entries);
+  return {
+    entries,
+    totalCount: entries.length,
+    countsByType
+  };
+}
+function countComponentsByType(entries) {
+  const counts = {
+    agents: 0,
+    skills: 0,
+    commands: 0,
+    cli: 0,
+    workflows: 0,
+    metadata: 0
+  };
+  for (const entry of entries) {
+    counts[entry.componentType]++;
+  }
+  return counts;
+}
+
+// src/engine/conflict-detector.ts
+import * as fs5 from "fs/promises";
+import * as crypto from "crypto";
+import * as nodePath from "path";
+async function computeFileHash(filePath) {
+  const content = await fs5.readFile(filePath);
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat5 = await fs5.stat(dirPath);
+    return stat5.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fileExists(filePath) {
+  try {
+    const stat5 = await fs5.stat(filePath);
+    return stat5.isFile();
+  } catch {
+    return false;
+  }
+}
+async function detectConflicts(manifest, sourceDirectory, targetDirectory) {
+  const isExistingInstallation = await directoryExists(targetDirectory);
+  const files = [];
+  const existingFiles = [];
+  const modifiedFiles = [];
+  let newCount = 0;
+  let identicalCount = 0;
+  let modifiedCount = 0;
+  for (const entry of manifest.entries) {
+    const sourcePath = nodePath.join(sourceDirectory, entry.relativePath);
+    const targetPath = nodePath.join(targetDirectory, entry.relativePath);
+    const targetFileExists = await fileExists(targetPath);
+    if (!targetFileExists) {
+      const sourceHash2 = await computeFileHash(sourcePath);
+      files.push({
+        relativePath: entry.relativePath,
+        status: "new",
+        sourceHash: sourceHash2,
+        targetHash: null
+      });
+      newCount++;
+      continue;
+    }
+    existingFiles.push(entry.relativePath);
+    const [sourceHash, targetHash] = await Promise.all([
+      computeFileHash(sourcePath),
+      computeFileHash(targetPath)
+    ]);
+    if (sourceHash === targetHash) {
+      files.push({
+        relativePath: entry.relativePath,
+        status: "identical",
+        sourceHash,
+        targetHash
+      });
+      identicalCount++;
+    } else {
+      files.push({
+        relativePath: entry.relativePath,
+        status: "modified",
+        sourceHash,
+        targetHash
+      });
+      modifiedFiles.push(entry.relativePath);
+      modifiedCount++;
+    }
+  }
+  return {
+    files,
+    existingFiles,
+    modifiedFiles,
+    newCount,
+    identicalCount,
+    modifiedCount,
+    hasConflicts: modifiedCount > 0,
+    isExistingInstallation
+  };
+}
+
+// src/engine/file-copier.ts
+import * as fs6 from "fs/promises";
+import * as path3 from "path";
+var Semaphore = class {
+  permits;
+  queue = [];
+  constructor(maxConcurrent) {
+    this.permits = maxConcurrent;
+  }
+  /** Acquire a permit. Resolves immediately if available, else waits. */
+  async acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+    return new Promise((resolve3) => this.queue.push(resolve3));
+  }
+  /** Release a permit. Wakes the next waiter if any. */
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.permits++;
+    }
+  }
+};
+async function ensureDirectories(files) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const dir = path3.dirname(file.destinationPath);
+    dirs.add(dir);
+  }
+  const sorted = Array.from(dirs).sort((a, b) => a.length - b.length);
+  for (const dir of sorted) {
+    await fs6.mkdir(dir, { recursive: true });
+  }
+}
+async function copySingleFile(sourcePath, destinationPath) {
+  await fs6.copyFile(sourcePath, destinationPath);
+}
+var DEFAULT_CONCURRENCY = 10;
+var MIN_CONCURRENCY = 1;
+var MAX_CONCURRENCY = 64;
+async function copyFiles(files, options = {}) {
+  const startTime = Date.now();
+  const concurrency = Math.max(
+    MIN_CONCURRENCY,
+    Math.min(MAX_CONCURRENCY, options.concurrency ?? DEFAULT_CONCURRENCY)
+  );
+  const onProgress = options.onProgress ?? (() => {
+  });
+  const total = files.length;
+  if (total === 0) {
+    return buildResult(true, 0, 0, [], [], startTime, {});
+  }
+  await ensureDirectories(files);
+  const errors = [];
+  const warnings = [];
+  const componentCounts = {
+    agents: 0,
+    skills: 0,
+    commands: 0,
+    cli: 0,
+    workflows: 0,
+    metadata: 0
+  };
+  let copiedCount = 0;
+  let skippedCount = 0;
+  let completedCount = 0;
+  let hasFailed = false;
+  const semaphore = new Semaphore(concurrency);
+  const tasks = files.map(async (file) => {
+    await semaphore.acquire();
+    try {
+      if (hasFailed) {
+        skippedCount++;
+        return;
+      }
+      await copySingleFile(file.sourcePath, file.destinationPath);
+      copiedCount++;
+      componentCounts[file.componentType]++;
+    } catch (error) {
+      hasFailed = true;
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push({
+        code: "COPY_FAILED",
+        message: `Failed to copy ${file.relativePath}: ${message}`,
+        filePath: file.relativePath,
+        originalError: message
+      });
+    } finally {
+      completedCount++;
+      try {
+        onProgress({
+          fileName: file.fileName,
+          current: completedCount,
+          total
+        });
+      } catch {
+      }
+      semaphore.release();
+    }
+  });
+  await Promise.all(tasks);
+  const success = errors.length === 0;
+  return buildResult(
+    success,
+    copiedCount,
+    skippedCount,
+    warnings,
+    errors,
+    startTime,
+    componentCounts
+  );
+}
+function buildResult(success, copiedCount, skippedCount, warnings, errors, startTime, componentCounts) {
+  return {
+    success,
+    copiedCount,
+    skippedCount,
+    warnings,
+    errors,
+    durationMs: Date.now() - startTime,
+    componentCounts: {
+      agents: componentCounts["agents"] ?? 0,
+      skills: componentCounts["skills"] ?? 0,
+      commands: componentCounts["commands"] ?? 0,
+      cli: componentCounts["cli"] ?? 0,
+      workflows: componentCounts["workflows"] ?? 0,
+      metadata: componentCounts["metadata"] ?? 0
+    }
+  };
+}
+
+// src/engine/rollback.ts
+import * as fs7 from "fs/promises";
+import * as path4 from "path";
+var BACKUP_ROOT_DIR = ".ai-dlc-backup";
+function generateTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "").replace(/\.\d+Z$/, "Z");
+}
+async function createBackup(targetDirectory, filesToBackup) {
+  if (filesToBackup.length === 0) {
+    return null;
+  }
+  const timestamp = generateTimestamp();
+  const backupDirectory = path4.join(
+    targetDirectory,
+    BACKUP_ROOT_DIR,
+    timestamp
+  );
+  await fs7.mkdir(backupDirectory, { recursive: true });
+  const backedUpFiles = [];
+  for (const relativePath of filesToBackup) {
+    const sourcePath = path4.join(targetDirectory, relativePath);
+    const backupPath = path4.join(backupDirectory, relativePath);
+    try {
+      await fs7.access(sourcePath);
+      await fs7.mkdir(path4.dirname(backupPath), { recursive: true });
+      await fs7.copyFile(sourcePath, backupPath);
+      backedUpFiles.push({
+        originalRelativePath: relativePath,
+        backupPath
+      });
+    } catch {
+      continue;
+    }
+  }
+  return {
+    backupDirectory,
+    files: backedUpFiles,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function restoreFromBackup(backup, targetDirectory) {
+  const errors = [];
+  let restoredCount = 0;
+  for (const file of backup.files) {
+    const restorePath = path4.join(targetDirectory, file.originalRelativePath);
+    try {
+      await fs7.mkdir(path4.dirname(restorePath), { recursive: true });
+      await fs7.copyFile(file.backupPath, restorePath);
+      restoredCount++;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push({
+        code: "ROLLBACK_RESTORE_FAILED",
+        message: `Failed to restore ${file.originalRelativePath}: ${message}`,
+        filePath: file.originalRelativePath,
+        originalError: message
+      });
+    }
+  }
+  return {
+    success: errors.length === 0,
+    restoredCount,
+    errors
+  };
+}
+
+// src/engine/validator.ts
+import * as fs8 from "fs/promises";
+import * as path5 from "path";
+async function validateSingleFile(destinationPath, relativePath) {
+  try {
+    const stat5 = await fs8.stat(destinationPath);
+    if (!stat5.isFile()) {
+      return {
+        relativePath,
+        reason: "Path exists but is not a regular file"
+      };
+    }
+    if (stat5.size === 0) {
+      return {
+        relativePath,
+        reason: "File exists but has zero size"
+      };
+    }
+    return null;
+  } catch (error) {
+    const code = error instanceof Error && "code" in error ? error.code : void 0;
+    if (code === "ENOENT") {
+      return {
+        relativePath,
+        reason: "File does not exist at destination"
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      relativePath,
+      reason: `Cannot access file: ${message}`
+    };
+  }
+}
+async function validateInstallation(files) {
+  if (files.length === 0) {
+    return {
+      valid: true,
+      totalChecked: 0,
+      validCount: 0,
+      missingFiles: [],
+      invalidFiles: []
+    };
+  }
+  const missingFiles = [];
+  const invalidFiles = [];
+  let validCount = 0;
+  for (const file of files) {
+    const issue = await validateSingleFile(
+      file.destinationPath,
+      file.relativePath
+    );
+    if (issue === null) {
+      validCount++;
+    } else if (issue.reason.includes("does not exist")) {
+      missingFiles.push(file.relativePath);
+      invalidFiles.push(issue);
+    } else {
+      invalidFiles.push(issue);
+    }
+  }
+  return {
+    valid: missingFiles.length === 0 && invalidFiles.length === 0,
+    totalChecked: files.length,
+    validCount,
+    missingFiles,
+    invalidFiles
+  };
+}
+
+// src/orchestrator/workflow.ts
+function createInitialState() {
+  return {
+    status: "pending",
+    steps: WORKFLOW_STEPS.map((def) => ({
+      def,
+      status: "pending",
+      output: null,
+      error: null,
+      startedAt: null,
+      completedAt: null
+    })),
+    currentStepId: null,
+    startedAt: null,
+    completedAt: null,
+    cancellationReason: null
+  };
+}
+function createInitialContext(sourceDirectory) {
+  return {
+    platformEnv: null,
+    terminalCapabilities: null,
+    runtimeReport: null,
+    targetDirectory: null,
+    claudeDirectory: null,
+    sourceDirectory,
+    manifest: null,
+    conflictReport: null,
+    backupManifest: null,
+    installationResult: null,
+    validationReport: null,
+    fileMappings: []
+  };
+}
+function buildTerminalCapabilities(env) {
+  return {
+    colorSupport: mapColorSupport(env.terminal.colorSupport),
+    unicodeSupport: env.terminal.unicodeSupport.supported,
+    width: env.terminal.dimensions.columns,
+    height: env.terminal.dimensions.rows,
+    isInteractive: env.terminal.interactivity.isInteractive
+  };
+}
+function buildFileMappings(manifest, sourceDirectory, claudeDirectory) {
+  return manifest.entries.map((entry) => ({
+    relativePath: entry.relativePath,
+    sourcePath: path6.join(sourceDirectory, entry.relativePath),
+    destinationPath: path6.join(claudeDirectory, entry.relativePath),
+    componentType: entry.componentType,
+    fileName: entry.fileName,
+    sizeBytes: entry.sizeBytes
+  }));
+}
+function buildDirectoryOptions(env) {
+  const cwd = process.cwd();
+  const home = env.platform.homeDirectory.path;
+  const options = [
+    {
+      path: cwd,
+      label: cwd,
+      isDefault: true,
+      exists: true
+    }
+  ];
+  if (home !== cwd) {
+    options.push({
+      path: home,
+      label: home,
+      isDefault: false,
+      exists: true
+    });
+  }
+  return options;
+}
+function verboseLog(verbose, ...args) {
+  if (verbose) {
+    console.error("[verbose]", ...args);
+  }
+}
+async function executeInstallation(options) {
+  const errorHandler = new ErrorHandler();
+  const workflow = createInitialState();
+  let sourceDirectory;
+  try {
+    sourceDirectory = await resolveSourceDirectory();
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    return EXIT_CANCELLED;
+  }
+  const ctx = createInitialContext(sourceDirectory);
+  let cancelled = false;
+  const sigintHandler = () => {
+    cancelled = true;
+    workflow.status = "cancelled";
+    workflow.cancellationReason = "User pressed Ctrl+C";
+  };
+  process.on("SIGINT", sigintHandler);
+  workflow.status = "running";
+  workflow.startedAt = Date.now();
+  let theme = null;
+  try {
+    for (const stepState of workflow.steps) {
+      if (cancelled) {
+        break;
+      }
+      const stepId = stepState.def.id;
+      const isInteractive = ctx.terminalCapabilities?.isInteractive ?? true;
+      if (stepState.def.isSkippable && shouldSkipStep(stepId, options, isInteractive)) {
+        stepState.status = "skipped";
+        verboseLog(options.verbose, `Skipping step: ${stepState.def.name}`);
+        continue;
+      }
+      stepState.status = "running";
+      stepState.startedAt = Date.now();
+      workflow.currentStepId = stepId;
+      verboseLog(options.verbose, `Starting step: ${stepState.def.name}`);
+      try {
+        const output = await executeStep(stepId, options, ctx, theme, errorHandler);
+        stepState.status = "completed";
+        stepState.output = output;
+        stepState.completedAt = Date.now();
+        if (stepId === "detect-platform" && ctx.terminalCapabilities) {
+          theme = ThemeEngine.initialize(ctx.terminalCapabilities, {
+            forceNoColor: options.noColor,
+            forceColor: false
+          });
+        }
+        verboseLog(
+          options.verbose,
+          `Completed step: ${stepState.def.name} (${stepState.completedAt - (stepState.startedAt ?? 0)}ms)`
+        );
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (err instanceof UserCancellationError) {
+          workflow.status = "cancelled";
+          workflow.cancellationReason = err.message;
+          break;
+        }
+        const recovery = errorHandler.handleError(err, stepId);
+        stepState.status = "failed";
+        stepState.error = err;
+        stepState.completedAt = Date.now();
+        verboseLog(options.verbose, `Step failed: ${stepState.def.name} - ${err.message}`);
+        verboseLog(options.verbose, `Recovery strategy: ${recovery.strategy}`);
+        if (recovery.strategy === "PromptUser" && isInteractive && theme) {
+          const errorContent = {
+            title: "Installation Error",
+            message: recovery.userGuidance,
+            cause: err.message,
+            suggestedActions: recovery.platformGuidance ? [{ step: 1, instruction: recovery.platformGuidance, command: null }] : [],
+            retryAvailable: true,
+            errorCode: null
+          };
+          const lines = renderError(errorContent, theme);
+          for (const line of lines) {
+            console.log(line);
+          }
+          const shouldRetry = await promptRetry();
+          if (shouldRetry && errorHandler.canRetry(stepId)) {
+            errorHandler.recordRetry(stepId);
+            stepState.status = "running";
+            stepState.error = null;
+            stepState.startedAt = Date.now();
+            stepState.completedAt = null;
+            try {
+              const output = await executeStep(stepId, options, ctx, theme, errorHandler);
+              stepState.status = "completed";
+              stepState.output = output;
+              stepState.completedAt = Date.now();
+              continue;
+            } catch (retryError) {
+              const retryErr = retryError instanceof Error ? retryError : new Error(String(retryError));
+              stepState.status = "failed";
+              stepState.error = retryErr;
+              stepState.completedAt = Date.now();
+              errorHandler.handleError(retryErr, stepId);
+            }
+          }
+          workflow.status = "failed";
+          break;
+        }
+        if (recovery.strategy === "RollbackAndAbort" || recovery.strategy === "AbortImmediately") {
+          await attemptRollback(ctx, options);
+          if (theme) {
+            const errorContent = {
+              title: "Installation Failed",
+              message: recovery.userGuidance,
+              cause: err.message,
+              suggestedActions: recovery.platformGuidance ? [{ step: 1, instruction: recovery.platformGuidance, command: null }] : [],
+              retryAvailable: false,
+              errorCode: null
+            };
+            const lines = renderError(errorContent, theme);
+            for (const line of lines) {
+              console.log(line);
+            }
+          } else {
+            console.error(`
+Error: ${err.message}`);
+            console.error(recovery.userGuidance);
+          }
+          workflow.status = "failed";
+          break;
+        }
+        if (recovery.strategy === "SkipAndContinue" && stepState.def.isSkippable) {
+          stepState.status = "skipped";
+          continue;
+        }
+        workflow.status = "failed";
+        break;
+      }
+    }
+    if (workflow.status === "running") {
+      workflow.status = "completed";
+    }
+    workflow.completedAt = Date.now();
+    if (workflow.status === "cancelled") {
+      await attemptRollback(ctx, options);
+      if (theme) {
+        promptOutro("Installation cancelled. All changes have been rolled back.");
+      } else {
+        console.log("\nInstallation cancelled. All changes have been rolled back.");
+      }
+    }
+  } finally {
+    process.removeListener("SIGINT", sigintHandler);
+  }
+  return errorHandler.getExitCode(workflow);
+}
+async function executeDryRun(options) {
+  let sourceDirectory;
+  try {
+    sourceDirectory = await resolveSourceDirectory();
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    return EXIT_CANCELLED;
+  }
+  const ctx = createInitialContext(sourceDirectory);
+  const details = [];
+  console.log("\n[dry-run] Simulating installation workflow...\n");
+  try {
+    const facade = new PlatformFacade();
+    ctx.platformEnv = await facade.detectAll();
+    ctx.terminalCapabilities = buildTerminalCapabilities(ctx.platformEnv);
+    details.push({
+      stepId: "detect-platform",
+      stepName: "Detect Platform",
+      result: `${ctx.platformEnv.platform.os.family} ${ctx.platformEnv.platform.os.architecture.name}`,
+      warnings: []
+    });
+  } catch (error) {
+    console.error(`Platform detection failed: ${error instanceof Error ? error.message : String(error)}`);
+    return EXIT_CANCELLED;
+  }
+  const prereqWarnings = [];
+  if (!ctx.platformEnv.runtime.allRequirementsMet) {
+    for (const err of ctx.platformEnv.runtime.errors) {
+      prereqWarnings.push(err.message);
+    }
+  }
+  details.push({
+    stepId: "check-prerequisites",
+    stepName: "Check Prerequisites",
+    result: prereqWarnings.length === 0 ? "All prerequisites met" : `${prereqWarnings.length} issue(s)`,
+    warnings: prereqWarnings
+  });
+  const targetDir = options.target ?? process.cwd();
+  ctx.targetDirectory = targetDir;
+  ctx.claudeDirectory = path6.join(targetDir, CLAUDE_DIRECTORY_NAME);
+  details.push({
+    stepId: "select-directory",
+    stepName: "Select Target Directory",
+    result: `Target: ${targetDir}`,
+    warnings: []
+  });
+  try {
+    ctx.manifest = await scanSourceDirectory(sourceDirectory);
+    details.push({
+      stepId: "scan-source",
+      stepName: "Scan Source Components",
+      result: `${ctx.manifest.totalCount} components found`,
+      warnings: []
+    });
+  } catch (error) {
+    console.error(`Source scan failed: ${error instanceof Error ? error.message : String(error)}`);
+    return EXIT_CANCELLED;
+  }
+  try {
+    ctx.conflictReport = await detectConflicts(ctx.manifest, sourceDirectory, ctx.claudeDirectory);
+    const conflictWarnings = [];
+    if (ctx.conflictReport.hasConflicts) {
+      conflictWarnings.push(`${ctx.conflictReport.modifiedCount} file(s) differ from source`);
+    }
+    details.push({
+      stepId: "detect-conflicts",
+      stepName: "Detect Conflicts",
+      result: ctx.conflictReport.hasConflicts ? `${ctx.conflictReport.modifiedCount} conflict(s) detected` : "No conflicts",
+      warnings: conflictWarnings
+    });
+  } catch (error) {
+    details.push({
+      stepId: "detect-conflicts",
+      stepName: "Detect Conflicts",
+      result: `Could not check: ${error instanceof Error ? error.message : "unknown"}`,
+      warnings: []
+    });
+  }
+  const report = {
+    filesToInstall: ctx.manifest.totalCount,
+    filesToOverwrite: ctx.conflictReport?.modifiedCount ?? 0,
+    conflictsDetected: ctx.conflictReport?.modifiedCount ?? 0,
+    wouldSucceed: prereqWarnings.length === 0,
+    details
+  };
+  console.log("[dry-run] Installation Preview");
+  console.log("\u2500".repeat(50));
+  console.log(`  Files to install:  ${report.filesToInstall}`);
+  console.log(`  Files to overwrite: ${report.filesToOverwrite}`);
+  console.log(`  Conflicts detected: ${report.conflictsDetected}`);
+  console.log(`  Would succeed:      ${report.wouldSucceed ? "yes" : "no"}`);
+  console.log("");
+  for (const detail of report.details) {
+    console.log(`  ${detail.stepName}: ${detail.result}`);
+    for (const warning of detail.warnings) {
+      console.log(`    ! ${warning}`);
+    }
+  }
+  console.log("");
+  console.log("[dry-run] No files were modified.");
+  return EXIT_SUCCESS;
+}
+async function executeStep(stepId, options, ctx, theme, errorHandler) {
+  switch (stepId) {
+    case "detect-platform":
+      return executeDetectPlatform(ctx, options);
+    case "check-prerequisites":
+      return executeCheckPrerequisites(ctx, options);
+    case "show-banner":
+      return executeShowBanner(ctx, options, theme);
+    case "select-directory":
+      return executeSelectDirectory(ctx, options, theme);
+    case "scan-source":
+      return executeScanSource(ctx, options);
+    case "detect-conflicts":
+      return executeDetectConflicts(ctx, options, theme);
+    case "confirm-installation":
+      return executeConfirmInstallation(ctx, options, theme);
+    case "execute-installation":
+      return executeInstallFiles(ctx, options, theme);
+    case "validate-installation":
+      return executeValidateInstallation(ctx, options);
+    case "show-summary":
+      return executeShowSummary(ctx, options, theme);
+    default: {
+      const _exhaustive = stepId;
+      throw new Error(`Unknown step: ${_exhaustive}`);
+    }
+  }
+}
+async function executeDetectPlatform(ctx, options) {
+  const facade = new PlatformFacade();
+  ctx.platformEnv = await facade.detectAll();
+  ctx.terminalCapabilities = buildTerminalCapabilities(ctx.platformEnv);
+  ctx.runtimeReport = ctx.platformEnv.runtime;
+  const os3 = ctx.platformEnv.platform.os;
+  return {
+    data: { os: os3.family, arch: os3.architecture.name, version: os3.version },
+    summary: `Platform: ${os3.family} ${os3.architecture.name} (${os3.version})`
+  };
+}
+async function executeCheckPrerequisites(ctx, options) {
+  const runtime = ctx.runtimeReport ?? ctx.platformEnv?.runtime;
+  if (!runtime) {
+    throw new Error("Platform detection must complete before prerequisite check.");
+  }
+  if (!runtime.allRequirementsMet) {
+    const errorMessages = runtime.errors.map((e) => e.message);
+    const fixMessages = runtime.errors.map((e) => e.fix);
+    throw new Error(
+      "Runtime requirements not met:\n" + errorMessages.map((msg, i) => `  - ${msg}
+    Fix: ${fixMessages[i]}`).join("\n")
+    );
+  }
+  const nodeVersion = runtime.node.version.raw;
+  const npmVersion = runtime.npm?.version.raw ?? "not detected";
+  return {
+    data: { nodeVersion, npmVersion },
+    summary: `Node.js ${nodeVersion}, npm ${npmVersion}`
+  };
+}
+async function executeShowBanner(ctx, options, theme) {
+  if (!theme) {
+    console.log("\n  SixSevenAI - AI-DLC Framework Installer\n");
+    return { data: {}, summary: "Banner displayed (plain)" };
+  }
+  const lines = renderBanner(INSTALLER_VERSION, theme);
+  for (const line of lines) {
+    console.log(line);
+  }
+  promptIntro(`SixSevenAI Installer v${INSTALLER_VERSION}`);
+  return { data: {}, summary: "Banner displayed" };
+}
+async function executeSelectDirectory(ctx, options, theme) {
+  if (options.target) {
+    ctx.targetDirectory = path6.resolve(options.target);
+    ctx.claudeDirectory = path6.join(ctx.targetDirectory, CLAUDE_DIRECTORY_NAME);
+    return {
+      data: { targetDirectory: ctx.targetDirectory },
+      summary: `Target: ${ctx.targetDirectory} (from --target)`
+    };
+  }
+  if (!ctx.platformEnv) {
+    throw new Error("Platform detection must complete before directory selection.");
+  }
+  if (!theme) {
+    ctx.targetDirectory = process.cwd();
+    ctx.claudeDirectory = path6.join(ctx.targetDirectory, CLAUDE_DIRECTORY_NAME);
+    return {
+      data: { targetDirectory: ctx.targetDirectory },
+      summary: `Target: ${ctx.targetDirectory} (default)`
+    };
+  }
+  const dirOptions = buildDirectoryOptions(ctx.platformEnv);
+  const selection = await promptDirectorySelection(dirOptions, theme);
+  ctx.targetDirectory = path6.resolve(selection.path);
+  ctx.claudeDirectory = path6.join(ctx.targetDirectory, CLAUDE_DIRECTORY_NAME);
+  return {
+    data: { targetDirectory: ctx.targetDirectory, isCustom: selection.isCustom },
+    summary: `Target: ${ctx.targetDirectory}`
+  };
+}
+async function executeScanSource(ctx, options) {
+  ctx.manifest = await scanSourceDirectory(ctx.sourceDirectory);
+  verboseLog(options.verbose, `Scanned ${ctx.manifest.totalCount} components from ${ctx.sourceDirectory}`);
+  verboseLog(options.verbose, `  Agents: ${ctx.manifest.countsByType.agents}`);
+  verboseLog(options.verbose, `  Skills: ${ctx.manifest.countsByType.skills}`);
+  verboseLog(options.verbose, `  Commands: ${ctx.manifest.countsByType.commands}`);
+  return {
+    data: {
+      totalCount: ctx.manifest.totalCount,
+      countsByType: ctx.manifest.countsByType
+    },
+    summary: `${ctx.manifest.totalCount} components scanned`
+  };
+}
+async function executeDetectConflicts(ctx, options, theme) {
+  if (!ctx.manifest || !ctx.claudeDirectory) {
+    throw new Error("Source scan and directory selection must complete before conflict detection.");
+  }
+  ctx.conflictReport = await detectConflicts(
+    ctx.manifest,
+    ctx.sourceDirectory,
+    ctx.claudeDirectory
+  );
+  if (ctx.conflictReport.hasConflicts && theme && !options.force) {
+    const shouldOverwrite = await promptOverwriteExisting(ctx.claudeDirectory);
+    if (!shouldOverwrite) {
+      throw new UserCancellationError("User declined to overwrite existing files.");
+    }
+  }
+  if (ctx.conflictReport.hasConflicts && !options.force) {
+    try {
+      ctx.backupManifest = await createBackup(
+        ctx.claudeDirectory,
+        ctx.conflictReport.modifiedFiles
+      );
+      if (ctx.backupManifest) {
+        verboseLog(
+          options.verbose,
+          `Backed up ${ctx.backupManifest.files.length} files to ${ctx.backupManifest.backupDirectory}`
+        );
+      }
+    } catch (backupError) {
+      verboseLog(options.verbose, `Backup warning: ${backupError instanceof Error ? backupError.message : String(backupError)}`);
+    }
+  }
+  return {
+    data: {
+      hasConflicts: ctx.conflictReport.hasConflicts,
+      newCount: ctx.conflictReport.newCount,
+      identicalCount: ctx.conflictReport.identicalCount,
+      modifiedCount: ctx.conflictReport.modifiedCount
+    },
+    summary: ctx.conflictReport.hasConflicts ? `${ctx.conflictReport.modifiedCount} conflict(s) found` : "No conflicts"
+  };
+}
+async function executeConfirmInstallation(ctx, options, theme) {
+  if (!ctx.manifest) {
+    throw new Error("Source scan must complete before confirmation.");
+  }
+  const fileCount = ctx.manifest.totalCount;
+  const target = ctx.claudeDirectory ?? ctx.targetDirectory ?? "unknown";
+  const confirmed = await promptConfirmation(
+    `Install ${fileCount} files to ${target}?`,
+    true
+  );
+  if (!confirmed) {
+    throw new UserCancellationError("User declined installation.");
+  }
+  return {
+    data: { confirmed: true },
+    summary: "Installation confirmed"
+  };
+}
+async function executeInstallFiles(ctx, options, theme) {
+  if (!ctx.manifest || !ctx.claudeDirectory) {
+    throw new Error("Source scan and directory selection must complete before installation.");
+  }
+  ctx.fileMappings = buildFileMappings(ctx.manifest, ctx.sourceDirectory, ctx.claudeDirectory);
+  if (options.dryRun) {
+    return {
+      data: { dryRun: true, fileCount: ctx.fileMappings.length },
+      summary: `[dry-run] Would install ${ctx.fileMappings.length} files`
+    };
+  }
+  let progressTracker = null;
+  if (theme && !options.quiet) {
+    progressTracker = new ProgressTracker();
+    progressTracker.addStep({ id: "copy-files", label: `Installing ${ctx.fileMappings.length} files` });
+    progressTracker.start();
+    progressTracker.startStep("copy-files");
+  }
+  const result = await copyFiles(ctx.fileMappings, {
+    concurrency: 16,
+    onProgress: (event) => {
+      verboseLog(
+        options.verbose,
+        `  [${event.current}/${event.total}] ${event.fileName}`
+      );
+    }
+  });
+  ctx.installationResult = result;
+  if (progressTracker) {
+    if (result.success) {
+      progressTracker.completeStep("copy-files");
+    } else {
+      progressTracker.failStep("copy-files", { message: "File copy failed", cause: null });
+    }
+    progressTracker.finish();
+  }
+  if (!result.success) {
+    const errorMessages = result.errors.map((e) => e.message).join("; ");
+    throw new Error(`File installation failed: ${errorMessages}`);
+  }
+  return {
+    data: {
+      copiedCount: result.copiedCount,
+      skippedCount: result.skippedCount,
+      errorCount: result.errors.length
+    },
+    summary: `${result.copiedCount} files installed, ${result.skippedCount} skipped`
+  };
+}
+async function executeValidateInstallation(ctx, options) {
+  if (!ctx.fileMappings || ctx.fileMappings.length === 0) {
+    return {
+      data: { valid: true, skipped: true },
+      summary: "Validation skipped (no files to validate)"
+    };
+  }
+  ctx.validationReport = await validateInstallation(ctx.fileMappings);
+  if (!ctx.validationReport.valid) {
+    const missing = ctx.validationReport.missingFiles;
+    const invalid = ctx.validationReport.invalidFiles;
+    throw new Error(
+      `Installation validation failed: ${missing.length} missing file(s), ${invalid.length} invalid file(s)`
+    );
+  }
+  return {
+    data: {
+      valid: true,
+      totalChecked: ctx.validationReport.totalChecked,
+      validCount: ctx.validationReport.validCount
+    },
+    summary: `${ctx.validationReport.validCount} files validated`
+  };
+}
+async function executeShowSummary(ctx, options, theme) {
+  const elapsed = Date.now() - (ctx.installationResult ? Date.now() : Date.now());
+  const summary = {
+    success: ctx.installationResult?.success ?? true,
+    targetDirectory: ctx.targetDirectory ?? "unknown",
+    componentCounts: {
+      agents: ctx.manifest?.countsByType.agents ?? 0,
+      skills: ctx.manifest?.countsByType.skills ?? 0,
+      commands: ctx.manifest?.countsByType.commands ?? 0,
+      cliFiles: ctx.manifest?.countsByType.cli ?? 0,
+      other: (ctx.manifest?.countsByType.workflows ?? 0) + (ctx.manifest?.countsByType.metadata ?? 0)
+    },
+    totalDuration: formatDuration(0),
+    // Will be updated by caller
+    totalFilesCopied: ctx.installationResult?.copiedCount ?? 0,
+    totalFilesSkipped: ctx.installationResult?.skippedCount ?? 0,
+    totalFilesFailed: ctx.installationResult?.errors.length ?? 0,
+    installerVersion: INSTALLER_VERSION
+  };
+  const nextSteps = getDefaultNextSteps(summary.success);
+  if (theme && !options.quiet) {
+    const lines = renderSummary(summary, nextSteps, theme);
+    for (const line of lines) {
+      console.log(line);
+    }
+    if (summary.success) {
+      promptOutro("Installation complete!");
+    }
+  } else if (!options.quiet) {
+    console.log("\n--- Installation Summary ---");
+    console.log(`  Status: ${summary.success ? "Success" : "Failed"}`);
+    console.log(`  Files installed: ${summary.totalFilesCopied}`);
+    console.log(`  Files skipped: ${summary.totalFilesSkipped}`);
+    console.log(`  Target: ${summary.targetDirectory}`);
+    if (summary.success) {
+      console.log("\n  Next steps:");
+      for (const step of nextSteps) {
+        console.log(`    ${step.order}. ${step.title}`);
+        if (step.command) {
+          console.log(`       $ ${step.command}`);
+        }
+      }
+    }
+  }
+  return {
+    data: { success: summary.success },
+    summary: summary.success ? "Installation successful" : "Installation completed with errors"
+  };
+}
+async function attemptRollback(ctx, options) {
+  if (!ctx.backupManifest || !ctx.claudeDirectory) {
+    verboseLog(options.verbose, "No backup available for rollback.");
+    return;
+  }
+  try {
+    verboseLog(options.verbose, "Rolling back installation...");
+    const rollbackResult = await restoreFromBackup(ctx.backupManifest, ctx.claudeDirectory);
+    if (rollbackResult.success) {
+      verboseLog(options.verbose, `Rollback complete: ${rollbackResult.restoredCount} files restored.`);
+    } else {
+      const errorMessages = rollbackResult.errors.map((e) => e.message).join("; ");
+      console.error(`Rollback encountered errors: ${errorMessages}`);
+    }
+  } catch (error) {
+    console.error(
+      `Rollback failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/index.ts
+async function runInstaller(options = {}) {
+  const cliOptions = {
+    command: "install",
+    target: options.target ?? null,
+    force: options.force ?? false,
+    dryRun: options.dryRun ?? false,
+    verbose: options.verbose ?? false,
+    noColor: options.noColor ?? false,
+    quiet: options.quiet ?? false,
+    rawArgs: []
+  };
+  let exitCode;
+  if (cliOptions.dryRun) {
+    exitCode = await executeDryRun(cliOptions);
+  } else {
+    exitCode = await executeInstallation(cliOptions);
+  }
+  return {
+    success: exitCode === EXIT_SUCCESS,
+    filesWritten: 0,
+    // Detailed counts are in the workflow output
+    summary: exitCode === EXIT_SUCCESS ? "Installation completed successfully." : exitCode === 2 ? "Installation cancelled by user." : "Installation failed.",
+    exitCode
+  };
+}
+
+// src/cli.ts
+var CLI_NAME = "sixsevenai";
+var KNOWN_FLAGS = [
+  "--version",
+  "-v",
+  "--help",
+  "-h",
+  "--verbose",
+  "--dry-run",
+  "-d",
+  "--no-color",
+  "--force",
+  "-f",
+  "--quiet",
+  "-q",
+  "--target",
+  "-t"
+];
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const filtered = args[0] === "install" ? args.slice(1) : args;
+  let target = null;
+  const version2 = filtered.includes("--version") || filtered.includes("-v");
+  const help = filtered.includes("--help") || filtered.includes("-h");
+  const verbose = filtered.includes("--verbose");
+  const dryRun = filtered.includes("--dry-run") || filtered.includes("-d");
+  const noColor = filtered.includes("--no-color");
+  const force = filtered.includes("--force") || filtered.includes("-f");
+  const quiet = filtered.includes("--quiet") || filtered.includes("-q");
+  for (let i = 0; i < filtered.length; i++) {
+    const arg = filtered[i];
+    if ((arg === "--target" || arg === "-t") && i + 1 < filtered.length) {
+      target = filtered[i + 1];
+      i++;
+    }
+  }
+  if (target === null) {
+    for (const arg of filtered) {
+      if (!arg.startsWith("-") && arg !== "install") {
+        target = arg;
+        break;
+      }
+    }
+  }
+  if (verbose && quiet) {
+    console.error("Error: Cannot use --verbose and --quiet together.");
+    process.exit(1);
+  }
+  for (const arg of filtered) {
+    if (arg.startsWith("-") && !KNOWN_FLAGS.includes(arg) && arg !== target) {
+      const prevIdx = filtered.indexOf(arg) - 1;
+      if (prevIdx >= 0 && (filtered[prevIdx] === "--target" || filtered[prevIdx] === "-t")) {
+        continue;
+      }
+      const suggestion = findClosestFlag(arg);
+      const suggestionText = suggestion ? ` Did you mean ${suggestion}?` : "";
+      console.error(`Error: Unknown flag: ${arg}.${suggestionText}`);
+      process.exit(1);
+    }
+  }
+  return { version: version2, help, verbose, dryRun, noColor, force, quiet, target };
+}
+function findClosestFlag(input) {
+  let bestMatch = null;
+  let bestDistance = Infinity;
+  for (const flag of KNOWN_FLAGS) {
+    const dist = levenshteinDistance(input, flag);
+    if (dist < bestDistance && dist <= 3) {
+      bestDistance = dist;
+      bestMatch = flag;
+    }
+  }
+  return bestMatch;
+}
+function levenshteinDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => Array.from({ length: n + 1 }, () => 0)
+  );
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+function printHelp() {
+  const help = `
+Usage: ${CLI_NAME} install [target-directory] [options]
+
+Interactive terminal installer for the AI-DLC framework.
+
+Arguments:
+  target-directory         Target project directory (default: current directory)
+
+Options:
+  --target, -t <dir>       Target project directory (overrides positional arg)
+  --force, -f              Overwrite existing files without prompting
+  --dry-run, -d            Preview changes without writing to disk
+  --verbose                Enable verbose logging to stderr
+  --no-color               Disable colored output (also respects NO_COLOR env)
+  --quiet, -q              Suppress non-error output (mutually exclusive with --verbose)
+  -h, --help               Show this help message
+  -v, --version            Show version number
+
+Exit Codes:
+  0                        Installation completed successfully
+  1                        Installation failed
+  2                        Installation cancelled by user
+
+Examples:
+  ${CLI_NAME} install
+  ${CLI_NAME} install --target /home/user/my-project --force
+  ${CLI_NAME} install --dry-run --verbose
+  ${CLI_NAME} install /path/to/project --dry-run > preview.txt
+`;
+  console.log(help.trim());
+}
+async function main() {
+  const flags = parseArgs(process.argv);
+  if (flags.version) {
+    console.log(`${CLI_NAME} v${INSTALLER_VERSION}`);
+    return;
+  }
+  if (flags.help) {
+    printHelp();
+    return;
+  }
+  if (flags.noColor) {
+    process.env["NO_COLOR"] = "1";
+  }
+  const options = {
+    verbose: flags.verbose,
+    dryRun: flags.dryRun,
+    force: flags.force,
+    quiet: flags.quiet,
+    noColor: flags.noColor,
+    target: flags.target ?? void 0
+  };
+  const result = await runInstaller(options);
+  process.exit(result.exitCode);
+}
+process.title = CLI_NAME;
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`
+Fatal error: ${message}`);
+  if (error instanceof Error && error.stack && process.env["DEBUG"]) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map