@sushanglewis/lincoln 1.5.0 → 1.5.2

package/dist/main.js

@@ -1,1009 +1,1379 @@
 #!/usr/bin/env node
 
-// src/cli.tsx
-import { Box as Box8, Text as Text7 } from "ink";
+// src/main.ts
+import fs11 from "fs";
+import path12 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
-// src/config/args.ts
-import { parseArgs as nodeParseArgs } from "util";
+// src/cli.ts
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "yes",
+  "y",
+  "dry-run",
+  "force",
+  "check",
+  "json",
+  "help",
+  "h",
+  "no-venv"
+]);
 function parseArgs(argv) {
-  const { values } = nodeParseArgs({
-    args: argv,
-    options: {
-      topic: { type: "string" },
-      "design-id": { type: "string" },
-      branch: { type: "string" },
-      "session-id": { type: "string" },
-      "no-tui": { type: "boolean", default: false },
-      help: { type: "boolean", short: "h", default: false }
-    },
-    strict: false,
-    allowPositionals: true
-  });
+  const args = argv.slice(2);
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.replace(/^--/, "");
+      const next = args[i + 1];
+      if (!BOOLEAN_FLAGS.has(key) && next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.replace(/^-/, "");
+      const next = args[i + 1];
+      if (!BOOLEAN_FLAGS.has(key) && next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  const command = positional[0] || "help";
+  const validCommands = /* @__PURE__ */ new Set([
+    "install",
+    "update",
+    "use",
+    "doctor",
+    "init-project",
+    "migrate-project",
+    "record",
+    "help",
+    "--help",
+    "-h"
+  ]);
+  if (command === "help" || command === "--help" || command === "-h") {
+    return { command: "help", args: positional.slice(1), flags };
+  }
+  if (!validCommands.has(command)) {
+    return { command: "help", args: positional, flags };
+  }
+  return { command, args: positional.slice(1), flags };
+}
+
+// src/commands/doctor.ts
+import fs2 from "fs";
+import path3 from "path";
+import { spawn } from "child_process";
+
+// src/lib/paths.ts
+import path from "path";
+import os from "os";
+function resolveLincolnPaths(overrideHomeDir) {
+  const homeDir = overrideHomeDir ?? os.homedir();
+  const lincolnHome = process.env.LINCOLN_HOME ? path.resolve(process.env.LINCOLN_HOME) : path.join(homeDir, ".lincoln");
   return {
-    topic: values.topic,
-    designId: values["design-id"],
-    branch: values.branch,
-    sessionId: values["session-id"],
-    noTui: values["no-tui"],
-    help: values.help
+    homeDir,
+    lincolnHome,
+    versionsDir: path.join(lincolnHome, "versions"),
+    currentDir: path.join(lincolnHome, "current"),
+    versionMarker: path.join(lincolnHome, "marker.json"),
+    venvDir: path.join(lincolnHome, "venv"),
+    claudeDir: path.join(homeDir, ".claude"),
+    codexDir: path.join(homeDir, ".codex"),
+    opencodeDir: path.join(homeDir, ".opencode")
   };
 }
 
-// src/config/resolveConfig.ts
-import { existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-
-// src/config/loadConfig.ts
-import { readFileSync } from "fs";
-import yaml from "js-yaml";
-function parseConfig(content, path) {
-  const trimmed = content.trim();
-  if (!trimmed) {
-    return {};
-  }
-  const isJson = trimmed.startsWith("{") || trimmed.startsWith("[");
-  const raw = isJson ? JSON.parse(trimmed) : yaml.load(trimmed);
-  if (raw === null || typeof raw !== "object") {
-    return {};
+// src/lib/versionMarker.ts
+import fs from "fs";
+import path2 from "path";
+function readVersionMarker(paths) {
+  try {
+    const raw = fs.readFileSync(paths.versionMarker, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version === "string" && typeof parsed.installedAt === "string" && Array.isArray(parsed.harnesses)) {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
   }
-  const data = raw;
+}
+function writeVersionMarker(paths, marker) {
+  fs.mkdirSync(path2.dirname(paths.versionMarker), { recursive: true });
+  fs.writeFileSync(paths.versionMarker, JSON.stringify(marker, null, 2) + "\n");
+}
+
+// src/commands/doctor.ts
+var MIN_NODE_MAJOR = 20;
+var MIN_PYTHON_MAJOR = 3;
+var MIN_PYTHON_MINOR = 10;
+function createDefaultDeps() {
+  const paths = resolveLincolnPaths();
+  const pythonCommand = resolvePythonCommand(paths);
   return {
-    defaultTopic: asString(data.default_topic),
-    defaultDesignId: asString(data.default_design_id),
-    defaultBranch: asString(data.default_branch),
-    autoProcess: asBoolean(data.auto_process),
-    showAudioMeter: asBoolean(data.show_audio_meter),
-    audioMeterStyle: asMeterStyle(data.audio_meter_style)
+    paths,
+    nodeVersion: () => process.version,
+    pythonVersion: () => queryCommandVersion(pythonCommand, ["--version"]),
+    pyyamlVersion: () => queryPyyamlVersion(pythonCommand),
+    npmVersion: () => queryCommandVersion("npm", ["--version"]),
+    projectRoot: process.cwd()
   };
 }
-function asString(value) {
-  return typeof value === "string" ? value : void 0;
+async function doctor(options = {}, deps = createDefaultDeps()) {
+  const checks = [];
+  checks.push(checkNode(deps.nodeVersion()));
+  checks.push(await checkPython(deps.pythonVersion));
+  checks.push(await checkPyyaml(deps.pyyamlVersion));
+  checks.push(await checkNpm(deps.npmVersion));
+  checks.push(checkGlobalMarker(deps.paths));
+  checks.push(checkPayloadHooks(deps.paths));
+  checks.push(checkVenv(deps.paths));
+  checks.push(checkProjectMarker(deps.projectRoot));
+  const hasError = checks.some((c) => c.status === "error");
+  const result = { code: hasError ? 1 : 0, checks };
+  if (options.json) {
+    console.log(JSON.stringify({ checks }, null, 2));
+  } else {
+    for (const check of checks) {
+      const icon = check.status === "ok" ? "\u2713" : check.status === "error" ? "\u2717" : check.status === "warn" ? "!" : "-";
+      console.log(`${icon} ${check.name}: ${check.message}`);
+    }
+    if (hasError) {
+      console.error("\nOne or more checks failed.");
+    }
+  }
+  return result;
 }
-function asBoolean(value) {
-  return typeof value === "boolean" ? value : void 0;
+function checkNode(version) {
+  const major = parseNodeMajor(version);
+  if (major === void 0) {
+    return { name: "node", status: "warn", message: `Could not parse Node version: ${version}` };
+  }
+  if (major < MIN_NODE_MAJOR) {
+    return { name: "node", status: "error", message: `Node ${version} is below the minimum required v${MIN_NODE_MAJOR}` };
+  }
+  return { name: "node", status: "ok", message: `Node ${version}` };
 }
-function asMeterStyle(value) {
-  if (value === "bar" || value === "dot" || value === "wave") {
-    return value;
+async function checkPython(query) {
+  const version = (await query())?.trim();
+  if (!version) {
+    return { name: "python", status: "error", message: "Python 3 is not available" };
   }
-  return void 0;
+  const parsed = parsePythonVersion(version);
+  if (!parsed) {
+    return { name: "python", status: "warn", message: `Could not parse Python version: ${version}` };
+  }
+  if (parsed.major < MIN_PYTHON_MAJOR || parsed.major === MIN_PYTHON_MAJOR && parsed.minor < MIN_PYTHON_MINOR) {
+    return {
+      name: "python",
+      status: "error",
+      message: `Python ${version} is below the minimum required ${MIN_PYTHON_MAJOR}.${MIN_PYTHON_MINOR}`
+    };
+  }
+  const display = version.replace(/^Python\s+/, "");
+  return { name: "python", status: "ok", message: `Python ${display}` };
 }
-function loadConfig(path) {
-  let content;
-  try {
-    content = readFileSync(path, "utf-8");
-  } catch (error) {
-    throw new Error(`Config file not found: ${String(path)}`);
+async function checkPyyaml(query) {
+  const version = await query();
+  if (!version) {
+    return { name: "pyyaml", status: "error", message: "PyYAML is not installed for Python 3" };
   }
-  try {
-    return parseConfig(content, path);
-  } catch (error) {
-    const cause = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to parse config ${String(path)}: ${cause}`);
+  return { name: "pyyaml", status: "ok", message: `PyYAML ${version}` };
+}
+async function checkNpm(query) {
+  const version = await query();
+  if (!version) {
+    return { name: "npm", status: "warn", message: "npm is not available" };
+  }
+  return { name: "npm", status: "ok", message: `npm ${version}` };
+}
+function checkGlobalMarker(paths) {
+  const marker = readVersionMarker(paths);
+  if (!marker) {
+    return { name: "global-marker", status: "warn", message: `No version marker at ${paths.versionMarker}` };
+  }
+  return { name: "global-marker", status: "ok", message: `Lincoln ${marker.version} installed` };
+}
+function checkPayloadHooks(paths) {
+  const hooksDir = path3.join(paths.currentDir, ".claude", "hooks");
+  if (!fs2.existsSync(hooksDir)) {
+    return { name: "payload-hooks", status: "warn", message: `Payload hooks not found at ${hooksDir}` };
+  }
+  const required = ["on-session-start.sh"];
+  const missing = required.filter((f) => !fs2.existsSync(path3.join(hooksDir, f)));
+  if (missing.length > 0) {
+    return { name: "payload-hooks", status: "warn", message: `Missing hooks: ${missing.join(", ")}` };
+  }
+  return { name: "payload-hooks", status: "ok", message: `Payload hooks present at ${hooksDir}` };
+}
+function checkVenv(paths) {
+  if (!fs2.existsSync(paths.venvDir)) {
+    return { name: "venv", status: "warn", message: `Virtual environment not found at ${paths.venvDir}` };
+  }
+  const pythonExe = path3.join(paths.venvDir, process.platform === "win32" ? "Scripts" : "bin", "python");
+  if (!fs2.existsSync(pythonExe)) {
+    return { name: "venv", status: "warn", message: `Virtual environment exists but python executable is missing` };
+  }
+  return { name: "venv", status: "ok", message: `Virtual environment present at ${paths.venvDir}` };
+}
+function checkProjectMarker(projectRoot) {
+  const markerPath = path3.join(projectRoot, ".lincoln.yaml");
+  if (!fs2.existsSync(markerPath)) {
+    return { name: "project-marker", status: "skip", message: `No .lincoln.yaml in ${projectRoot}` };
+  }
+  return { name: "project-marker", status: "ok", message: `Project marker found at ${markerPath}` };
+}
+function resolvePythonCommand(paths) {
+  const venvPython = path3.join(
+    paths.venvDir,
+    process.platform === "win32" ? "Scripts" : "bin",
+    process.platform === "win32" ? "python.exe" : "python"
+  );
+  if (fs2.existsSync(venvPython)) {
+    return venvPython;
+  }
+  return "python3";
+}
+function parseNodeMajor(version) {
+  const match = /^v?(\d+)/.exec(version);
+  if (!match) {
+    return void 0;
+  }
+  return Number(match[1]);
+}
+function parsePythonVersion(version) {
+  const match = /(\d+)\.(\d+)/.exec(version);
+  if (!match) {
+    return void 0;
   }
+  return { major: Number(match[1]), minor: Number(match[2]) };
 }
-function loadConfigOptional(path) {
+async function queryCommandVersion(command, args) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "ignore"],
+      shell: process.platform === "win32"
+    });
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.on("close", (code) => {
+      const text = stdout.trim();
+      resolvePromise(code === 0 && text.length > 0 ? text : void 0);
+    });
+    child.on("error", () => resolvePromise(void 0));
+  });
+}
+async function queryPyyamlVersion(pythonCommand) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(
+      pythonCommand,
+      ["-c", "import yaml; print(yaml.__version__)"],
+      { stdio: ["ignore", "pipe", "ignore"], shell: process.platform === "win32" }
+    );
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.on("close", (code) => {
+      const text = stdout.trim();
+      resolvePromise(code === 0 && text.length > 0 ? text : void 0);
+    });
+    child.on("error", () => resolvePromise(void 0));
+  });
+}
+
+// src/lib/packageInfo.ts
+import fs3 from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+function readLocalPackageRoot() {
   try {
-    return loadConfig(path);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("Config file not found")) {
-      return {};
+    let dir = path4.dirname(fileURLToPath(import.meta.url));
+    const root = path4.parse(dir).root;
+    while (dir !== root) {
+      const pkgPath = path4.join(dir, "package.json");
+      if (fs3.existsSync(pkgPath)) {
+        const parsed = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
+        if (parsed.name === "@sushanglewis/lincoln") {
+          return dir;
+        }
+      }
+      dir = path4.dirname(dir);
     }
-    throw error;
+  } catch {
+  }
+  return void 0;
+}
+function readLocalPackageVersion() {
+  try {
+    const root = readLocalPackageRoot();
+    if (!root) return void 0;
+    const parsed = JSON.parse(fs3.readFileSync(path4.join(root, "package.json"), "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : void 0;
+  } catch {
+    return void 0;
   }
 }
+function resolvePayloadRoot() {
+  const root = readLocalPackageRoot();
+  if (!root) return void 0;
+  const payload = path4.join(root, "framework");
+  return fs3.existsSync(payload) ? payload : void 0;
+}
 
-// src/utils/sessionId.ts
-function generateSessionId(options = {}) {
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  const date = now.toISOString().slice(0, 10);
-  const slug = normalizeDescriptor(options.descriptor);
-  return `${date}-${slug}`;
+// src/lib/marker.ts
+import fs4 from "fs";
+import path5 from "path";
+import yaml from "js-yaml";
+function readProjectMarker(projectRoot) {
+  const markerPath = path5.join(projectRoot, ".lincoln.yaml");
+  if (!fs4.existsSync(markerPath)) {
+    return void 0;
+  }
+  try {
+    const parsed = yaml.load(fs4.readFileSync(markerPath, "utf8"));
+    if (!parsed || typeof parsed !== "object") {
+      return void 0;
+    }
+    return {
+      enabled: Boolean(parsed.enabled),
+      workflow_template: typeof parsed.workflow_template === "string" ? parsed.workflow_template : void 0,
+      min_lincoln_version: typeof parsed.min_lincoln_version === "string" ? parsed.min_lincoln_version : void 0
+    };
+  } catch {
+    return void 0;
+  }
 }
-function normalizeDescriptor(descriptor) {
-  if (!descriptor) {
-    return "recording";
+function writeProjectMarker(projectRoot, marker, opts = {}) {
+  const markerPath = path5.join(projectRoot, ".lincoln.yaml");
+  if (fs4.existsSync(markerPath) && !opts.force) {
+    throw new Error(`.lincoln.yaml already exists at ${markerPath}; use --force to overwrite`);
+  }
+  const content = yaml.dump(marker, { sortKeys: false, lineWidth: -1 });
+  if (!opts.dryRun) {
+    fs4.mkdirSync(projectRoot, { recursive: true });
+    fs4.writeFileSync(markerPath, content);
   }
-  const normalized = descriptor.trim().toLowerCase().replace(/[^a-z0-9一-龥]+/g, "-").replace(/^-+|-+$/g, "");
-  return normalized.slice(0, 80) || "recording";
 }
 
-// src/config/resolveConfig.ts
-function pickFirst(...values) {
-  for (const value of values) {
-    if (value !== void 0 && value !== "") {
-      return value;
-    }
-  }
-  return "";
-}
-function uniqueSessionId(workspaceRoot, now, descriptor) {
-  const baseSessionId = generateSessionId({ now, descriptor });
-  const recordingPath = join(workspaceRoot, "recordings", `${baseSessionId}.m4a`);
-  if (!existsSync(recordingPath)) {
-    return baseSessionId;
-  }
-  for (let counter = 1; counter <= 999; counter += 1) {
-    const candidate = `${baseSessionId}-${String(counter).padStart(3, "0")}`;
-    const candidatePath = join(workspaceRoot, "recordings", `${candidate}.m4a`);
-    if (!existsSync(candidatePath)) {
-      return candidate;
-    }
-  }
-  return baseSessionId;
-}
-function resolveConfig(args, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const home = options.home ?? homedir();
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  const globalConfig = loadConfigOptional(join(home, ".lincolnrc"));
-  const localConfig = loadConfigOptional(join(cwd, ".lincolnrc"));
-  const topic = pickFirst(args.topic, localConfig.defaultTopic, globalConfig.defaultTopic);
-  const designId = pickFirst(args.designId, localConfig.defaultDesignId, globalConfig.defaultDesignId);
-  const branch = pickFirst(args.branch, localConfig.defaultBranch, globalConfig.defaultBranch);
-  const descriptor = designId || topic || void 0;
-  const sessionId = args.sessionId || uniqueSessionId(cwd, now, descriptor);
-  return {
-    workspaceRoot: cwd,
-    sessionId,
-    topic,
-    designId,
-    branch,
-    noTui: args.noTui ?? false,
-    autoProcess: localConfig.autoProcess ?? globalConfig.autoProcess ?? false,
-    showAudioMeter: localConfig.showAudioMeter ?? globalConfig.showAudioMeter ?? true,
-    audioMeterStyle: localConfig.audioMeterStyle ?? globalConfig.audioMeterStyle ?? "bar"
-  };
+// src/commands/initProject.ts
+function initProject(projectRoot, options = {}) {
+  if (!options.force && readProjectMarker(projectRoot) !== void 0) {
+    console.error(`Project already has a .lincoln.yaml. Use --force to overwrite.`);
+    return 1;
+  }
+  try {
+    writeProjectMarker(
+      projectRoot,
+      {
+        enabled: true,
+        workflow_template: "interview-to-knowledge",
+        min_lincoln_version: readLocalPackageVersion() ?? "1.5.0"
+      },
+      { force: options.force, dryRun: options.dryRun }
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to write .lincoln.yaml: ${message}`);
+    return 1;
+  }
+  if (options.dryRun) {
+    console.log(`Dry run: would create ${projectRoot}/.lincoln.yaml`);
+  } else {
+    console.log(`Created ${projectRoot}/.lincoln.yaml`);
+  }
+  return 0;
 }
 
-// src/components/RecordingApp.tsx
-import { Box as Box7, useApp } from "ink";
-import { useCallback as useCallback2, useEffect as useEffect4, useMemo, useState as useState5 } from "react";
+// src/commands/install.ts
+import fs7 from "fs";
+import path8 from "path";
+import { spawn as spawn2 } from "child_process";
 
-// src/components/StatusPanel.tsx
-import { Box, Text } from "ink";
+// src/lib/syncClaude.ts
+import fs5 from "fs";
+import path6 from "path";
+import crypto from "crypto";
 
-// src/utils/formatDuration.ts
-function formatDuration(totalSeconds) {
-  const safeSeconds = Math.max(0, Math.floor(totalSeconds));
-  const minutes = Math.floor(safeSeconds / 60);
-  const seconds = safeSeconds % 60;
-  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-}
+// src/lib/claudeMdMerge.ts
+var BEGIN = "<!-- lincoln:begin -->";
+var END = "<!-- lincoln:end -->";
+function mergeManagedBlock(existing, block) {
+  const wrapped = `${BEGIN}
+${block}
+${END}`;
+  const text = existing ?? "";
+  const beginIndex = text.indexOf(BEGIN);
+  const endIndex = text.indexOf(END);
+  if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
+    return text.slice(0, beginIndex) + wrapped + text.slice(endIndex + END.length);
+  }
+  if (text.trim().length === 0) {
+    return wrapped;
+  }
+  return `${text.trimEnd()}
 
-// src/components/StatusPanel.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-function StatusPanel({
-  sessionId,
-  topic,
-  designId,
-  branch,
-  status,
-  duration
-}) {
-  const statusLabel = {
-    idle: "Ready",
-    recording: `Recording ${formatDuration(duration)}`,
-    stopped: "Stopped",
-    cancelled: "Cancelled",
-    error: "Error"
-  }[status];
-  const statusColor = status === "recording" ? "red" : status === "error" ? "red" : status === "cancelled" ? "yellow" : "green";
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingTop: 1, children: [
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", justifyContent: "space-between", alignItems: "center", children: [
-      /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: "Lincoln Recorder" }),
-      /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
-        /* @__PURE__ */ jsx(Text, { color: statusColor, children: status === "recording" ? "\u25CF" : "\u25CB" }),
-        /* @__PURE__ */ jsx(Text, { children: statusLabel })
-      ] })
-    ] }),
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingY: 1, children: [
-      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "Session: ",
-        sessionId
-      ] }),
-      topic ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "Topic: ",
-        topic
-      ] }) : null,
-      designId ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "Design: ",
-        designId
-      ] }) : null,
-      branch ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "Branch: ",
-        branch
-      ] }) : null
-    ] })
-  ] });
+${wrapped}
+`;
 }
 
-// src/components/LogView.tsx
-import { Box as Box2, Text as Text2 } from "ink";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var TYPE_COLORS = {
-  info: void 0,
-  success: "green",
-  error: "red",
-  command: "cyan"
-};
-function LogView({ logs }) {
-  const visible = logs.slice(-8);
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-    /* @__PURE__ */ jsx2(Text2, { underline: true, dimColor: true, children: "Log" }),
-    visible.length === 0 ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "No events yet." }) : visible.map((log) => /* @__PURE__ */ jsx2(Text2, { color: TYPE_COLORS[log.type ?? "info"], children: log.message }, log.id))
-  ] });
+// src/lib/syncClaude.ts
+var COPY_SUBDIRS = [
+  "agents",
+  "skills",
+  "workflows",
+  "stages",
+  "schemas",
+  "templates",
+  "harnesses"
+];
+function sha256(filePath) {
+  const data = fs5.readFileSync(filePath);
+  return crypto.createHash("sha256").update(data).digest("hex");
 }
-
-// src/components/HintBar.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { jsx as jsx3 } from "react/jsx-runtime";
-var HINTS = {
-  idle: "[r] record  [d] devices  [m] model  [q] quit",
-  recording: "[s] stop  [c] cancel",
-  stopped: "[any key] exit",
-  cancelled: "[q] exit",
-  error: "[q] exit",
-  menu: "[\u2191\u2193] select  [enter] confirm  [esc] back"
-};
-function HintBar({ mode }) {
-  return /* @__PURE__ */ jsx3(Box3, { paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: HINTS[mode] }) });
+function sameContent(a, b) {
+  return sha256(a) === sha256(b);
 }
-
-// src/components/DevicesMenu.tsx
-import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
-import { useEffect, useState as useState2 } from "react";
-
-// src/components/SelectMenu.tsx
-import { Box as Box4, Text as Text4, useInput } from "ink";
-import { useState } from "react";
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-function SelectMenu({ title, items, onSelect, onClose, footer }) {
-  const [index, setIndex] = useState(0);
-  useInput((_input, key) => {
-    if (key.escape) {
-      onClose();
-      return;
-    }
-    if (key.upArrow) {
-      setIndex((i) => i > 0 ? i - 1 : items.length - 1);
-      return;
-    }
-    if (key.downArrow) {
-      setIndex((i) => i < items.length - 1 ? i + 1 : 0);
-      return;
-    }
-    if (key.return && items.length > 0) {
-      onSelect(items[Math.min(index, items.length - 1)].key);
-    }
-  });
-  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", paddingX: 1, children: [
-    /* @__PURE__ */ jsx4(Text4, { bold: true, children: title }),
-    items.length === 0 ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "(none)" }) : items.map((item, i) => /* @__PURE__ */ jsxs3(Text4, { color: i === index ? "cyan" : void 0, children: [
-      i === index ? "\u203A" : " ",
-      " ",
-      item.label
-    ] }, item.key)),
-    footer ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: footer }) : null
-  ] });
-}
-
-// src/components/DevicesMenu.tsx
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
-function DevicesMenu({ listDevicesFn, onSelect, onClose }) {
-  const [loadState, setLoadState] = useState2({ status: "loading" });
-  useEffect(() => {
-    let cancelled = false;
-    listDevicesFn().then((list2) => {
-      if (!cancelled) setLoadState({ status: "loaded", list: list2 });
-    }).catch((error) => {
-      if (!cancelled) {
-        setLoadState({
-          status: "error",
-          message: error instanceof Error ? error.message : String(error)
-        });
+function deepMergeSettings(existing, incoming) {
+  if (Array.isArray(existing) && Array.isArray(incoming)) {
+    return incoming;
+  }
+  if (typeof existing === "object" && existing !== null && typeof incoming === "object" && incoming !== null) {
+    const result = { ...existing };
+    for (const [key, value] of Object.entries(incoming)) {
+      if (key in result) {
+        result[key] = deepMergeSettings(result[key], value);
+      } else {
+        result[key] = value;
       }
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [listDevicesFn]);
-  useInput2(
-    (_input, key) => {
-      if (key.escape) onClose();
-    },
-    { isActive: loadState.status !== "loaded" }
-  );
-  if (loadState.status === "loading") {
-    return /* @__PURE__ */ jsx5(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Loading devices\u2026" }) });
-  }
-  if (loadState.status === "error") {
-    return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", paddingX: 1, children: [
-      /* @__PURE__ */ jsxs4(Text5, { color: "red", children: [
-        "Failed to list devices: ",
-        loadState.message
-      ] }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "[esc] back" })
-    ] });
-  }
-  const { list } = loadState;
-  const items = list.devices.map((name) => ({
-    key: name,
-    label: name === list.defaultDevice ? `${name} (default)` : name
-  }));
-  return /* @__PURE__ */ jsx5(
-    SelectMenu,
-    {
-      title: "Devices",
-      items,
-      onSelect,
-      onClose,
-      footer: "[\u2191\u2193] select  [enter] confirm  [esc] back"
     }
-  );
+    return result;
+  }
+  return incoming;
 }
-
-// src/components/ModelMenu.tsx
-import { Box as Box6, Text as Text6, useInput as useInput3 } from "ink";
-import { useEffect as useEffect2, useState as useState3 } from "react";
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
-function ModelMenu({ listModelStatusesFn, runWarmupFn, onSelect, onClose }) {
-  const [menuState, setMenuState] = useState3({ status: "loading" });
-  useEffect2(() => {
-    let cancelled = false;
-    listModelStatusesFn().then((models) => {
-      if (!cancelled) setMenuState({ status: "loaded", models });
-    }).catch((error) => {
-      if (!cancelled) {
-        setMenuState({
-          status: "error",
-          message: error instanceof Error ? error.message : String(error)
-        });
-      }
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [listModelStatusesFn]);
-  useInput3(
-    (_input, key) => {
-      if (key.escape) onClose();
-    },
-    { isActive: menuState.status === "error" }
-  );
-  const handleSelect = (name) => {
-    if (menuState.status !== "loaded") return;
-    const target = menuState.models.find((m) => m.name === name);
-    if (!target) return;
-    if (target.cached) {
-      onSelect(name);
-      return;
-    }
-    setMenuState({ status: "downloading", model: name, percent: null, downloaded: 0 });
-    runWarmupFn(name, (progress) => {
-      setMenuState({
-        status: "downloading",
-        model: name,
-        percent: progress.percent,
-        downloaded: progress.downloaded
-      });
-    }).then(() => onSelect(name)).catch((error) => {
-      setMenuState({
-        status: "error",
-        message: error instanceof Error ? error.message : String(error)
-      });
-    });
+function syncClaudeCode(opts) {
+  const report = {
+    written: [],
+    skipped: [],
+    preserved: [],
+    warnings: [],
+    settingsTouched: []
   };
-  if (menuState.status === "loading") {
-    return /* @__PURE__ */ jsx6(Box6, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Loading models\u2026" }) });
-  }
-  if (menuState.status === "error") {
-    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", paddingX: 1, children: [
-      /* @__PURE__ */ jsx6(Text6, { color: "red", children: menuState.message }),
-      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "[esc] back" })
-    ] });
-  }
-  if (menuState.status === "downloading") {
-    const progressText = menuState.percent !== null ? `${menuState.percent.toFixed(1)}%` : `${menuState.downloaded} bytes`;
-    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", paddingX: 1, children: [
-      /* @__PURE__ */ jsxs5(Text6, { children: [
-        "Downloading model '",
-        menuState.model,
-        "'\u2026 ",
-        progressText
-      ] }),
-      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "please wait" })
-    ] });
-  }
-  const items = menuState.models.map((m) => ({
-    key: m.name,
-    label: m.cached ? `\u2713 ${m.name}` : `\xB7 ${m.name} (not downloaded)`
-  }));
-  return /* @__PURE__ */ jsx6(
-    SelectMenu,
-    {
-      title: "Model",
-      items,
-      onSelect: handleSelect,
-      onClose,
-      footer: "[\u2191\u2193] select  [enter] confirm  [esc] back"
+  const payloadClaude = path6.join(opts.payloadRoot, ".claude");
+  if (!fs5.existsSync(payloadClaude)) {
+    report.warnings.push(`payload .claude directory not found: ${payloadClaude}`);
+    return report;
+  }
+  if (!opts.dryRun) {
+    fs5.mkdirSync(opts.targetDir, { recursive: true });
+  }
+  for (const subdir of COPY_SUBDIRS) {
+    const srcDir = path6.join(payloadClaude, subdir);
+    if (!fs5.existsSync(srcDir)) {
+      continue;
     }
-  );
-}
-
-// src/hooks/useKeyHandler.ts
-import { useInput as useInput4 } from "ink";
-function useKeyHandler({
-  enabled = true,
-  onRecord,
-  onStop,
-  onCancel,
-  onQuit,
-  onDevices,
-  onModel,
-  onAnyKey
-}) {
-  useInput4(
-    (input, key) => {
-      if (key.escape || input === "q" || input === "Q") {
-        onQuit?.();
-        return;
+    const destDir = path6.join(opts.targetDir, subdir);
+    if (!opts.dryRun) {
+      fs5.mkdirSync(destDir, { recursive: true });
+    }
+    for (const entry of walkSync(srcDir)) {
+      const relativePath = path6.relative(srcDir, entry);
+      const srcFile = entry;
+      const destFile = path6.join(destDir, relativePath);
+      if (fs5.existsSync(destFile) && sameContent(srcFile, destFile)) {
+        report.skipped.push(path6.join(".claude", subdir, relativePath));
+        continue;
       }
-      if (key.ctrl && input === "c") {
-        onQuit?.();
-        return;
+      if (!opts.dryRun) {
+        fs5.mkdirSync(path6.dirname(destFile), { recursive: true });
+        fs5.copyFileSync(srcFile, destFile);
       }
-      switch (input) {
-        case "r":
-        case "R":
-          onRecord?.();
-          return;
-        case "s":
-        case "S":
-          onStop?.();
-          return;
-        case "c":
-        case "C":
-          onCancel?.();
-          return;
-        case "d":
-        case "D":
-          onDevices?.();
-          return;
-        case "m":
-        case "M":
-          onModel?.();
-          return;
+      report.written.push(path6.join(".claude", subdir, relativePath));
+    }
+  }
+  const payloadSettings = path6.join(payloadClaude, "settings.json");
+  const targetSettings = path6.join(opts.targetDir, "settings.json");
+  if (fs5.existsSync(payloadSettings)) {
+    const incoming = JSON.parse(fs5.readFileSync(payloadSettings, "utf8"));
+    let merged = incoming;
+    if (fs5.existsSync(targetSettings)) {
+      const existing = JSON.parse(fs5.readFileSync(targetSettings, "utf8"));
+      merged = deepMergeSettings(existing, incoming);
+    }
+    const wouldChange = !fs5.existsSync(targetSettings) || JSON.stringify(merged) !== JSON.stringify(JSON.parse(fs5.readFileSync(targetSettings, "utf8")));
+    if (wouldChange) {
+      if (!opts.dryRun) {
+        fs5.writeFileSync(targetSettings, JSON.stringify(merged, null, 2) + "\n");
       }
-      onAnyKey?.();
-    },
-    { isActive: enabled }
-  );
+      report.written.push(".claude/settings.json");
+      report.settingsTouched = [".claude/settings.json"];
+    } else {
+      report.skipped.push(".claude/settings.json");
+    }
+  }
+  const payloadClaudeMd = path6.join(opts.payloadRoot, "CLAUDE.md");
+  const targetClaudeMd = path6.join(path6.dirname(opts.targetDir), "CLAUDE.md");
+  if (fs5.existsSync(payloadClaudeMd)) {
+    const incomingBlock = fs5.readFileSync(payloadClaudeMd, "utf8");
+    const existing = fs5.existsSync(targetClaudeMd) ? fs5.readFileSync(targetClaudeMd, "utf8") : void 0;
+    const merged = mergeManagedBlock(existing, incomingBlock);
+    if (merged !== existing) {
+      if (!opts.dryRun) {
+        fs5.writeFileSync(targetClaudeMd, merged);
+      }
+      report.written.push("CLAUDE.md");
+    } else {
+      report.skipped.push("CLAUDE.md");
+    }
+  }
+  return report;
+}
+function* walkSync(dir) {
+  const entries = fs5.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path6.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkSync(fullPath);
+    } else {
+      yield fullPath;
+    }
+  }
 }
 
-// src/recording/useRecorder.ts
-import { useCallback, useEffect as useEffect3, useRef, useState as useState4 } from "react";
+// src/lib/harnessDetect.ts
+import fs6 from "fs";
+import path7 from "path";
+import os2 from "os";
+var HARNESS_SPECS = [
+  {
+    id: "claude-code",
+    configDirName: ".claude",
+    pluginMarker: "plugins/lincoln"
+  },
+  { id: "codex", configDirName: ".codex" },
+  { id: "opencode", configDirName: ".opencode" }
+];
+function detectGlobalHarnesses(overrideHomeDir) {
+  const homeDir = overrideHomeDir ?? os2.homedir();
+  return HARNESS_SPECS.map((spec) => {
+    const configDir = path7.join(homeDir, spec.configDirName);
+    const installed = fs6.existsSync(configDir);
+    const pluginManaged = spec.pluginMarker ? fs6.existsSync(path7.join(configDir, spec.pluginMarker)) : false;
+    return {
+      id: spec.id,
+      installed,
+      configDir,
+      pluginManaged
+    };
+  });
+}
+function installedHarnessIds(homeDir) {
+  return detectGlobalHarnesses(homeDir).filter((h) => h.installed).map((h) => h.id);
+}
 
-// src/recording/spawnRecorder.ts
-import { spawn } from "child_process";
-import { EventEmitter } from "events";
-var RecorderProcessImpl = class extends EventEmitter {
-  child;
-  stopped = false;
-  exitPromise;
-  resolveExit = () => {
+// src/commands/install.ts
+function createDefaultDeps2() {
+  return {
+    paths: resolveLincolnPaths(),
+    payloadRoot: resolvePayloadRoot() || "",
+    syncClaude: syncClaudeCode
   };
-  exitSettled = false;
-  constructor(child) {
-    super();
-    this.child = child;
-    this.exitPromise = new Promise((resolve) => {
-      this.resolveExit = resolve;
+}
+async function install(options, deps = createDefaultDeps2()) {
+  if (!options.dryRun && !options.yes) {
+    console.error("This will install Lincoln globally. Run with --yes to proceed.");
+    return 1;
+  }
+  const version = readLocalPackageVersion();
+  if (!version) {
+    console.error("Could not determine Lincoln version");
+    return 1;
+  }
+  const harnesses = options.harnesses.length > 0 ? options.harnesses : installedHarnessIds(deps.paths.homeDir);
+  if (harnesses.length === 0) {
+    console.error("No agent harness detected. Install Claude Code, Codex, or OpenCode first.");
+    return 1;
+  }
+  const payloadRoot = deps.payloadRoot;
+  if (!payloadRoot || !fs7.existsSync(payloadRoot)) {
+    console.error(
+      `Lincoln payload not found. Run "npm install -g @sushanglewis/lincoln" first.`
+    );
+    return 1;
+  }
+  const versionDir = path8.join(deps.paths.versionsDir, version);
+  if (!options.dryRun) {
+    fs7.mkdirSync(versionDir, { recursive: true });
+    fs7.cpSync(payloadRoot, versionDir, { recursive: true, force: true });
+    try {
+      fs7.rmSync(deps.paths.currentDir, { recursive: true, force: true });
+      fs7.symlinkSync(versionDir, deps.paths.currentDir);
+    } catch {
+      fs7.rmSync(deps.paths.currentDir, { recursive: true, force: true });
+      fs7.cpSync(versionDir, deps.paths.currentDir, { recursive: true, force: true });
+    }
+  }
+  const report = deps.syncClaude({
+    payloadRoot: deps.paths.currentDir,
+    targetDir: deps.paths.claudeDir,
+    version,
+    dryRun: options.dryRun
+  });
+  if (!options.dryRun && !options.noVenv) {
+    const python = await resolvePythonForVenv();
+    if (!python) {
+      console.error(
+        "Python 3.10+ is required but was not found. Set LINCOLN_PYTHON to a compatible Python executable."
+      );
+      return 1;
+    }
+    await setupVenv(deps.paths, payloadRoot, python);
+  }
+  if (!options.dryRun) {
+    writeVersionMarker(deps.paths, {
+      version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      harnesses,
+      managedFiles: report.written
     });
-    this.child.on("error", (error) => {
-      this.emit("error", error);
-      this.settleExit();
+  }
+  if (options.dryRun) {
+    console.log(`Dry run: would install Lincoln ${version} for harnesses: ${harnesses.join(", ")}`);
+    console.log(`Would write ${report.written.length} files`);
+  } else {
+    console.log(`Installed Lincoln ${version} for harnesses: ${harnesses.join(", ")}`);
+    console.log(`Wrote ${report.written.length} files`);
+  }
+  return 0;
+}
+function runCommand(command, args) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn2(command, args, { stdio: "inherit" });
+    child.on("close", (code) => resolvePromise(code ?? 1));
+    child.on("error", (err) => rejectPromise(err));
+  });
+}
+var MIN_PYTHON_MAJOR2 = 3;
+var MIN_PYTHON_MINOR2 = 10;
+var DEFAULT_PYTHON_CANDIDATES = ["python3.12", "python3.11", "python3.10", "python3"];
+function parsePythonVersion2(version) {
+  const match = /(\d+)\.(\d+)/.exec(version);
+  if (!match) {
+    return void 0;
+  }
+  return { major: Number(match[1]), minor: Number(match[2]) };
+}
+async function queryPythonVersion(command) {
+  return new Promise((resolvePromise) => {
+    const child = spawn2(command, ["--version"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      shell: process.platform === "win32"
     });
-    this.child.on("exit", (code, signal) => {
-      this.emit("exit", code, signal);
-      this.settleExit();
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
     });
-    this.child.stdout.on("data", (data) => {
-      process.stdout.write(data);
+    child.on("close", (code) => {
+      const text = stdout.trim();
+      resolvePromise(code === 0 && text.length > 0 ? text : void 0);
     });
-    this.child.stderr.on("data", (data) => {
-      process.stderr.write(data);
+    child.on("error", () => resolvePromise(void 0));
+  });
+}
+async function resolvePythonForVenv(envOverride = process.env.LINCOLN_PYTHON, candidates = DEFAULT_PYTHON_CANDIDATES, queryVersion = queryPythonVersion) {
+  const list = envOverride ? [envOverride] : candidates;
+  for (const cmd of list) {
+    const version = await queryVersion(cmd);
+    if (!version) {
+      continue;
+    }
+    const parsed = parsePythonVersion2(version);
+    if (parsed && parsed.major >= MIN_PYTHON_MAJOR2 && (parsed.major > MIN_PYTHON_MAJOR2 || parsed.minor >= MIN_PYTHON_MINOR2)) {
+      return cmd;
+    }
+  }
+  return void 0;
+}
+async function setupVenv(paths, payloadRoot, pythonCommand) {
+  const pythonExe = path8.join(
+    paths.venvDir,
+    process.platform === "win32" ? "Scripts" : "bin",
+    process.platform === "win32" ? "python.exe" : "python"
+  );
+  if (!fs7.existsSync(pythonExe)) {
+    console.log("Creating Lincoln virtual environment...");
+    await runCommand(pythonCommand, ["-m", "venv", paths.venvDir]);
+  }
+  const requirementsPath = path8.join(payloadRoot, "requirements.txt");
+  if (fs7.existsSync(requirementsPath)) {
+    console.log("Installing Python dependencies...");
+    const pipExe = path8.join(
+      paths.venvDir,
+      process.platform === "win32" ? "Scripts" : "bin",
+      process.platform === "win32" ? "pip.exe" : "pip"
+    );
+    await runCommand(pipExe, ["install", "-r", requirementsPath]);
+  }
+}
+
+// src/commands/update.ts
+import { spawn as spawn3 } from "child_process";
+
+// src/lib/npmRegistry.ts
+var DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
+var FETCH_TIMEOUT_MS = 15e3;
+function createRegistryClient(registryUrl = DEFAULT_REGISTRY_URL, fetchImpl = fetch) {
+  const baseUrl = registryUrl.replace(/\/+$/, "");
+  async function fetchPackument(packageName) {
+    const url = `${baseUrl}/${encodePackageName(packageName)}`;
+    const response = await fetchImpl(url, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
     });
-    process.nextTick(() => this.emit("ready"));
+    if (!response.ok) {
+      throw new Error(
+        `npm registry returned ${response.status} ${response.statusText} for ${packageName}`
+      );
+    }
+    return await response.json();
   }
-  settleExit() {
-    if (!this.exitSettled) {
-      this.exitSettled = true;
-      this.resolveExit();
+  return {
+    async latestVersion(packageName) {
+      const packument = await fetchPackument(packageName);
+      const latest = packument["dist-tags"]?.latest;
+      if (!latest) {
+        throw new Error(`npm registry has no latest dist-tag for ${packageName}`);
+      }
+      return latest;
+    },
+    async versions(packageName) {
+      const packument = await fetchPackument(packageName);
+      return Object.keys(packument.versions ?? {});
+    },
+    async resolveVersion(packageName, spec) {
+      const packument = await fetchPackument(packageName);
+      const tagTarget = packument["dist-tags"]?.[spec];
+      if (tagTarget) {
+        return tagTarget;
+      }
+      if (packument.versions && spec in packument.versions) {
+        return spec;
+      }
+      throw new Error(`Version not found for ${packageName}: ${spec}`);
+    }
+  };
+}
+function encodePackageName(packageName) {
+  if (packageName.startsWith("@")) {
+    const slash = packageName.indexOf("/");
+    if (slash === -1) {
+      return encodeURIComponent(packageName);
     }
+    const scope = packageName.slice(1, slash);
+    const name = packageName.slice(slash + 1);
+    return `@${encodeURIComponent(scope)}%2F${encodeURIComponent(name)}`;
+  }
+  return encodeURIComponent(packageName);
+}
+
+// src/lib/semver.ts
+var SEMVER_CORE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+var NUMERIC_IDENTIFIER = /^\d+$/;
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) {
+    return void 0;
+  }
+  if (pa.major !== pb.major) return pa.major - pb.major;
+  if (pa.minor !== pb.minor) return pa.minor - pb.minor;
+  if (pa.patch !== pb.patch) return pa.patch - pb.patch;
+  return comparePrerelease(pa.prerelease, pb.prerelease);
+}
+function parseVersion(version) {
+  const match = SEMVER_CORE.exec(version.trim());
+  if (!match) {
+    return void 0;
   }
-  stop() {
-    return this._terminate("SIGINT");
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  if (a.length === 0) return 1;
+  if (b.length === 0) return -1;
+  const shared = Math.min(a.length, b.length);
+  for (let i = 0; i < shared; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x === y) continue;
+    const xNumeric = NUMERIC_IDENTIFIER.test(x);
+    const yNumeric = NUMERIC_IDENTIFIER.test(y);
+    if (xNumeric && yNumeric) return Number(x) - Number(y);
+    if (xNumeric) return -1;
+    if (yNumeric) return 1;
+    return x < y ? -1 : 1;
   }
-  cancel() {
-    return this._terminate("SIGKILL");
+  return a.length - b.length;
+}
+
+// src/commands/update.ts
+var PACKAGE_NAME = "@sushanglewis/lincoln";
+function createDefaultDeps3() {
+  const paths = resolveLincolnPaths();
+  const registry = createRegistryClient();
+  return {
+    paths,
+    latestVersion: () => registry.latestVersion(PACKAGE_NAME),
+    currentVersion: () => readVersionMarker(paths)?.version ?? readLocalPackageVersion(),
+    npmInstallGlobal: (version) => runNpmInstallGlobal(PACKAGE_NAME, version),
+    runInstall: (options) => install(options)
+  };
+}
+async function update(options, deps = {}) {
+  const resolved = { ...createDefaultDeps3(), ...deps };
+  let latest;
+  try {
+    latest = await resolved.latestVersion();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to query npm registry: ${message}`);
+    return 1;
   }
-  _terminate(signal) {
-    if (this.stopped) {
-      return this.exitPromise;
+  const current = resolved.currentVersion();
+  if (current !== void 0) {
+    const comparison = compareVersions(current, latest);
+    if (comparison !== void 0 ? comparison > 0 : false) {
+      console.log(
+        `Lincoln ${current} is ahead of the latest release (${latest}); nothing to do.`
+      );
+      return 0;
     }
-    this.stopped = true;
-    if (this.child.killed) {
-      return this.exitPromise;
+    if (comparison !== void 0 ? comparison === 0 : current === latest) {
+      console.log(`Lincoln ${current} is already up to date.`);
+      return 0;
     }
-    this.child.kill(signal);
-    const timeout = setTimeout(() => {
-      if (!this.child.killed) {
-        this.child.kill("SIGKILL");
-      }
-    }, 5e3);
-    this.exitPromise.finally(() => clearTimeout(timeout));
-    return this.exitPromise;
   }
-};
-function spawnRecorder(options) {
-  const {
-    workspaceRoot,
-    sessionId,
-    lincolnRecordPath = "lincoln-record",
-    mic,
-    model
-  } = options;
-  const args = [
-    "record",
-    "--session-id",
-    sessionId,
-    "--output",
-    workspaceRoot
-  ];
-  if (mic) {
-    args.push("--mic", mic);
-  }
-  if (model) {
-    args.push("--model", model);
-  }
-  const child = spawn(lincolnRecordPath, args, {
-    cwd: workspaceRoot,
-    stdio: ["pipe", "pipe", "pipe"]
+  const summary = `${current ?? "unknown"} -> ${latest}`;
+  if (options.check) {
+    console.log(`Lincoln update available: ${summary}`);
+    return 0;
+  }
+  if (options.dryRun) {
+    console.log(`Dry run: would update Lincoln ${summary}`);
+    return 0;
+  }
+  if (!options.yes) {
+    console.error(`Will update Lincoln ${summary}. Run with --yes to proceed.`);
+    return 1;
+  }
+  const installCode = await resolved.npmInstallGlobal(latest);
+  if (installCode !== 0) {
+    console.error(`npm install -g ${PACKAGE_NAME}@${latest} failed with exit code ${installCode}`);
+    return 1;
+  }
+  const syncCode = await resolved.runInstall(defaultInstallOptions());
+  if (syncCode !== 0) {
+    console.error(`lincoln install failed with exit code ${syncCode}`);
+    return 1;
+  }
+  console.log(`Updated Lincoln to ${latest}`);
+  return 0;
+}
+function defaultInstallOptions() {
+  return { yes: true, dryRun: false, force: false, harnesses: [], noVenv: true };
+}
+function runNpmInstallGlobal(packageName, version) {
+  return new Promise((resolvePromise) => {
+    const child = spawn3("npm", ["install", "-g", `${packageName}@${version}`], {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("close", (code) => resolvePromise(code ?? 1));
+    child.on("error", () => resolvePromise(1));
   });
-  return new RecorderProcessImpl(child);
 }
 
-// src/recording/useRecorder.ts
-function mockAmplitude(duration) {
-  return 0.5 + 0.4 * Math.sin(duration * 0.8);
-}
-function useRecorder(options) {
-  const {
-    startOnMount = false,
-    workspaceRoot,
-    sessionId,
-    lincolnRecordPath,
-    mic,
-    model
-  } = options;
-  const [state, setState] = useState4({
-    status: "idle",
-    duration: 0,
-    amplitude: 0,
-    errorMessage: null
-  });
-  const recorderRef = useRef(null);
-  const intervalRef = useRef(null);
-  const durationRef = useRef(0);
-  const terminatingRef = useRef(false);
-  const clearRecordingInterval = useCallback(() => {
-    if (intervalRef.current) {
-      clearInterval(intervalRef.current);
-      intervalRef.current = null;
-    }
-  }, []);
-  const start = useCallback(() => {
-    if (recorderRef.current) {
-      return;
-    }
-    terminatingRef.current = false;
-    setState({ status: "recording", duration: 0, amplitude: 0.3, errorMessage: null });
-    durationRef.current = 0;
-    try {
-      const recorder = spawnRecorder({
-        workspaceRoot,
-        sessionId,
-        lincolnRecordPath,
-        mic,
-        model
-      });
-      recorderRef.current = recorder;
-      recorder.on("ready", () => {
-      });
-      recorder.on("error", (error) => {
-        setState((s) => ({ ...s, status: "error", errorMessage: error.message }));
-        clearRecordingInterval();
-      });
-      recorder.on("exit", (code, signal) => {
-        recorderRef.current = null;
-        clearRecordingInterval();
-        if (terminatingRef.current) {
-          return;
-        }
-        const reason = code !== null && code !== void 0 ? `lincoln-record exited unexpectedly with code ${code}` : `lincoln-record exited unexpectedly with signal ${signal}`;
-        setState((s) => ({ ...s, status: "error", errorMessage: reason }));
-      });
-      intervalRef.current = setInterval(() => {
-        durationRef.current += 1;
-        setState((s) => ({
-          ...s,
-          duration: durationRef.current,
-          amplitude: mockAmplitude(durationRef.current)
-        }));
-      }, 1e3);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      setState((s) => ({ ...s, status: "error", errorMessage: message }));
-    }
-  }, [workspaceRoot, sessionId, lincolnRecordPath, mic, model, clearRecordingInterval]);
-  const stop = useCallback(async () => {
-    const recorder = recorderRef.current;
-    if (!recorder) return;
-    terminatingRef.current = true;
-    clearRecordingInterval();
-    setState((s) => ({ ...s, status: "stopped" }));
-    await recorder.stop();
-  }, [clearRecordingInterval]);
-  const cancel = useCallback(async () => {
-    const recorder = recorderRef.current;
-    if (!recorder) return;
-    terminatingRef.current = true;
-    clearRecordingInterval();
-    setState((s) => ({ ...s, status: "cancelled" }));
-    await recorder.cancel();
-  }, [clearRecordingInterval]);
-  useEffect3(() => {
-    if (startOnMount) {
-      start();
-    }
-    return () => {
-      clearRecordingInterval();
-      if (recorderRef.current) {
-        recorderRef.current.cancel().catch(() => {
-        });
-        recorderRef.current = null;
+// src/commands/use.ts
+import fs8 from "fs";
+import path9 from "path";
+import { spawn as spawn4 } from "child_process";
+var PACKAGE_NAME2 = "@sushanglewis/lincoln";
+var SEMVER_REGEX = /^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var STRICT_SEMVER_REGEX = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var DIST_TAG_REGEX = /^[a-zA-Z][a-zA-Z0-9._-]*$/;
+function createDefaultDeps4() {
+  const paths = resolveLincolnPaths();
+  const registry = createRegistryClient();
+  return {
+    paths,
+    resolveVersion: async (spec) => {
+      const normalized = spec.startsWith("v") ? spec.slice(1) : spec;
+      if (STRICT_SEMVER_REGEX.test(normalized)) {
+        return normalized;
       }
-    };
-  }, [startOnMount, start, clearRecordingInterval]);
-  return { state, start, stop, cancel };
+      return registry.resolveVersion(PACKAGE_NAME2, spec);
+    },
+    ensureVersionAvailable: async (version) => {
+      const code = await runNpmInstallGlobal2(PACKAGE_NAME2, version);
+      if (code !== 0) {
+        throw new Error(`npm install -g ${PACKAGE_NAME2}@${version} exited with ${code}`);
+      }
+    },
+    npmGlobalRoot: () => runNpmRootGlobal(),
+    runInstall: (options) => install(options)
+  };
 }
-
-// src/devices/listDevices.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-
-// src/devices/parseDevices.ts
-var DEFAULT_PREFIX = "Default input: ";
-function parseDevicesOutput(output) {
-  let defaultDevice = null;
-  const devices = [];
-  for (const rawLine of output.split("\n")) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    if (line.startsWith(DEFAULT_PREFIX)) {
-      defaultDevice = line.slice(DEFAULT_PREFIX.length).trim() || null;
-      continue;
+async function use(spec, options, deps = {}) {
+  if (!isValidVersion(spec)) {
+    console.error(`Invalid version: ${spec}`);
+    return 1;
+  }
+  const resolved = { ...createDefaultDeps4(), ...deps };
+  let version;
+  try {
+    version = await resolved.resolveVersion(spec);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to resolve version ${spec}: ${message}`);
+    return 1;
+  }
+  const versionDir = path9.join(resolved.paths.versionsDir, version);
+  const alreadyInstalled = fs8.existsSync(versionDir);
+  if (options.dryRun) {
+    if (alreadyInstalled) {
+      console.log(`Dry run: would switch ${resolved.paths.currentDir} to ${versionDir}`);
+    } else {
+      console.log(
+        `Dry run: would install ${PACKAGE_NAME2}@${version} globally, then switch ${resolved.paths.currentDir} to ${versionDir}`
+      );
+    }
+    return 0;
+  }
+  if (!options.yes) {
+    console.error(`Will switch Lincoln to ${version}. Run with --yes to proceed.`);
+    return 1;
+  }
+  if (!alreadyInstalled) {
+    try {
+      await resolved.ensureVersionAvailable(version);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to install ${PACKAGE_NAME2}@${version}: ${message}`);
+      return 1;
+    }
+    if (!fs8.existsSync(versionDir)) {
+      try {
+        await copyVersionFromNpmGlobal(resolved, versionDir);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to populate ${versionDir}: ${message}`);
+        return 1;
+      }
     }
-    devices.push(line);
+    if (!fs8.existsSync(versionDir)) {
+      console.error(
+        `Provisioning ${PACKAGE_NAME2}@${version} did not produce ${versionDir}; cannot switch versions.`
+      );
+      return 1;
+    }
+  }
+  try {
+    switchCurrentLink(resolved.paths, versionDir);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to switch ${resolved.paths.currentDir}: ${message}`);
+    return 1;
+  }
+  const syncCode = await resolved.runInstall(defaultInstallOptions2());
+  if (syncCode !== 0) {
+    console.error(`lincoln install failed with exit code ${syncCode}`);
+    return 1;
+  }
+  try {
+    switchCurrentLink(resolved.paths, versionDir);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to switch ${resolved.paths.currentDir}: ${message}`);
+    return 1;
   }
-  return { defaultDevice, devices };
+  console.log(`Switched Lincoln to ${version}`);
+  return 0;
 }
-
-// src/devices/listDevices.ts
-var execFileAsync = promisify(execFile);
-async function listDevices(lincolnRecordPath = "lincoln-record") {
-  const { stdout } = await execFileAsync(lincolnRecordPath, ["devices"]);
-  return parseDevicesOutput(stdout);
+function isValidVersion(version) {
+  return SEMVER_REGEX.test(version) || DIST_TAG_REGEX.test(version);
 }
-
-// src/models/models.ts
-import { existsSync as existsSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-var KNOWN_MODELS = [
-  "tiny",
-  "base",
-  "small",
-  "medium",
-  "large-v1",
-  "large-v2",
-  "large-v3",
-  "large-v3-turbo"
-];
-function defaultModelCacheDir() {
-  return join2(homedir2(), ".cache", "lincoln", "models");
+async function copyVersionFromNpmGlobal(deps, versionDir) {
+  const globalRoot = await deps.npmGlobalRoot();
+  if (!globalRoot) {
+    return;
+  }
+  const packageRoot = path9.join(globalRoot, ...PACKAGE_NAME2.split("/"));
+  if (!fs8.existsSync(packageRoot)) {
+    return;
+  }
+  fs8.mkdirSync(path9.dirname(versionDir), { recursive: true });
+  fs8.cpSync(packageRoot, versionDir, { recursive: true });
+}
+function switchCurrentLink(paths, versionDir) {
+  fs8.mkdirSync(paths.lincolnHome, { recursive: true });
+  try {
+    fs8.rmSync(paths.currentDir, { recursive: true, force: true });
+    fs8.symlinkSync(versionDir, paths.currentDir);
+  } catch {
+    fs8.rmSync(paths.currentDir, { recursive: true, force: true });
+    fs8.cpSync(versionDir, paths.currentDir, { recursive: true, force: true });
+  }
 }
-function modelCachePath(name, cacheDir) {
-  return join2(cacheDir, "whisper", `ggml-${name}.bin`);
+function defaultInstallOptions2() {
+  return { yes: true, dryRun: false, force: false, harnesses: [], noVenv: true };
 }
-function listModelStatuses(cacheDir) {
-  return KNOWN_MODELS.map((name) => ({
-    name,
-    cached: existsSync2(modelCachePath(name, cacheDir))
-  }));
+function runNpmInstallGlobal2(packageName, version) {
+  return new Promise((resolvePromise) => {
+    const child = spawn4("npm", ["install", "-g", `${packageName}@${version}`], {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("close", (code) => resolvePromise(code ?? 1));
+    child.on("error", () => resolvePromise(1));
+  });
+}
+function runNpmRootGlobal() {
+  return new Promise((resolvePromise) => {
+    const child = spawn4("npm", ["root", "-g"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      shell: process.platform === "win32"
+    });
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.on("close", (code) => {
+      const root = stdout.trim();
+      resolvePromise(code === 0 && root.length > 0 ? root : void 0);
+    });
+    child.on("error", () => resolvePromise(void 0));
+  });
 }
 
-// src/models/runWarmup.ts
-import { spawn as spawn2 } from "child_process";
+// src/commands/migrateProject.ts
+import fs10 from "fs";
+import path11 from "path";
 
-// src/models/warmupProgress.ts
-var PROGRESS_WITH_TOTAL = /downloaded (\d+) \/ (\d+) bytes \(([\d.]+)%\)/;
-var PROGRESS_WITHOUT_TOTAL = /downloaded (\d+) bytes/;
-function parseWarmupProgress(chunk) {
-  const withTotal = PROGRESS_WITH_TOTAL.exec(chunk);
-  if (withTotal) {
-    return {
-      downloaded: Number(withTotal[1]),
-      total: Number(withTotal[2]),
-      percent: Number(withTotal[3])
-    };
+// src/lib/projectFiles.ts
+import fs9 from "fs";
+import path10 from "path";
+import crypto2 from "crypto";
+var FRAMEWORK_ALLOWLIST_DIRS = [".claude", ".claude-plugin", "scripts", "tools"];
+var FRAMEWORK_ALLOWLIST_FILES = [
+  "README.md",
+  "README.en.md",
+  "USAGE.md",
+  "CONTRIBUTING.md",
+  "CLAUDE.md",
+  "LICENSE",
+  "RELEASE.md",
+  ".version-bump.json",
+  "requirements.txt",
+  "SKILL.md"
+];
+var FRAMEWORK_DENYLIST_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  ".context",
+  ".venv",
+  "venv",
+  "dist",
+  "oss",
+  ".pytest_cache",
+  "__pycache__",
+  ".DS_Store",
+  "node_modules"
+]);
+var FRAMEWORK_DENYLIST_PREFIXES = ["issue-"];
+var FRAMEWORK_SKIP_PATHS = /* @__PURE__ */ new Set([
+  ".claude/templates/issue-package",
+  "tools/lincoln-installer/dist",
+  "tools/lincoln-installer/node_modules",
+  "tools/lincoln-installer/coverage"
+]);
+function sha2562(filePath) {
+  return crypto2.createHash("sha256").update(fs9.readFileSync(filePath)).digest("hex");
+}
+function isDenied(relativePath) {
+  const parts = relativePath.split(path10.sep);
+  for (const part of parts) {
+    if (FRAMEWORK_DENYLIST_NAMES.has(part)) return true;
+    for (const prefix of FRAMEWORK_DENYLIST_PREFIXES) {
+      if (part.startsWith(prefix)) return true;
+    }
   }
-  const withoutTotal = PROGRESS_WITHOUT_TOTAL.exec(chunk);
-  if (withoutTotal) {
-    return {
-      downloaded: Number(withoutTotal[1]),
-      total: null,
-      percent: null
-    };
+  for (const skip of FRAMEWORK_SKIP_PATHS) {
+    if (relativePath === skip || relativePath.startsWith(skip + path10.sep)) return true;
   }
-  return null;
+  return false;
 }
-
-// src/models/runWarmup.ts
-var READY_LINE = /Model ready at (.+)/;
-function runWarmup(options) {
-  const { model, lincolnRecordPath = "lincoln-record", onProgress } = options;
-  return new Promise((resolve, reject) => {
-    const child = spawn2(lincolnRecordPath, ["warmup", "--model", model], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let readyPath = null;
-    child.stdout.on("data", (data) => {
-      const match = READY_LINE.exec(data.toString());
-      if (match) {
-        readyPath = match[1].trim();
+function isAllowlisted(relativePath) {
+  if (FRAMEWORK_ALLOWLIST_FILES.includes(relativePath)) return true;
+  for (const dir of FRAMEWORK_ALLOWLIST_DIRS) {
+    if (relativePath === dir || relativePath.startsWith(dir + path10.sep)) return true;
+  }
+  return false;
+}
+function isPreservedDir(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  if (normalized === ".context" || normalized.startsWith(".context/")) return true;
+  const parts = normalized.split("/");
+  for (const part of parts) {
+    if (part.startsWith("issue-")) return true;
+  }
+  return false;
+}
+function isPreserved(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  if (normalized === ".github/openspec-config.yml") return true;
+  return isPreservedDir(relativePath);
+}
+function listVendoredFrameworkFiles(payloadRoot, projectRoot) {
+  const report = { removable: [], modified: [], preserved: [] };
+  function walk(dir) {
+    const entries = fs9.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path10.join(dir, entry.name);
+      const relativePath = path10.relative(projectRoot, fullPath);
+      if (entry.isDirectory()) {
+        if (isPreservedDir(relativePath)) {
+          walk(fullPath);
+        } else if (!isDenied(relativePath)) {
+          walk(fullPath);
+        }
+        continue;
       }
-    });
-    child.stderr.on("data", (data) => {
-      const progress = parseWarmupProgress(data.toString());
-      if (progress) {
-        onProgress?.(progress);
+      if (isPreserved(relativePath)) {
+        report.preserved.push(relativePath);
+        continue;
       }
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code === 0) {
-        resolve(readyPath ?? model);
+      if (isDenied(relativePath)) continue;
+      if (!isAllowlisted(relativePath)) continue;
+      const payloadFile = path10.join(payloadRoot, relativePath);
+      if (!fs9.existsSync(payloadFile)) {
+        report.modified.push(relativePath);
+        continue;
+      }
+      if (sha2562(fullPath) === sha2562(payloadFile)) {
+        report.removable.push(relativePath);
       } else {
-        reject(new Error(`lincoln-record warmup exited with code ${code}`));
+        report.modified.push(relativePath);
       }
-    });
-  });
+    }
+  }
+  if (fs9.existsSync(projectRoot)) {
+    walk(projectRoot);
+  }
+  return report;
 }
 
-// src/components/RecordingApp.tsx
-import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
-function createLogId() {
-  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function RecordingApp({
-  workspaceRoot,
-  sessionId,
-  topic,
-  designId,
-  branch,
-  audioMeterStyle = "bar",
-  lincolnRecordPath,
-  listDevicesFn,
-  listModelStatusesFn,
-  runWarmupFn
-}) {
-  const { exit } = useApp();
-  const [logs, setLogs] = useState5([]);
-  const [mode, setMode] = useState5("main");
-  const [mic, setMic] = useState5(null);
-  const [model, setModel] = useState5(null);
-  const addLog = useCallback2((message, type = "info") => {
-    setLogs((prev) => [...prev, { id: createLogId(), message, type }]);
-  }, []);
-  const { state, start, stop, cancel } = useRecorder({
-    workspaceRoot,
-    sessionId,
-    lincolnRecordPath,
-    mic,
-    model,
-    startOnMount: false
-  });
-  useEffect4(() => {
-    switch (state.status) {
-      case "recording":
-        addLog("Recording started.", "info");
-        break;
-      case "stopped":
-        addLog(`Saved to ${workspaceRoot}/${sessionId}/audio.wav`, "success");
-        addLog(`Run: claude process-interview ${sessionId}`, "command");
-        break;
-      case "cancelled":
-        addLog("Recording cancelled. No files were saved.", "error");
-        break;
-      case "error":
-        addLog(`Recording error: ${state.errorMessage ?? "unknown error"}`, "error");
-        break;
-    }
-  }, [state.status, state.errorMessage, addLog, workspaceRoot, sessionId]);
-  const handleQuit = useCallback2(() => {
-    exit();
-  }, [exit]);
-  const handleRecord = useCallback2(() => {
-    if (state.status === "idle") {
-      start();
-    }
-  }, [state.status, start]);
-  const handleStop = useCallback2(() => {
-    if (state.status === "recording") {
-      stop().catch(() => {
-      });
-    }
-  }, [state.status, stop]);
-  const handleCancel = useCallback2(() => {
-    if (state.status === "recording") {
-      cancel().catch(() => {
-      });
-    }
-  }, [state.status, cancel]);
-  const handleDevices = useCallback2(() => {
-    if (state.status === "idle") {
-      setMode("devices");
-    }
-  }, [state.status]);
-  const handleModel = useCallback2(() => {
-    if (state.status === "idle") {
-      setMode("model");
-    }
-  }, [state.status]);
-  const handleDeviceSelect = useCallback2(
-    (device) => {
-      setMic(device);
-      addLog(`Input device: ${device}`, "success");
-      setMode("main");
-    },
-    [addLog]
-  );
-  const handleModelSelect = useCallback2(
-    (name) => {
-      setModel(name);
-      addLog(`Model: ${name}`, "success");
-      setMode("main");
-    },
-    [addLog]
-  );
-  const handleMenuClose = useCallback2(() => {
-    setMode("main");
-  }, []);
-  const isTerminal = state.status === "stopped" || state.status === "cancelled" || state.status === "error";
-  useKeyHandler({
-    enabled: mode === "main",
-    onRecord: handleRecord,
-    onStop: handleStop,
-    onCancel: handleCancel,
-    onQuit: handleQuit,
-    onDevices: handleDevices,
-    onModel: handleModel,
-    onAnyKey: isTerminal ? handleQuit : void 0
-  });
-  const hintMode = useMemo(() => {
-    if (mode !== "main") return "menu";
-    if (state.status === "idle") return "idle";
-    if (state.status === "recording") return "recording";
-    if (state.status === "stopped") return "stopped";
-    if (state.status === "cancelled") return "cancelled";
-    return "error";
-  }, [mode, state.status]);
-  const devicesLoader = useCallback2(
-    () => (listDevicesFn ?? (() => listDevices(lincolnRecordPath)))(),
-    [listDevicesFn, lincolnRecordPath]
-  );
-  const modelsLoader = useCallback2(
-    () => (listModelStatusesFn ?? (() => Promise.resolve(listModelStatuses(defaultModelCacheDir()))))(),
-    [listModelStatusesFn]
-  );
-  const warmupRunner = useCallback2(
-    (name, onProgress) => runWarmupFn ? runWarmupFn(name, onProgress) : runWarmup({ model: name, lincolnRecordPath, onProgress }),
-    [runWarmupFn, lincolnRecordPath]
-  );
-  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "gray", height: 24, children: [
-    /* @__PURE__ */ jsx7(
-      StatusPanel,
-      {
-        sessionId,
-        topic,
-        designId,
-        branch,
-        status: state.status,
-        duration: state.duration
-      }
-    ),
-    mode === "devices" && /* @__PURE__ */ jsx7(
-      DevicesMenu,
-      {
-        listDevicesFn: devicesLoader,
-        onSelect: handleDeviceSelect,
-        onClose: handleMenuClose
+// src/commands/migrateProject.ts
+function createDefaultDeps5() {
+  return {
+    paths: resolveLincolnPaths(),
+    listVendoredFrameworkFiles,
+    writeProjectMarker
+  };
+}
+async function migrateProject(projectRoot, options = {}, deps = createDefaultDeps5()) {
+  const payloadRoot = deps.paths.currentDir;
+  if (!fs10.existsSync(payloadRoot)) {
+    console.error(`Lincoln payload not found at ${payloadRoot}. Run "lincoln install" first.`);
+    return 1;
+  }
+  const absoluteProjectRoot = path11.resolve(projectRoot);
+  const report = deps.listVendoredFrameworkFiles(payloadRoot, absoluteProjectRoot);
+  if (options.dryRun) {
+    console.log(`Dry run: would migrate ${absoluteProjectRoot}`);
+    if (report.removable.length > 0) {
+      console.log("Would remove unmodified framework files:");
+      for (const f of report.removable) console.log(`  - ${f}`);
+    }
+    if (report.modified.length > 0) {
+      console.log("Would preserve modified framework files:");
+      for (const f of report.modified) console.log(`  - ${f}`);
+    }
+    if (report.preserved.length > 0) {
+      console.log("Would preserve project-local files:");
+      for (const f of report.preserved) console.log(`  - ${f}`);
+    }
+    console.log("Would create .lincoln.yaml");
+    return 0;
+  }
+  if (!options.yes) {
+    console.error("This will remove vendored framework files. Run with --yes to proceed.");
+    return 1;
+  }
+  for (const file of report.removable) {
+    const filePath = path11.join(absoluteProjectRoot, file);
+    try {
+      fs10.rmSync(filePath);
+      let dir = path11.dirname(filePath);
+      while (dir !== absoluteProjectRoot && fs10.existsSync(dir)) {
+        const entries = fs10.readdirSync(dir);
+        if (entries.length === 0) {
+          fs10.rmdirSync(dir);
+          dir = path11.dirname(dir);
+        } else {
+          break;
+        }
       }
-    ),
-    mode === "model" && /* @__PURE__ */ jsx7(
-      ModelMenu,
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to remove ${file}: ${message}`);
+      return 1;
+    }
+  }
+  if (report.modified.length > 0) {
+    console.log("Preserved modified framework files:");
+    for (const f of report.modified) console.log(`  - ${f}`);
+  }
+  if (report.preserved.length > 0) {
+    console.log("Preserved project-local files:");
+    for (const f of report.preserved) console.log(`  - ${f}`);
+  }
+  try {
+    deps.writeProjectMarker(
+      absoluteProjectRoot,
       {
-        listModelStatusesFn: modelsLoader,
-        runWarmupFn: warmupRunner,
-        onSelect: handleModelSelect,
-        onClose: handleMenuClose
-      }
-    ),
-    /* @__PURE__ */ jsx7(LogView, { logs }),
-    /* @__PURE__ */ jsx7(Box7, { flexGrow: 1 }),
-    /* @__PURE__ */ jsx7(HintBar, { mode: hintMode })
-  ] });
+        enabled: true,
+        workflow_template: "interview-to-knowledge",
+        min_lincoln_version: readLocalPackageVersion() ?? "1.5.0"
+      },
+      { force: options.force }
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to write .lincoln.yaml: ${message}`);
+    return 1;
+  }
+  console.log(`Migrated project at ${absoluteProjectRoot}`);
+  console.log(`Removed ${report.removable.length} unmodified framework files`);
+  return 0;
 }
 
-// src/cli.tsx
-import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
-function App({ args, config }) {
-  if (args.help) {
-    return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", padding: 1, children: [
-      /* @__PURE__ */ jsx8(Text7, { bold: true, children: "lincoln" }),
-      /* @__PURE__ */ jsx8(Text7, { children: "Cross-tool TUI for Lincoln interview recording." }),
-      /* @__PURE__ */ jsx8(Text7, {}),
-      /* @__PURE__ */ jsx8(Text7, { bold: true, children: "Usage:" }),
-      /* @__PURE__ */ jsx8(Text7, { children: "  lincoln [options]" }),
-      /* @__PURE__ */ jsx8(Text7, {}),
-      /* @__PURE__ */ jsx8(Text7, { bold: true, children: "Options:" }),
-      /* @__PURE__ */ jsx8(Text7, { children: "  --topic       Interview topic" }),
-      /* @__PURE__ */ jsx8(Text7, { children: "  --design-id   Design ID for the session" }),
-      /* @__PURE__ */ jsx8(Text7, { children: "  --branch      Current branch name" }),
-      /* @__PURE__ */ jsx8(Text7, { children: "  --session-id  Explicit session ID" }),
-      /* @__PURE__ */ jsx8(Text7, { children: "  --no-tui      Run without the terminal UI" }),
-      /* @__PURE__ */ jsx8(Text7, { children: "  --help, -h    Show this help message" }),
-      /* @__PURE__ */ jsx8(Text7, {}),
-      /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "Configuration files: ~/.lincolnrc, ./.lincolnrc" })
-    ] });
-  }
-  return /* @__PURE__ */ jsx8(
-    RecordingApp,
-    {
-      workspaceRoot: config.workspaceRoot,
-      sessionId: config.sessionId,
-      topic: config.topic,
-      designId: config.designId,
-      branch: config.branch,
-      audioMeterStyle: config.audioMeterStyle
-    }
-  );
+// src/commands/record.ts
+import { spawn as spawn5 } from "child_process";
+import { EventEmitter } from "events";
+function createDefaultDeps6() {
+  return { spawn: spawn5 };
 }
-async function main(argv = process.argv.slice(2)) {
-  const args = parseArgs(argv);
-  const config = resolveConfig(args);
-  if (args.noTui) {
-    console.log(JSON.stringify(config, null, 2));
-    return;
-  }
-  const { render } = await import("ink");
-  render(/* @__PURE__ */ jsx8(App, { args, config }));
+function record(args, deps = createDefaultDeps6()) {
+  return new Promise((resolve) => {
+    const child = deps.spawn("lincoln-record", args, { stdio: "inherit" });
+    child.on("error", (err) => {
+      console.error(`Failed to start lincoln-record: ${err.message}`);
+      resolve(1);
+    });
+    child.on("close", (code) => {
+      resolve(code ?? 0);
+    });
+  });
 }
 
-// src/main.tsx
-main();
+// src/main.ts
+var USAGE = `Lincoln \u2014 Global agent harness plugin CLI
+
+Usage:
+  lincoln <command> [options]
+
+Commands:
+  install          One-time global setup: sync to ~/.claude/, ~/.codex/, ~/.opencode/
+  update           Pull latest release and re-sync globally
+  use <version>   Switch active global version
+  doctor           Diagnose harness integration
+  init-project     Create .lincoln.yaml in current project
+  migrate-project  Remove vendored framework files from an existing project
+  record           Launch the Lincoln interview recorder TUI
+  help             Show this help message
+
+Options:
+  --yes, -y        Skip confirmation prompts
+  --dry-run        Show what would be done without making changes
+  --force          Force re-install even if up to date
+  --check          Check for available updates without installing (update)
+  --json           Output machine-readable JSON (where supported)
+  --help, -h       Show this help message
+`;
+async function main(argv) {
+  const parsed = parseArgs(argv);
+  if (parsed.command === "help") {
+    console.log(USAGE);
+    return 0;
+  }
+  if (parsed.command === "install") {
+    return install({
+      yes: Boolean(parsed.flags.yes || parsed.flags.y),
+      dryRun: Boolean(parsed.flags["dry-run"]),
+      force: Boolean(parsed.flags.force),
+      harnesses: parsed.args,
+      noVenv: Boolean(parsed.flags["no-venv"])
+    });
+  }
+  if (parsed.command === "update") {
+    return update({
+      check: Boolean(parsed.flags.check),
+      dryRun: Boolean(parsed.flags["dry-run"]),
+      yes: Boolean(parsed.flags.yes || parsed.flags.y)
+    });
+  }
+  if (parsed.command === "use") {
+    const version = parsed.args[0];
+    if (!version) {
+      console.error("Usage: lincoln use <version> [--yes] [--dry-run]");
+      return 1;
+    }
+    return use(version, {
+      dryRun: Boolean(parsed.flags["dry-run"]),
+      yes: Boolean(parsed.flags.yes || parsed.flags.y)
+    });
+  }
+  if (parsed.command === "doctor") {
+    const result = await doctor({ json: Boolean(parsed.flags.json) });
+    return result.code;
+  }
+  if (parsed.command === "init-project") {
+    return initProject(process.cwd(), {
+      force: Boolean(parsed.flags.force),
+      dryRun: Boolean(parsed.flags["dry-run"])
+    });
+  }
+  if (parsed.command === "migrate-project") {
+    return migrateProject(process.cwd(), {
+      dryRun: Boolean(parsed.flags["dry-run"]),
+      yes: Boolean(parsed.flags.yes || parsed.flags.y),
+      force: Boolean(parsed.flags.force)
+    });
+  }
+  if (parsed.command === "record") {
+    return record(parsed.args);
+  }
+  console.log(USAGE);
+  return 0;
+}
+if (process.argv[1] && path12.resolve(fs11.realpathSync(fileURLToPath2(import.meta.url))) === path12.resolve(fs11.realpathSync(process.argv[1]))) {
+  main(process.argv).then((code) => process.exit(code));
+}
+export {
+  main
+};
 //# sourceMappingURL=main.js.map