@vaka.world/cli 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1236 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { cancel, confirm, intro, isCancel, log, outro, text } from "@clack/prompts";
+
+// src/commands/init.ts
+import { lstat, mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
+var rules = `version: 1
+checkpoints:
+  build:
+    required: true
+  design:
+    required: true
+  implementation:
+    required: true
+verification:
+  local_status: unverified
+`;
+var managedStart = "<!-- BEGIN VAKA MANAGED INSTRUCTIONS -->";
+var managedEnd = "<!-- END VAKA MANAGED INSTRUCTIONS -->";
+var sharedGuidance = `Before implementing a feature, help the developer reason through its behavior, data, and failure cases. Keep understanding, design confirmation, and implementation authorization distinct. Do not write code until the developer explicitly authorizes the scoped implementation; design confirmation alone is not implementation approval. Explain unfamiliar code and why each change is needed.
+
+Vaka instructions are guidance, not a technical enforcement boundary. Local session files are unverified; only a server-accepted seal can be described as server-verified.`;
+var instructions = {
+  claude: `# Vaka
+
+${sharedGuidance}
+`,
+  cursor: `---
+description: Vaka architecture and reasoning guidance
+alwaysApply: true
+---
+
+${sharedGuidance}
+`,
+  copilot: `# Vaka
+
+${sharedGuidance}
+`,
+  codex: sharedGuidance,
+  windsurfOwnFile: `---
+trigger: always_on
+description: Vaka architecture and reasoning guidance
+---
+
+${sharedGuidance}
+`,
+  windsurfMerge: sharedGuidance,
+  clineOwnFile: `# Vaka
+
+${sharedGuidance}
+`,
+  clineMerge: sharedGuidance
+};
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isAlreadyExists(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+async function inspectPath(path) {
+  try {
+    const stat = await lstat(path);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Refusing to follow symbolic link: ${path}`);
+    }
+    if (stat.isDirectory()) return "directory";
+    if (stat.isFile()) return "file";
+    return void 0;
+  } catch (error) {
+    if (isMissing(error)) return void 0;
+    throw error;
+  }
+}
+async function detectIntegrations(projectRoot) {
+  const [
+    cursor,
+    claudeManifest,
+    claudeDirectory,
+    copilotManifest,
+    instructionsDirectory,
+    codexManifest,
+    codexDirectory,
+    windsurfDirectory,
+    windsurfLegacyFile,
+    clinerules
+  ] = await Promise.all([
+    inspectPath(join(projectRoot, ".cursor")),
+    inspectPath(join(projectRoot, "CLAUDE.md")),
+    inspectPath(join(projectRoot, ".claude")),
+    inspectPath(join(projectRoot, ".github", "copilot-instructions.md")),
+    inspectPath(join(projectRoot, ".github", "instructions")),
+    inspectPath(join(projectRoot, "AGENTS.md")),
+    inspectPath(join(projectRoot, ".codex")),
+    inspectPath(join(projectRoot, ".windsurf")),
+    inspectPath(join(projectRoot, ".windsurfrules")),
+    inspectPath(join(projectRoot, ".clinerules"))
+  ]);
+  const integrations = [];
+  if (cursor === "directory") integrations.push("cursor");
+  if (claudeManifest === "file" || claudeDirectory === "directory") {
+    integrations.push("claude");
+  }
+  let copilotDetected = copilotManifest === "file" || instructionsDirectory === "directory";
+  const vscodeSettings = join(projectRoot, ".vscode", "settings.json");
+  if (!copilotDetected && await inspectPath(vscodeSettings) === "file") {
+    const settings = await readFile(vscodeSettings, "utf8");
+    copilotDetected = /"github\.copilot\.[^"]+"\s*:/.test(settings);
+  }
+  if (copilotDetected) integrations.push("copilot");
+  if (codexManifest === "file" || codexDirectory === "directory") {
+    integrations.push("codex");
+  }
+  if (windsurfDirectory === "directory" || windsurfLegacyFile === "file") {
+    integrations.push("windsurf");
+  }
+  if (clinerules === "file" || clinerules === "directory") {
+    integrations.push("cline");
+  }
+  return integrations;
+}
+async function ensureDirectory(projectRoot, relativePath) {
+  const absolutePath = resolve(projectRoot, relativePath);
+  const fromRoot = relative(projectRoot, absolutePath);
+  if (fromRoot.startsWith("..") || isAbsolute(fromRoot)) {
+    throw new Error(`Refusing to create a directory outside the project: ${relativePath}`);
+  }
+  const segments = fromRoot.split(/[/\\]/).filter(Boolean);
+  let current = projectRoot;
+  for (const segment of segments) {
+    current = join(current, segment);
+    const existing = await inspectPath(current);
+    if (existing === "file") {
+      throw new Error(`Expected a directory, found a file: ${current}`);
+    }
+    if (existing === void 0) {
+      try {
+        await mkdir(current, { mode: segment === ".vaka" ? 448 : 493 });
+      } catch (error) {
+        if (!isAlreadyExists(error)) throw error;
+      }
+      if (await inspectPath(current) !== "directory") {
+        throw new Error(`Could not safely create directory: ${current}`);
+      }
+    }
+  }
+}
+async function createIfMissing(projectRoot, relativePath, contents) {
+  const absolutePath = resolve(projectRoot, relativePath);
+  const parent = relative(projectRoot, absolutePath).split(/[/\\]/).slice(0, -1).join("/");
+  if (parent) await ensureDirectory(projectRoot, parent);
+  try {
+    await writeFile(absolutePath, contents, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 420
+    });
+    return "created";
+  } catch (error) {
+    if (isAlreadyExists(error)) return "skipped";
+    throw error;
+  }
+}
+function wrapManagedSection(body) {
+  return `${managedStart}
+${body}
+${managedEnd}`;
+}
+function mergeManagedSection(existing, body) {
+  const section = wrapManagedSection(body);
+  const start = existing.indexOf(managedStart);
+  const end = existing.indexOf(managedEnd);
+  if (start === -1 && end === -1) {
+    const separator = existing.length === 0 ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+    return `${existing}${separator}${section}
+`;
+  }
+  if (start === -1 || end === -1 || end < start || existing.indexOf(managedStart, start + managedStart.length) !== -1 || existing.indexOf(managedEnd, end + managedEnd.length) !== -1) {
+    throw new Error("File has malformed Vaka instruction markers; refusing to modify it.");
+  }
+  const managedEndIndex = end + managedEnd.length;
+  return `${existing.slice(0, start)}${section}${existing.slice(managedEndIndex)}`;
+}
+async function mergeIntoFile(projectRoot, relativePath, sectionBody) {
+  const absolutePath = resolve(projectRoot, relativePath);
+  const parent = relative(projectRoot, absolutePath).split(/[/\\]/).slice(0, -1).join("/");
+  if (parent) await ensureDirectory(projectRoot, parent);
+  const pathType = await inspectPath(absolutePath);
+  if (pathType === void 0) {
+    try {
+      await writeFile(absolutePath, `${wrapManagedSection(sectionBody)}
+`, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 420
+      });
+      return "created";
+    } catch (error) {
+      if (!isAlreadyExists(error)) throw error;
+    }
+  } else if (pathType !== "file") {
+    throw new Error(`Expected a regular file, found a directory: ${absolutePath}`);
+  }
+  const stat = await lstat(absolutePath);
+  if (!stat.isFile() || stat.isSymbolicLink()) {
+    throw new Error(`Expected a regular file: ${absolutePath}`);
+  }
+  const existing = await readFile(absolutePath, "utf8");
+  const updated = mergeManagedSection(existing, sectionBody);
+  if (updated === existing) return "skipped";
+  const temporaryPath = join(
+    dirname(absolutePath),
+    `.${basename(absolutePath)}.${crypto.randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(temporaryPath, updated, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: stat.mode & 511
+    });
+    await rename(temporaryPath, absolutePath);
+  } catch (error) {
+    try {
+      await unlink(temporaryPath);
+    } catch (cleanupError) {
+      if (!isMissing(cleanupError)) {
+        throw new AggregateError(
+          [error, cleanupError],
+          `Could not update ${absolutePath} or clean up ${temporaryPath}.`
+        );
+      }
+    }
+    throw error;
+  }
+  return "updated";
+}
+async function resolveWindsurfTarget(projectRoot) {
+  const directory = await inspectPath(join(projectRoot, ".windsurf"));
+  if (directory === "directory") {
+    return { mode: "own-file", relativePath: ".windsurf/rules/vaka.md" };
+  }
+  return { mode: "merge", relativePath: ".windsurfrules" };
+}
+async function resolveClineTarget(projectRoot) {
+  const existing = await inspectPath(join(projectRoot, ".clinerules"));
+  if (existing === "directory") {
+    return { mode: "own-file", relativePath: ".clinerules/vaka.md" };
+  }
+  return { mode: "merge", relativePath: ".clinerules" };
+}
+async function initializeProject(projectPath) {
+  const projectRoot = resolve(projectPath);
+  if (await inspectPath(projectRoot) !== "directory") {
+    throw new Error(`Project path is not a directory: ${projectRoot}`);
+  }
+  const integrations = await detectIntegrations(projectRoot);
+  const result = { integrations, created: [], updated: [], skipped: [] };
+  const ownFiles = [
+    { relativePath: ".vaka/rules.yml", contents: rules }
+  ];
+  if (integrations.includes("claude")) {
+    ownFiles.push({ relativePath: "CLAUDE.md", contents: instructions.claude });
+  }
+  if (integrations.includes("cursor")) {
+    ownFiles.push({ relativePath: ".cursor/rules/vaka.mdc", contents: instructions.cursor });
+  }
+  if (integrations.includes("copilot")) {
+    ownFiles.push({
+      relativePath: ".github/copilot-instructions.md",
+      contents: instructions.copilot
+    });
+  }
+  for (const file of ownFiles) {
+    const status = await createIfMissing(projectRoot, file.relativePath, file.contents);
+    result[status].push(file.relativePath);
+  }
+  if (integrations.includes("codex")) {
+    const status = await mergeIntoFile(projectRoot, "AGENTS.md", instructions.codex);
+    result[status].push("AGENTS.md");
+  }
+  if (integrations.includes("windsurf")) {
+    const target = await resolveWindsurfTarget(projectRoot);
+    const status = target.mode === "own-file" ? await createIfMissing(projectRoot, target.relativePath, instructions.windsurfOwnFile) : await mergeIntoFile(projectRoot, target.relativePath, instructions.windsurfMerge);
+    result[status].push(target.relativePath);
+  }
+  if (integrations.includes("cline")) {
+    const target = await resolveClineTarget(projectRoot);
+    const status = target.mode === "own-file" ? await createIfMissing(projectRoot, target.relativePath, instructions.clineOwnFile) : await mergeIntoFile(projectRoot, target.relativePath, instructions.clineMerge);
+    result[status].push(target.relativePath);
+  }
+  return result;
+}
+
+// src/commands/line-prompter.ts
+import { createInterface } from "readline";
+
+// ../../packages/core/dist/session.js
+import { createHash, randomUUID } from "crypto";
+import { lstat as lstat2, mkdir as mkdir2, readFile as readFile2, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2, resolve as resolve2 } from "path";
+function canonicalize(value, ancestors) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new TypeError("Session payload numbers must be finite.");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    if (ancestors.has(value))
+      throw new TypeError("Session payload cannot contain cycles.");
+    ancestors.add(value);
+    const serialized = `[${value.map((item) => canonicalize(item, ancestors)).join(",")}]`;
+    ancestors.delete(value);
+    return serialized;
+  }
+  if (typeof value === "object") {
+    const object = value;
+    const prototype = Object.getPrototypeOf(object);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("Session payload must contain only plain JSON objects.");
+    }
+    if (ancestors.has(object))
+      throw new TypeError("Session payload cannot contain cycles.");
+    ancestors.add(object);
+    const serialized = `{${Object.keys(object).sort().map((key) => {
+      const item = object[key];
+      if (item === void 0) {
+        throw new TypeError("Session payload cannot contain undefined values.");
+      }
+      return `${JSON.stringify(key)}:${canonicalize(item, ancestors)}`;
+    }).join(",")}}`;
+    ancestors.delete(object);
+    return serialized;
+  }
+  throw new TypeError("Session payload must be valid JSON.");
+}
+function canonicalJson(value) {
+  return canonicalize(value, /* @__PURE__ */ new WeakSet());
+}
+function isCheckpointName(value) {
+  return value === "build" || value === "design" || value === "implementation";
+}
+function isEventActor(value) {
+  return value === "developer" || value === "assistant";
+}
+function isEventType(value) {
+  return value === "checkpoint-question" || value === "checkpoint-answer" || value === "design-confirmed" || value === "implementation-approved";
+}
+function hasExactKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function hashEvent(sessionId, event) {
+  const content = canonicalJson({
+    sessionId,
+    sequence: event.sequence,
+    checkpoint: event.checkpoint,
+    actor: event.actor,
+    type: event.type,
+    payload: event.payload,
+    recordedAt: event.recordedAt,
+    previousHash: event.previousHash
+  });
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function createLocalSession(options = {}) {
+  return {
+    schemaVersion: 1,
+    id: options.id ?? randomUUID(),
+    provenance: "local",
+    status: "unverified",
+    createdAt: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    events: []
+  };
+}
+function verifySessionIntegrity(session) {
+  if (typeof session !== "object" || session === null) {
+    return { valid: false, reason: "Session must be an object." };
+  }
+  const candidate = session;
+  if (!hasExactKeys(candidate, [
+    "schemaVersion",
+    "id",
+    "provenance",
+    "status",
+    "createdAt",
+    "events"
+  ]) || candidate.schemaVersion !== 1 || typeof candidate.id !== "string" || candidate.id.length === 0 || candidate.provenance !== "local" || candidate.status !== "unverified" || typeof candidate.createdAt !== "string" || Number.isNaN(Date.parse(candidate.createdAt)) || !Array.isArray(candidate.events)) {
+    return { valid: false, reason: "Session metadata is invalid or has an unsupported version." };
+  }
+  let previousHash = null;
+  let previousRecordedAt = candidate.createdAt;
+  for (let index = 0; index < candidate.events.length; index += 1) {
+    const event = candidate.events[index];
+    if (typeof event !== "object" || event === null || !hasExactKeys(event, [
+      "sequence",
+      "checkpoint",
+      "actor",
+      "type",
+      "payload",
+      "recordedAt",
+      "previousHash",
+      "hash"
+    ]) || event.sequence !== index || !isCheckpointName(event.checkpoint) || !isEventActor(event.actor) || !isEventType(event.type) || typeof event.recordedAt !== "string" || Number.isNaN(Date.parse(event.recordedAt)) || event.previousHash !== previousHash || typeof event.hash !== "string" || !/^[a-f0-9]{64}$/.test(event.hash)) {
+      return { valid: false, eventIndex: index, reason: "Event shape or sequence is invalid." };
+    }
+    if (Date.parse(event.recordedAt) < Date.parse(previousRecordedAt)) {
+      return {
+        valid: false,
+        eventIndex: index,
+        reason: "Event timestamp is earlier than a prior event or the session's creation time."
+      };
+    }
+    try {
+      const { hash, ...eventWithoutHash } = event;
+      if (hashEvent(candidate.id, eventWithoutHash) !== hash) {
+        return { valid: false, eventIndex: index, reason: "Event hash does not match its contents." };
+      }
+    } catch (error) {
+      return {
+        valid: false,
+        eventIndex: index,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+    previousRecordedAt = event.recordedAt;
+    previousHash = event.hash;
+  }
+  return { valid: true };
+}
+function appendSessionEvent(session, input, recordedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const integrity = verifySessionIntegrity(session);
+  if (!integrity.valid) {
+    throw new Error(`Cannot append to an invalid local session${integrity.eventIndex === void 0 ? "" : ` at event ${integrity.eventIndex}`}: ${integrity.reason}`);
+  }
+  if (!isCheckpointName(input.checkpoint) || !isEventActor(input.actor) || !isEventType(input.type)) {
+    throw new TypeError("Session event has an unsupported checkpoint, actor, or type.");
+  }
+  if (Number.isNaN(Date.parse(recordedAt))) {
+    throw new TypeError("Session event timestamp must be a valid date.");
+  }
+  const previousRecordedAt = session.events.at(-1)?.recordedAt ?? session.createdAt;
+  if (Date.parse(recordedAt) < Date.parse(previousRecordedAt)) {
+    throw new RangeError("Session event timestamp cannot be earlier than the previous event or the session's creation time.");
+  }
+  const previousHash = session.events.at(-1)?.hash ?? null;
+  const eventWithoutHash = {
+    sequence: session.events.length,
+    checkpoint: input.checkpoint,
+    actor: input.actor,
+    type: input.type,
+    payload: input.payload,
+    recordedAt,
+    previousHash
+  };
+  const event = {
+    ...eventWithoutHash,
+    hash: hashEvent(session.id, eventWithoutHash)
+  };
+  return { ...session, events: [...session.events, event] };
+}
+function isMissing2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function ensureStateDirectory(projectRoot) {
+  const root = resolve2(projectRoot);
+  const rootStat = await lstat2(root);
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+    throw new Error(`Project path is not a safe directory: ${root}`);
+  }
+  const stateDirectory = join2(root, ".vaka");
+  try {
+    const stateStat = await lstat2(stateDirectory);
+    if (!stateStat.isDirectory() || stateStat.isSymbolicLink()) {
+      throw new Error(`Vaka state path must be a real directory: ${stateDirectory}`);
+    }
+  } catch (error) {
+    if (!isMissing2(error))
+      throw error;
+    try {
+      await mkdir2(stateDirectory, { mode: 448 });
+    } catch (createError) {
+      if (!(typeof createError === "object" && createError !== null && "code" in createError && createError.code === "EEXIST")) {
+        throw createError;
+      }
+    }
+    const stateStat = await lstat2(stateDirectory);
+    if (!stateStat.isDirectory() || stateStat.isSymbolicLink()) {
+      throw new Error(`Vaka state path must be a real directory: ${stateDirectory}`);
+    }
+  }
+  return stateDirectory;
+}
+async function inspectStateDirectory(projectRoot) {
+  const root = resolve2(projectRoot);
+  const rootStat = await lstat2(root);
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+    throw new Error(`Project path is not a safe directory: ${root}`);
+  }
+  const stateDirectory = join2(root, ".vaka");
+  const stateStat = await lstat2(stateDirectory);
+  if (!stateStat.isDirectory() || stateStat.isSymbolicLink()) {
+    throw new Error(`Vaka state path must be a real directory: ${stateDirectory}`);
+  }
+  return stateDirectory;
+}
+async function saveLocalSession(projectRoot, session) {
+  const integrity = verifySessionIntegrity(session);
+  if (!integrity.valid) {
+    throw new Error(`Refusing to save an invalid local session: ${integrity.reason}`);
+  }
+  const stateDirectory = await ensureStateDirectory(projectRoot);
+  const sessionPath = join2(stateDirectory, "session.json");
+  try {
+    const existing = await lstat2(sessionPath);
+    if (existing.isSymbolicLink() || !existing.isFile()) {
+      throw new Error(`Session path must be a regular file: ${sessionPath}`);
+    }
+  } catch (error) {
+    if (!isMissing2(error))
+      throw error;
+  }
+  const temporaryPath = join2(stateDirectory, `session.${randomUUID()}.tmp`);
+  try {
+    await writeFile2(temporaryPath, `${JSON.stringify(session, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    await rename2(temporaryPath, sessionPath);
+  } catch (error) {
+    try {
+      await unlink2(temporaryPath);
+    } catch (cleanupError) {
+      if (!isMissing2(cleanupError)) {
+        throw new AggregateError([error, cleanupError], `Could not save the session or clean up ${temporaryPath}.`);
+      }
+    }
+    throw error;
+  }
+}
+async function loadLocalSession(projectRoot) {
+  const stateDirectory = await inspectStateDirectory(projectRoot);
+  const sessionPath = join2(stateDirectory, "session.json");
+  const stat = await lstat2(sessionPath);
+  if (!stat.isFile() || stat.isSymbolicLink()) {
+    throw new Error(`Session path must be a regular file: ${sessionPath}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile2(sessionPath, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Session JSON is invalid: ${sessionPath}`, { cause: error });
+    }
+    throw error;
+  }
+  const integrity = verifySessionIntegrity(parsed);
+  if (!integrity.valid) {
+    throw new Error(`Local session integrity check failed: ${integrity.reason}`);
+  }
+  return parsed;
+}
+async function tryLoadLocalSession(projectRoot) {
+  try {
+    return await loadLocalSession(projectRoot);
+  } catch (error) {
+    if (isMissing2(error))
+      return void 0;
+    throw error;
+  }
+}
+async function loadOrCreateLocalSession(projectRoot) {
+  return await tryLoadLocalSession(projectRoot) ?? createLocalSession();
+}
+
+// ../../packages/core/dist/checkpoints.js
+var CHECKPOINT_QUESTIONS = [
+  {
+    id: "build-goal",
+    checkpoint: "build",
+    prompt: "What is the goal of this feature, in one or two sentences?"
+  },
+  {
+    id: "build-flow",
+    checkpoint: "build",
+    prompt: "What are the system boundaries and state transitions \u2014 what talks to what, and where does this sit in the flow?"
+  },
+  {
+    id: "build-data",
+    checkpoint: "build",
+    prompt: "What data does this touch, and why these structures, relations, and indexes?"
+  },
+  {
+    id: "design-edge-cases",
+    checkpoint: "design",
+    prompt: "What edge cases could break this \u2014 concurrency, idempotency, timeouts, or network failure \u2014 and how are they handled?"
+  }
+];
+var DEFAULT_RULES = {
+  checkpoints: {
+    build: { required: true },
+    design: { required: true },
+    implementation: { required: true }
+  }
+};
+var CHECKPOINT_ORDER = ["build", "design", "implementation"];
+function questionsFor(checkpoint) {
+  return CHECKPOINT_QUESTIONS.filter((question) => question.checkpoint === checkpoint);
+}
+function lastIndexOfType(events, type) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    if (events[index]?.type === type)
+      return index;
+  }
+  return -1;
+}
+function answeredQuestionIds(cycle, checkpoint) {
+  const answered = /* @__PURE__ */ new Set();
+  for (const event of cycle) {
+    if (event.checkpoint !== checkpoint || event.type !== "checkpoint-answer")
+      continue;
+    const payload = event.payload;
+    if (typeof payload === "object" && payload !== null && !Array.isArray(payload)) {
+      const questionId = payload.questionId;
+      if (typeof questionId === "string")
+        answered.add(questionId);
+    }
+  }
+  return answered;
+}
+function currentCycleEvents(events) {
+  const lastApprovalIndex = lastIndexOfType(events, "implementation-approved");
+  return events.slice(lastApprovalIndex + 1);
+}
+function resolveResumeState(events, rules2) {
+  const cycle = currentCycleEvents(events);
+  for (const checkpoint of CHECKPOINT_ORDER) {
+    if (!rules2.checkpoints[checkpoint].required)
+      continue;
+    const answered = answeredQuestionIds(cycle, checkpoint);
+    const nextQuestion = questionsFor(checkpoint).find((question) => !answered.has(question.id));
+    if (nextQuestion) {
+      return { kind: "ask-question", question: nextQuestion };
+    }
+    if (checkpoint === "design" && lastIndexOfType(cycle, "design-confirmed") === -1) {
+      return { kind: "confirm-design" };
+    }
+    if (checkpoint === "implementation" && lastIndexOfType(cycle, "implementation-approved") === -1) {
+      return { kind: "authorize-implementation" };
+    }
+  }
+  return { kind: "cycle-complete" };
+}
+
+// ../../packages/core/dist/rules.js
+import { lstat as lstat3, readFile as readFile3 } from "fs/promises";
+import { join as join3, resolve as resolve3 } from "path";
+import { parse as parseYaml } from "yaml";
+var CHECKPOINT_NAMES = ["build", "design", "implementation"];
+function isMissing3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function parseRulesDocument(path, text2) {
+  let parsed;
+  try {
+    parsed = parseYaml(text2);
+  } catch (error) {
+    throw new Error(`Could not parse ${path} as YAML.`, { cause: error });
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${path} must contain a YAML mapping at the top level.`);
+  }
+  const document = parsed;
+  const checkpointsField = document.checkpoints;
+  if (typeof checkpointsField !== "object" || checkpointsField === null || Array.isArray(checkpointsField)) {
+    throw new Error(`${path} is missing a valid top-level "checkpoints" mapping.`);
+  }
+  const checkpointsDocument = checkpointsField;
+  const checkpoints = {};
+  for (const name of CHECKPOINT_NAMES) {
+    const entry = checkpointsDocument[name];
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry) || typeof entry.required !== "boolean") {
+      throw new Error(`${path} is missing a boolean "checkpoints.${name}.required" value.`);
+    }
+    checkpoints[name] = { required: entry.required };
+  }
+  return { checkpoints };
+}
+async function loadRulesConfig(projectRoot) {
+  const root = resolve3(projectRoot);
+  const rulesPath = join3(root, ".vaka", "rules.yml");
+  let stat;
+  try {
+    stat = await lstat3(rulesPath);
+  } catch (error) {
+    if (isMissing3(error))
+      return DEFAULT_RULES;
+    throw error;
+  }
+  if (!stat.isFile() || stat.isSymbolicLink()) {
+    throw new Error(`Vaka rules path must be a regular file: ${rulesPath}`);
+  }
+  const text2 = await readFile3(rulesPath, "utf8");
+  return parseRulesDocument(rulesPath, text2);
+}
+
+// src/commands/start.ts
+var CANCELLED = Symbol("cancelled");
+async function runStart(projectRoot, prompter) {
+  const rules2 = await loadRulesConfig(projectRoot);
+  let session = await loadOrCreateLocalSession(projectRoot);
+  for (; ; ) {
+    const state = resolveResumeState(session.events, rules2);
+    if (state.kind === "cycle-complete") {
+      return { kind: "nothing-required" };
+    }
+    if (state.kind === "ask-question") {
+      session = appendSessionEvent(session, {
+        checkpoint: state.question.checkpoint,
+        actor: "assistant",
+        type: "checkpoint-question",
+        payload: { questionId: state.question.id, prompt: state.question.prompt }
+      });
+      await saveLocalSession(projectRoot, session);
+      const answer = await prompter.askQuestion(state.question);
+      if (answer === CANCELLED) return { kind: "cancelled" };
+      session = appendSessionEvent(session, {
+        checkpoint: state.question.checkpoint,
+        actor: "developer",
+        type: "checkpoint-answer",
+        payload: { questionId: state.question.id, answer }
+      });
+      await saveLocalSession(projectRoot, session);
+      continue;
+    }
+    if (state.kind === "confirm-design") {
+      const confirmed = await prompter.askConfirm(
+        "Does this design look right to proceed with?"
+      );
+      if (confirmed === CANCELLED) return { kind: "cancelled" };
+      if (!confirmed) return { kind: "design-declined" };
+      session = appendSessionEvent(session, {
+        checkpoint: "design",
+        actor: "developer",
+        type: "design-confirmed",
+        payload: {}
+      });
+      await saveLocalSession(projectRoot, session);
+      continue;
+    }
+    const approved = await prompter.askConfirm(
+      "Authorize implementation of exactly this scoped change?"
+    );
+    if (approved === CANCELLED) return { kind: "cancelled" };
+    if (!approved) return { kind: "implementation-declined" };
+    session = appendSessionEvent(session, {
+      checkpoint: "implementation",
+      actor: "developer",
+      type: "implementation-approved",
+      payload: {}
+    });
+    await saveLocalSession(projectRoot, session);
+    return { kind: "implementation-approved" };
+  }
+}
+
+// src/commands/line-prompter.ts
+function createLineReaderPrompter(input = process.stdin, output = process.stdout) {
+  const rl = createInterface({ input, terminal: false });
+  const lines = rl[Symbol.asyncIterator]();
+  async function nextLine() {
+    const { value, done } = await lines.next();
+    return done ? void 0 : value;
+  }
+  return {
+    async askQuestion(question) {
+      output.write(`${question.prompt}
+> `);
+      const line = await nextLine();
+      if (line === void 0) return CANCELLED;
+      const answer = line.trim();
+      if (answer.length === 0) {
+        throw new Error(`Expected a non-empty answer for: ${question.prompt}`);
+      }
+      return answer;
+    },
+    async askConfirm(message) {
+      output.write(`${message} (y/n)
+> `);
+      const line = await nextLine();
+      if (line === void 0) return CANCELLED;
+      const normalized = line.trim().toLowerCase();
+      if (normalized === "y" || normalized === "yes") return true;
+      if (normalized === "n" || normalized === "no") return false;
+      throw new Error(`Expected "y" or "n" for: ${message} (got ${JSON.stringify(line)})`);
+    },
+    close() {
+      rl.close();
+    }
+  };
+}
+
+// src/commands/status.ts
+async function runStatus(projectRoot) {
+  const rules2 = await loadRulesConfig(projectRoot);
+  const session = await tryLoadLocalSession(projectRoot);
+  const events = session?.events ?? [];
+  return {
+    sessionExists: session !== void 0,
+    totalEvents: events.length,
+    completedCycles: events.filter((event) => event.type === "implementation-approved").length,
+    resumeState: resolveResumeState(events, rules2)
+  };
+}
+
+// src/ui/banner.ts
+import readline from "readline";
+
+// src/ui/terminal-theme.ts
+function detectTerminalTheme(env = process.env) {
+  const override = env.VAKA_THEME?.toLowerCase();
+  if (override === "light" || override === "dark") {
+    return override;
+  }
+  const colorFgBg = env.COLORFGBG;
+  if (colorFgBg) {
+    const bg = Number.parseInt(colorFgBg.split(";").pop() ?? "", 10);
+    if (!Number.isNaN(bg)) {
+      return bg === 7 || bg >= 9 ? "light" : "dark";
+    }
+  }
+  return "dark";
+}
+function supportsColor(stream = process.stdout, env = process.env) {
+  if (env.NO_COLOR !== void 0) {
+    return false;
+  }
+  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0") {
+    return true;
+  }
+  if (!stream.isTTY) {
+    return false;
+  }
+  return env.TERM !== "dumb";
+}
+
+// src/ui/banner.ts
+var BOLD = "\x1B[1m";
+var RESET = "\x1B[0m";
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+function rgb(hex) {
+  const r = Number.parseInt(hex.slice(1, 3), 16);
+  const g = Number.parseInt(hex.slice(3, 5), 16);
+  const b = Number.parseInt(hex.slice(5, 7), 16);
+  return `\x1B[38;2;${r};${g};${b}m`;
+}
+function stripAnsi(input) {
+  return input.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "");
+}
+var PALETTES = {
+  dark: {
+    border: rgb("#2C303D"),
+    // --ink-border
+    text: rgb("#F3F4F7"),
+    // --ink-text
+    muted: rgb("#9AA1B2"),
+    // --ink-muted (the dark-canvas muted token, not --muted-foreground)
+    ring: rgb("#9DB0E8"),
+    // --accent-light ("numerals on dark")
+    core: rgb("#2E478C")
+    // --primary
+  },
+  light: {
+    border: rgb("#E5E6EB"),
+    // --border
+    text: rgb("#1B1D26"),
+    // --foreground
+    muted: rgb("#70747F"),
+    // --muted-foreground
+    ring: rgb("#8E9AC2"),
+    // --secondary-indigo (the light-canvas pair for --accent-light)
+    core: rgb("#2E478C")
+    // --primary
+  }
+};
+var SEED_FRAMES = [
+  // Frame 0: The Origin (Point of Intention)
+  [
+    `                       \xB7                       `,
+    `                                               `,
+    `                       \u25CF                       `,
+    `                                               `,
+    `                       \xB7                       `
+  ],
+  // Frame 1: The Central Sphere (First Circle of Reasoning)
+  [
+    `                    . \u2500\u2500\u2500 .                    `,
+    `                  /         \\                  `,
+    `                 |     \u25C8     |                 `,
+    `                  \\         /                  `,
+    `                    ' \u2500\u2500\u2500 '                    `
+  ],
+  // Frame 2: The Vertical Polar Axis
+  [
+    `                    . \u2500\u2500\u2500 .                    `,
+    `                 \u256D\u2500/\u2500\u2500\u2500\u252C\u2500\u2500\u2500\\\u2500\u256E                 `,
+    `                 \u2502\u2502    \u2502    \u2502\u2502                 `,
+    `                 \u2570\u2500\\\u2500\u2500\u2500\u2534\u2500\u2500\u2500/\u2500\u256F                 `,
+    `                    ' \u2500\u2500\u2500 '                    `
+  ],
+  // Frame 3: Triad Intersection (State, Schema, Edge Checkpoints)
+  [
+    `                    . \u2500\u2500\u2500 .                    `,
+    `                 \u256D\u2500/\u2500\u2500\u2500\u252C\u2500\u2500\u2500\\\u2500\u256E                 `,
+    `                ( (  \u25F8 \u253C \u25F9  ) )                `,
+    `                 \u2570\u2500\\\u2500\u2500\u2500\u2534\u2500\u2500\u2500/\u2500\u256F                 `,
+    `                    ' \u2500\u2500\u2500 '                    `
+  ],
+  // Frame 4: Hexagonal Petals Emerge
+  [
+    `                  .\u2500\u2500.   .\u2500\u2500.                  `,
+    `                /  \u256D\u2500\u2500\\ /\u2500\u2500\u256E  \\                `,
+    `               |  ( \u25F8  \u2715  \u25F9 )  |               `,
+    `                \\  \u2570\u2500\u2500/ \\\u2500\u2500\u256F  /                `,
+    `                  '\u2500\u2500'   '\u2500\u2500'                  `
+  ],
+  // Frame 5: Fully Assembled Seed of Life
+  [
+    `                 .\u2500\u2500.  \u25B2  .\u2500\u2500.                 `,
+    `               \u256D\u2500( \u25F8 \u2572 \u2502 / \u25F9 )\u2500\u256E               `,
+    `               \u2502  \u2572\u2500\u2500\u2500 \u25C8 \u2500\u2500\u2500\u2571  \u2502               `,
+    `               \u2570\u2500( \u25FA \u2571 \u2502 \\ \u25FF )\u2500\u256F               `,
+    `                 '\u2500\u2500'  \u25BC  '\u2500\u2500'                 `
+  ],
+  // Frame 6: Harmonic Pulse Lock
+  [
+    `                 .\u2500\u2500.  \u2726  .\u2500\u2500.                 `,
+    `               \u256D\u2500( \u25F8 \u2572 \u2502 / \u25F9 )\u2500\u256E               `,
+    `               \u2502  \u2572\u2500\u2500\u2500 \u25C8 \u2500\u2500\u2500\u2571  \u2502               `,
+    `               \u2570\u2500( \u25FA \u2571 \u2502 \\ \u25FF )\u2500\u256F               `,
+    `                 '\u2500\u2500'  \u2726  '\u2500\u2500'                 `
+  ]
+];
+var FINAL_FRAME = SEED_FRAMES.length - 1;
+function center(text2, width) {
+  const totalPad = Math.max(width - text2.length, 0);
+  const left = Math.floor(totalPad / 2);
+  return " ".repeat(left) + text2 + " ".repeat(totalPad - left);
+}
+function padEndSafe(text2, width) {
+  return text2.length >= width ? text2 : text2 + " ".repeat(width - text2.length);
+}
+function buildVakaCard(frameIndex, isPulsing, theme, colorEnabled, version) {
+  const palette = PALETTES[theme];
+  const glyph = SEED_FRAMES[frameIndex] ?? SEED_FRAMES[FINAL_FRAME];
+  const ringColor = isPulsing ? palette.text : palette.ring;
+  const coreColor = isPulsing ? palette.ring : palette.core;
+  const title = "YOUR MIND IS THE ARCHITECT";
+  const subtitle = "Architecture checkpoints for engineers.";
+  const footer = `v${version} \xB7 Local checkpoints: unverified`;
+  const innerWidth = Math.max(
+    ...glyph.map((line) => line.length),
+    title.length,
+    subtitle.length,
+    footer.length
+  );
+  const colorWrap = (code, text2, bold = false) => colorEnabled ? `${bold ? BOLD : ""}${code}${text2}${RESET}` : text2;
+  const border = (char) => colorWrap(palette.border, char);
+  const contentRow = (text2) => `${border("\u2502")} ${text2} ${border("\u2502")}`;
+  const glyphRow = (line, color) => contentRow(colorWrap(color, padEndSafe(line, innerWidth)));
+  const lines = [
+    `${border("\u250C")}${border("\u2500".repeat(innerWidth + 2))}${border("\u2510")}`,
+    contentRow(" ".repeat(innerWidth)),
+    glyphRow(glyph[0], ringColor),
+    glyphRow(glyph[1], ringColor),
+    glyphRow(glyph[2], coreColor),
+    glyphRow(glyph[3], ringColor),
+    glyphRow(glyph[4], ringColor),
+    contentRow(" ".repeat(innerWidth)),
+    contentRow(colorWrap(palette.text, center(title, innerWidth), true)),
+    contentRow(colorWrap(palette.muted, center(subtitle, innerWidth))),
+    contentRow(" ".repeat(innerWidth)),
+    contentRow(colorWrap(palette.muted, center(footer, innerWidth))),
+    `${border("\u2514")}${border("\u2500".repeat(innerWidth + 2))}${border("\u2518")}`
+  ];
+  return lines.join("\n");
+}
+function buildMinimalBanner(version) {
+  return `Vaka v${version} \u2014 Your mind is the architect.`;
+}
+async function animateVakaEntrance(options = {}) {
+  const stdout = options.stdout ?? process.stdout;
+  const env = options.env ?? process.env;
+  const version = options.version ?? "0.1.0";
+  const theme = detectTerminalTheme(env);
+  const colorEnabled = supportsColor(stdout, env);
+  const interactive = stdout.isTTY === true;
+  const finalCard = buildVakaCard(FINAL_FRAME, false, theme, colorEnabled, version);
+  const cardWidth = Math.max(...finalCard.split("\n").map((line) => stripAnsi(line).length));
+  const columns = stdout.columns ?? cardWidth;
+  if (!interactive) {
+    stdout.write(`${finalCard}
+`);
+    return;
+  }
+  if (columns < cardWidth) {
+    stdout.write(`${buildMinimalBanner(version)}
+`);
+    return;
+  }
+  stdout.write(HIDE_CURSOR);
+  readline.cursorTo(stdout, 0, 0);
+  readline.clearScreenDown(stdout);
+  for (let i = 0; i < SEED_FRAMES.length; i++) {
+    readline.cursorTo(stdout, 0, 0);
+    stdout.write(`${buildVakaCard(i, false, theme, colorEnabled, version)}
+`);
+    await new Promise((resolve4) => setTimeout(resolve4, 85));
+  }
+  const pulseRhythm = [true, false, true, false];
+  for (const pulse of pulseRhythm) {
+    readline.cursorTo(stdout, 0, 0);
+    stdout.write(`${buildVakaCard(FINAL_FRAME, pulse, theme, colorEnabled, version)}
+`);
+    await new Promise((resolve4) => setTimeout(resolve4, pulse ? 130 : 90));
+  }
+  stdout.write(SHOW_CURSOR);
+}
+
+// src/update-check.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+var REGISTRY_DIST_TAGS_URL = "https://registry.npmjs.org/-/package/";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 1500;
+function defaultCachePath() {
+  return join4(homedir(), ".vaka", "update-check.json");
+}
+function readCache(cachePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+    if (typeof parsed.lastChecked === "number" && typeof parsed.latestVersion === "string") {
+      return { lastChecked: parsed.lastChecked, latestVersion: parsed.latestVersion };
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeCache(cachePath, cache) {
+  try {
+    mkdirSync(dirname2(cachePath), { recursive: true });
+    writeFileSync(cachePath, JSON.stringify(cache), "utf8");
+  } catch {
+  }
+}
+function compareVersions(a, b) {
+  const toParts = (version) => (version.split(/[-+]/)[0] ?? "").split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const partsA = toParts(a);
+  const partsB = toParts(b);
+  const length = Math.max(partsA.length, partsB.length);
+  for (let i = 0; i < length; i++) {
+    const diff = (partsA[i] ?? 0) - (partsB[i] ?? 0);
+    if (diff !== 0) {
+      return diff > 0 ? 1 : -1;
+    }
+  }
+  return 0;
+}
+async function fetchLatestVersion(packageName, fetchImpl) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetchImpl(`${REGISTRY_DIST_TAGS_URL}${encodeURIComponent(packageName)}/dist-tags`, {
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const tags = await response.json();
+    return typeof tags.latest === "string" ? tags.latest : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function checkForUpdates(currentVersion, packageName, options = {}) {
+  const cachePath = options.cachePath ?? defaultCachePath();
+  const now = options.now ?? Date.now;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const cache = readCache(cachePath);
+  const isStale = !cache || now() - cache.lastChecked > CACHE_TTL_MS;
+  if (isStale) {
+    void fetchLatestVersion(packageName, fetchImpl).then((latestVersion) => {
+      if (latestVersion) {
+        writeCache(cachePath, { lastChecked: now(), latestVersion });
+      }
+    });
+  }
+  if (cache && compareVersions(cache.latestVersion, currentVersion) > 0) {
+    return { currentVersion, latestVersion: cache.latestVersion };
+  }
+  return void 0;
+}
+function formatUpdateNotice(notice, packageName) {
+  const line1 = `Update available: ${notice.currentVersion} \u2192 ${notice.latestVersion}`;
+  const line2 = `Run: npm install -g ${packageName}`;
+  const width = Math.max(line1.length, line2.length) + 2;
+  const pad = (line) => `\u2502 ${line.padEnd(width - 1)}\u2502`;
+  return [
+    `\u250C${"\u2500".repeat(width)}\u2510`,
+    pad(line1),
+    pad(line2),
+    `\u2514${"\u2500".repeat(width)}\u2518`
+  ].join("\n");
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var PACKAGE_NAME = "@vaka.world/cli";
+var clackPrompter = {
+  async askQuestion(question) {
+    const answer = await text({
+      message: question.prompt,
+      validate: (value) => value.trim().length === 0 ? "An answer is required." : void 0
+    });
+    return isCancel(answer) ? CANCELLED : answer;
+  },
+  async askConfirm(message) {
+    const answer = await confirm({ message });
+    return isCancel(answer) ? CANCELLED : answer;
+  }
+};
+function describeResumeState(state) {
+  switch (state.kind) {
+    case "ask-question":
+      return `Next: ${state.question?.prompt}`;
+    case "confirm-design":
+      return "Next: confirm the design.";
+    case "authorize-implementation":
+      return "Next: authorize implementation.";
+    case "cycle-complete":
+      return "Nothing required by .vaka/rules.yml for this cycle.";
+    default:
+      return "Unknown state.";
+  }
+}
+var program = new Command().name("vaka").description("Make the reasoning behind engineering decisions visible.").version(VERSION);
+program.command("init").description("Add Vaka rules and instructions to the current project.").action(async () => {
+  await animateVakaEntrance({ version: VERSION });
+  intro("vaka init");
+  try {
+    const result = await initializeProject(process.cwd());
+    for (const file of result.created) {
+      log.success(`Created ${file}`);
+    }
+    for (const file of result.skipped) {
+      log.warn(`Preserved existing file: ${file}`);
+    }
+    if (result.integrations.length === 0) {
+      log.info(
+        "No supported AI integration was detected. Created the Vaka project rules; add a Cursor, Claude Code, Codex, Copilot, Windsurf, or Cline marker to install its instructions."
+      );
+    } else {
+      log.info(`Detected: ${result.integrations.join(", ")}`);
+    }
+    outro("Local setup is ready. Local records are not server-verified.");
+  } catch (error) {
+    log.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+program.command("start").description(
+  "Work through the Build, Design, and Implementation checkpoints for the current cycle."
+).action(async () => {
+  intro("Vaka | Your mind is the architect.");
+  const nonInteractivePrompter = process.stdin.isTTY === true ? void 0 : createLineReaderPrompter();
+  const prompter = nonInteractivePrompter ?? clackPrompter;
+  try {
+    const outcome = await runStart(process.cwd(), prompter);
+    switch (outcome.kind) {
+      case "implementation-approved":
+        outro(
+          "Implementation authorized. Local session is unverified \u2014 this records what Vaka accepted locally, not independent proof of understanding or a server verification."
+        );
+        break;
+      case "design-declined":
+        log.warn("Design not confirmed. Revisit the edge cases above, then run `vaka start` again.");
+        outro("Stopped before design was confirmed.");
+        break;
+      case "implementation-declined":
+        log.warn("Implementation not authorized. Nothing was unlocked.");
+        outro("Stopped before implementation was authorized.");
+        break;
+      case "cancelled":
+        cancel("Stopped (input ended or was interrupted). Resume anytime with `vaka start`.");
+        break;
+      case "nothing-required":
+        outro("Nothing is required by .vaka/rules.yml for this cycle.");
+        break;
+    }
+  } catch (error) {
+    log.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  } finally {
+    nonInteractivePrompter?.close();
+  }
+});
+program.command("status").description("Show the current local/unverified checkpoint status.").action(async () => {
+  try {
+    const report = await runStatus(process.cwd());
+    log.info(report.sessionExists ? "Local session: unverified" : "No local session yet.");
+    log.info(`Recorded events: ${report.totalEvents}`);
+    log.info(`Completed cycles: ${report.completedCycles}`);
+    log.info(describeResumeState(report.resumeState));
+  } catch (error) {
+    log.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+await program.parseAsync(process.argv);
+var updateNotice = checkForUpdates(VERSION, PACKAGE_NAME);
+if (updateNotice) {
+  console.log(formatUpdateNotice(updateNotice, PACKAGE_NAME));
+}
+//# sourceMappingURL=index.js.map