@glrs-dev/cli 2.4.0 → 2.6.0

package/dist/node_modules/@glrs-dev/autopilot/dist/index.js

@@ -0,0 +1,768 @@
+import {
+  enrichPlanForFastModel,
+  isFreeformFile
+} from "./chunk-6JZQLIRP.js";
+import {
+  generateChangeset
+} from "./chunk-AWRK6S6G.js";
+import {
+  autoShip
+} from "./chunk-BLEIZHET.js";
+import {
+  MAX_ITERATIONS,
+  MAX_ITERATIONS_PER_PHASE_BY_TIER,
+  STALL_MS,
+  STALL_MS_BY_TIER,
+  STATUS_INTERVAL_MS,
+  STRUGGLE_THRESHOLD,
+  StruggleDetector,
+  TIMEOUT_MS,
+  buildConflictGraph,
+  checkKillSwitch,
+  createStatusHeartbeat,
+  createWorktree,
+  deleteCheckpoint,
+  detectSentinel,
+  formatCost,
+  formatElapsed,
+  getChangedFiles,
+  hasParallelism,
+  markPhaseCompleted,
+  mergeWorktree,
+  parseItems,
+  parsePlanState,
+  readCheckpoint,
+  recordHead,
+  resetSoft,
+  runLanes,
+  runLoopSession,
+  runRalphLoop,
+  runVerifyCommands,
+  validatePlan,
+  validateScope,
+  writeCheckpoint
+} from "./chunk-2X3CWH47.js";
+import {
+  resolveModel
+} from "./chunk-S34HOCZ4.js";
+import {
+  childLogger,
+  createAutopilotLogger
+} from "./chunk-2ZQ6SBV3.js";
+import {
+  detectSpecPhases,
+  filterUncheckedSpecPhases,
+  hasSpec,
+  parseSpecItems,
+  readSpecConstraints,
+  readSpecGoal,
+  validateMainSpec,
+  validatePhaseSpec
+} from "./chunk-GXXCEGDD.js";
+
+// src/event-stream.ts
+import * as fs from "fs";
+import * as path from "path";
+var EventStreamWriter = class {
+  fd;
+  constructor(filePath) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    this.fd = fs.openSync(filePath, "a");
+  }
+  /**
+   * Serialize `event` as a JSON line and write it synchronously.
+   * Sync write ensures the line is on disk even if the process crashes
+   * immediately after.
+   */
+  emit(event) {
+    const line = JSON.stringify(event) + "\n";
+    const buf = Buffer.from(line, "utf8");
+    fs.writeSync(this.fd, buf);
+  }
+  /**
+   * Close the underlying file descriptor. Safe to call multiple times
+   * (subsequent calls are no-ops).
+   */
+  close() {
+    try {
+      fs.closeSync(this.fd);
+    } catch {
+    }
+  }
+};
+var EventStreamReader = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  /**
+   * Read all events from the file. Returns an empty array if the file
+   * does not exist or is empty.
+   */
+  readAll() {
+    let raw;
+    try {
+      raw = fs.readFileSync(this.filePath, "utf8");
+    } catch {
+      return [];
+    }
+    return parseLines(raw);
+  }
+  /**
+   * Read events starting at `byteOffset`. Returns the parsed events and
+   * the new byte offset (= file size after reading). Useful for polling
+   * (tail mode): pass the returned `newOffset` on the next call to read
+   * only new events.
+   *
+   * Truncated or malformed last lines are skipped.
+   */
+  readFrom(byteOffset) {
+    let stat;
+    try {
+      stat = fs.statSync(this.filePath);
+    } catch {
+      return { events: [], newOffset: byteOffset };
+    }
+    const fileSize = stat.size;
+    if (fileSize <= byteOffset) {
+      return { events: [], newOffset: byteOffset };
+    }
+    const length = fileSize - byteOffset;
+    const buf = Buffer.alloc(length);
+    const fd = fs.openSync(this.filePath, "r");
+    try {
+      fs.readSync(fd, buf, 0, length, byteOffset);
+    } finally {
+      fs.closeSync(fd);
+    }
+    const raw = buf.toString("utf8");
+    const events = parseLines(raw);
+    return { events, newOffset: fileSize };
+  }
+};
+function parseLines(raw) {
+  const events = [];
+  const lines = raw.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      events.push(parsed);
+    } catch {
+    }
+  }
+  return events;
+}
+
+// src/session-runner.ts
+import { EventEmitter } from "events";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var SessionEventEmitter = class extends EventEmitter {
+  emitEvent(event) {
+    const eventName = event.type === "error" ? "session:error" : event.type;
+    this.emit(eventName, event);
+    this.emit("event", event);
+  }
+};
+var STATUS_WRITE_INTERVAL_MS = 5e3;
+var LegacyStatusBridge = class {
+  statusFilePath;
+  lastWriteMs = 0;
+  startedAt = Date.now();
+  iterationsCompleted = 0;
+  cumulativeCostUsd = 0;
+  phasesCompleted = 0;
+  phaseCount = 0;
+  lastIterationProgress = false;
+  lastIterationErrored = false;
+  constructor(cwd) {
+    this.statusFilePath = path2.join(cwd, ".agent", "autopilot-status.json");
+  }
+  /** Update internal state from an event and conditionally write the file. */
+  onEvent(event) {
+    switch (event.type) {
+      case "session:start":
+        this.startedAt = Date.now();
+        this._writeNow();
+        return;
+      case "iteration:done":
+        this.iterationsCompleted = event.iteration;
+        this.lastIterationProgress = event.madeProgress ?? false;
+        this.lastIterationErrored = false;
+        break;
+      case "cost:update":
+        this.cumulativeCostUsd = event.cumulativeCostUsd;
+        break;
+      case "phase:start":
+        this.phaseCount = event.total;
+        break;
+      case "phase:done":
+        this.phasesCompleted += 1;
+        break;
+      case "error":
+        this.lastIterationErrored = true;
+        break;
+      case "session:done":
+        if (event.cumulativeCostUsd !== void 0) {
+          this.cumulativeCostUsd = event.cumulativeCostUsd;
+        }
+        this._writeNow();
+        return;
+      default:
+        break;
+    }
+    const now = Date.now();
+    if (now - this.lastWriteMs >= STATUS_WRITE_INTERVAL_MS) {
+      this._writeNow();
+    }
+  }
+  _writeNow() {
+    const now = Date.now();
+    this.lastWriteMs = now;
+    const state = {
+      startedAt: this.startedAt,
+      iterationsCompleted: this.iterationsCompleted,
+      cumulativeCostUsd: this.cumulativeCostUsd,
+      lastIterationProgress: this.lastIterationProgress,
+      lastIterationErrored: this.lastIterationErrored,
+      phaseCount: this.phaseCount > 0 ? this.phaseCount : void 0,
+      phasesCompleted: this.phasesCompleted > 0 ? this.phasesCompleted : void 0
+    };
+    const snapshot = {
+      ...state,
+      elapsedMs: now - this.startedAt,
+      writtenAt: new Date(now).toISOString()
+    };
+    try {
+      const dir = path2.dirname(this.statusFilePath);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
+      }
+      const tmp = `${this.statusFilePath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 10)}`;
+      fs2.writeFileSync(tmp, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+      fs2.renameSync(tmp, this.statusFilePath);
+    } catch {
+    }
+  }
+};
+var SessionRunner = class {
+  /** Channel 1: in-process event emitter. Subscribe to event types or "event" for all. */
+  events;
+  opts;
+  _abortController = null;
+  _abortCount = 0;
+  constructor(opts) {
+    this.opts = opts;
+    this.events = new SessionEventEmitter();
+  }
+  /**
+   * Request graceful shutdown. First call signals the running loop session
+   * to stop at the next phase boundary (checkpoint is written). Second call
+   * force-exits via process.exit(1).
+   */
+  abort() {
+    this._abortCount++;
+    if (this._abortCount === 1) {
+      if (this._abortController) {
+        this._abortController.abort();
+      }
+    } else {
+      process.exit(1);
+    }
+  }
+  /**
+   * Run the autopilot session:
+   * 1. Emit session:start
+   * 2. If --fast, run enrichment (emitting enrich:* events)
+   * 3. Run the loop session (emitting phase:* events via loop-session.ts)
+   * 4. Emit session:done
+   *
+   * Returns a SessionResult with the final LoopResult.
+   */
+  async run() {
+    this._abortController = new AbortController();
+    this._abortCount = 0;
+    const { planPath, cwd, fast, resume, parallel, ship, maxIterationsPerPhase } = this.opts;
+    const eventStreamPath = this.opts.eventStreamPath ?? path2.join(cwd, ".agent", "autopilot-events.jsonl");
+    const _createWriter = this.opts._deps?.createWriter ?? ((fp) => new EventStreamWriter(fp));
+    const _createLogger = this.opts._deps?.createLogger;
+    const _enrichPlan = this.opts._deps?.enrichPlan;
+    const _runLoopSession = this.opts._deps?.runLoopSession;
+    const writer = _createWriter(eventStreamPath);
+    const statusBridge = new LegacyStatusBridge(cwd);
+    const emitEvent = (event) => {
+      this.events.emitEvent(event);
+      writer.emit(event);
+      statusBridge.onEvent(event);
+    };
+    let logger;
+    if (_createLogger) {
+      logger = _createLogger({ cwd });
+    } else {
+      const { createAutopilotLogger: createAutopilotLogger2 } = await import("./logger-3XLFMXLN.js");
+      const logLevel = this.opts.config?.log_level;
+      logger = createAutopilotLogger2({ cwd, level: logLevel });
+    }
+    const adapterName = this.opts.adapter?.name ?? "unknown";
+    let enrichModel = "unknown";
+    let executeModel = "unknown";
+    const cfgObj = this.opts.config;
+    const cfgModels = cfgObj?.models;
+    if (adapterName === "claude-code-cli") {
+      enrichModel = cfgModels?.enrichment ?? "claude-opus-4-7";
+      executeModel = cfgModels?.execution ?? "claude-haiku-4-5-20251001";
+    } else {
+      try {
+        const { join: join3 } = await import("path");
+        const { readFileSync: readFileSync3 } = await import("fs");
+        const configHome = process.env["XDG_CONFIG_HOME"] ?? join3(process.env["HOME"] ?? "", ".config");
+        const configPath = join3(configHome, "opencode", "opencode.json");
+        const raw = readFileSync3(configPath, "utf8");
+        const config = JSON.parse(raw);
+        const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+        for (const entry of plugins) {
+          if (Array.isArray(entry) && entry.length >= 2) {
+            const opts2 = entry[1];
+            const models = opts2?.models;
+            if (models) {
+              const deepArr = models["deep"] ?? models["prime"];
+              if (Array.isArray(deepArr) && deepArr[0]) enrichModel = deepArr[0];
+              const execArr = models["autopilot-execute"] ?? models["mid-execute"] ?? models["mid"];
+              if (Array.isArray(execArr) && execArr[0]) executeModel = execArr[0];
+            }
+          }
+        }
+        if (typeof config.model === "string" && enrichModel === "unknown") {
+          enrichModel = config.model;
+        }
+      } catch {
+      }
+    }
+    let branch = "unknown";
+    try {
+      const { execFileSync } = await import("child_process");
+      branch = execFileSync("git", ["branch", "--show-current"], { cwd, encoding: "utf8" }).trim() || "detached";
+    } catch {
+    }
+    emitEvent({
+      type: "session:start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      planPath,
+      cwd,
+      fast: fast ?? false,
+      resume: resume ?? false,
+      enrichModel,
+      executeModel,
+      adapter: adapterName,
+      branch
+    });
+    let loopResult;
+    let effectivePlanPath = planPath;
+    try {
+      if (fast && planPath) {
+        emitEvent({
+          type: "enrich:start",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          planPath,
+          fileCount: 0
+          // file count is determined inside enrichPlanForFastModel
+        });
+        try {
+          if (_enrichPlan) {
+            effectivePlanPath = await _enrichPlan(cwd, planPath, logger);
+            emitEvent({
+              type: "enrich:done",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              filesProcessed: 0
+            });
+          } else {
+            const { enrichPlanForFastModel: enrichPlanForFastModel2 } = await import("./plan-enrichment-4SQYV5FC.js");
+            effectivePlanPath = await enrichPlanForFastModel2(cwd, planPath, logger, this.events, this.opts.adapter, this.opts.enrichmentConfig, this.opts.config);
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          emitEvent({
+            type: "error",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            message: `Enrichment failed: ${message}`
+          });
+        }
+      }
+      const loopOpts = {
+        planPath: effectivePlanPath,
+        cwd,
+        fast,
+        resume,
+        parallel,
+        ship,
+        maxIterationsPerPhase,
+        logger,
+        emitter: this.events,
+        adapter: this.opts.adapter,
+        config: this.opts.config,
+        signal: this._abortController?.signal
+      };
+      if (_runLoopSession) {
+        loopResult = await _runLoopSession(loopOpts);
+      } else {
+        const { runLoopSession: runLoopSession2 } = await import("./loop-session-YLCVJGPV.js");
+        loopResult = await runLoopSession2(loopOpts);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      emitEvent({
+        type: "error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message
+      });
+      loopResult = {
+        exitReason: "error",
+        iterations: 0,
+        message
+      };
+    } finally {
+      if (logger) {
+        await logger.flush().catch(() => {
+        });
+      }
+    }
+    emitEvent({
+      type: "session:done",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      exitReason: loopResult.exitReason,
+      iterations: loopResult.iterations,
+      cumulativeCostUsd: loopResult.cumulativeCostUsd,
+      message: loopResult.message
+    });
+    writer.close();
+    return { planPath, loopResult };
+  }
+};
+
+// src/config-reader.ts
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  const cloned = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
+}
+function applyCLIOverrides(config, flags) {
+  const result = deepClone(config);
+  if (!result.models || typeof result.models !== "object") {
+    result.models = {};
+  }
+  const models = result.models;
+  if (flags.adapter !== void 0) {
+    result.adapter = flags.adapter;
+  }
+  if (flags.fast) {
+    const activeAdapter = flags.adapter ?? result.adapter;
+    models.execution = activeAdapter === "claude-code-cli" ? "claude-haiku-4-5-20251001" : "autopilot-execute";
+  }
+  if (flags.parallel !== void 0) {
+    result.execution_order = "parallel";
+    result.parallel_lanes = flags.parallel;
+  }
+  if (flags.ship) {
+    result.auto_ship = true;
+  }
+  if (flags.resume) {
+    result.checkpoint = true;
+  }
+  if (flags.maxIterationsPerPhase !== void 0) {
+    result.max_iterations_per_phase = flags.maxIterationsPerPhase;
+  }
+  if (flags.stallTimeout !== void 0) {
+    result.stall_timeout = flags.stallTimeout;
+  }
+  if (flags.notify !== void 0) {
+    result.notify_url = flags.notify;
+  }
+  return result;
+}
+
+// src/session-state.ts
+function deriveId(planPath, startedAt) {
+  const raw = `${planPath}|${startedAt}`;
+  return Buffer.from(raw).toString("base64url").slice(0, 24);
+}
+function deriveState(events) {
+  const startEvent = events.find((e) => e.type === "session:start");
+  if (!startEvent || startEvent.type !== "session:start") {
+    return null;
+  }
+  const id = deriveId(startEvent.planPath, startEvent.timestamp);
+  let status = "running";
+  let currentPhase = void 0;
+  let currentIteration = void 0;
+  let totalIterations = 0;
+  let cost = 0;
+  let lastEventAt = startEvent.timestamp;
+  let error = void 0;
+  let exitReason = void 0;
+  let enrichProgress = void 0;
+  let verifyProgress = void 0;
+  for (const event of events) {
+    lastEventAt = event.timestamp;
+    switch (event.type) {
+      case "session:start":
+        status = "running";
+        break;
+      case "session:done":
+        status = "complete";
+        exitReason = event.exitReason;
+        totalIterations = event.iterations;
+        if (event.cumulativeCostUsd !== void 0) {
+          cost = event.cumulativeCostUsd;
+        }
+        break;
+      case "enrich:start":
+        status = "enriching";
+        enrichProgress = { done: 0, total: event.fileCount };
+        break;
+      case "enrich:file:done":
+      case "enrich:file:skip":
+      case "enrich:file:error":
+        if (enrichProgress) {
+          enrichProgress = { done: enrichProgress.done + 1, total: enrichProgress.total };
+        }
+        break;
+      case "enrich:file:start":
+        break;
+      case "enrich:done":
+        status = "running";
+        enrichProgress = enrichProgress ? { done: enrichProgress.total, total: enrichProgress.total } : void 0;
+        break;
+      case "phase:start":
+        status = "running";
+        currentPhase = {
+          phase: event.phase,
+          current: event.current,
+          total: event.total
+        };
+        break;
+      case "phase:done":
+        currentPhase = void 0;
+        currentIteration = void 0;
+        break;
+      case "iteration:start":
+        status = "running";
+        currentIteration = {
+          iteration: event.iteration,
+          max: event.maxIterations
+        };
+        break;
+      case "iteration:done":
+        totalIterations = event.iteration;
+        currentIteration = void 0;
+        if (event.costUsd !== void 0) {
+          cost = event.costUsd;
+        }
+        break;
+      case "cost:update":
+        cost = event.cumulativeCostUsd;
+        break;
+      case "error":
+        status = "error";
+        error = event.message;
+        break;
+      case "credential:expired":
+        status = "error";
+        error = `Credential expired: ${event.provider} \u2014 ${event.message}`;
+        break;
+      case "verify:start":
+        status = "verifying";
+        verifyProgress = { passed: 0, total: event.itemCount };
+        break;
+      case "verify:result":
+        if (verifyProgress) {
+          verifyProgress = {
+            passed: verifyProgress.passed + (event.passed ? 1 : 0),
+            total: verifyProgress.total
+          };
+        }
+        break;
+      case "verify:done":
+        status = "running";
+        verifyProgress = verifyProgress ? { passed: verifyProgress.passed, total: event.passed + event.failed } : void 0;
+        break;
+      case "tool:call":
+      case "thinking":
+        break;
+    }
+  }
+  return {
+    id,
+    planPath: startEvent.planPath,
+    cwd: startEvent.cwd,
+    fast: startEvent.fast,
+    resume: startEvent.resume,
+    status,
+    currentPhase,
+    currentIteration,
+    totalIterations,
+    cost,
+    startedAt: startEvent.timestamp,
+    lastEventAt,
+    error,
+    exitReason,
+    enrichProgress,
+    verifyProgress
+  };
+}
+
+// src/plan-session.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var DEFAULT_PLAN_TIMEOUT_MS = 10 * 60 * 1e3;
+async function runPlanSession(opts) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_PLAN_TIMEOUT_MS;
+  const adapter = opts.adapter;
+  const _existsSync = opts._deps?.existsSync ?? fs3.existsSync;
+  const handle = await adapter.start({ cwd: opts.planDir });
+  try {
+    const sessionId = await adapter.createSession(handle, {
+      agentName: "plan"
+    });
+    const multiFileDir = path3.join(opts.planDir, opts.slug);
+    const multiFileMain = path3.join(multiFileDir, "main.md");
+    const singleFilePlan = path3.join(opts.planDir, `${opts.slug}.md`);
+    const prompt = `Read the scope at ${opts.scopePath} and produce a plan. Use slug ${opts.slug} for the plan file(s). If the scope warrants multiple phases, produce a multi-file plan at ${multiFileDir}/main.md + phase_N.md files. Otherwise produce a single-file plan at ${singleFilePlan}.`;
+    const result = await adapter.sendAndWait(handle, {
+      sessionId,
+      message: prompt,
+      stallMs: timeoutMs
+    });
+    if (result.kind === "abort") {
+      throw new Error(
+        `Plan session aborted (timeout after ${timeoutMs}ms).`
+      );
+    }
+    if (result.kind === "stall") {
+      throw new Error(
+        `Plan session stalled for ${result.stallMs}ms with no idle signal.`
+      );
+    }
+    if (result.kind === "error") {
+      throw new Error(`Plan session error: ${result.message}`);
+    }
+    if (result.kind === "question_rejected") {
+    }
+    if (_existsSync(multiFileMain)) {
+      return { planPath: multiFileDir };
+    }
+    if (_existsSync(singleFilePlan)) {
+      return { planPath: singleFilePlan };
+    }
+    const retryPrompt = `You did not write a plan file. Write the plan NOW. Read the scope at ${opts.scopePath}. Write the plan to ${singleFilePlan} (single-file) or ${multiFileDir}/main.md (multi-file). Do NOT ask questions. Just write the plan.`;
+    const retryResult = await adapter.sendAndWait(handle, {
+      sessionId,
+      message: retryPrompt,
+      stallMs: timeoutMs
+    });
+    if (retryResult.kind !== "idle" && retryResult.kind !== "question_rejected") {
+      throw new Error(`@plan retry failed: ${retryResult.kind}`);
+    }
+    if (_existsSync(multiFileMain)) {
+      return { planPath: multiFileDir };
+    }
+    if (_existsSync(singleFilePlan)) {
+      return { planPath: singleFilePlan };
+    }
+    const scopeContent = fs3.existsSync(opts.scopePath) ? fs3.readFileSync(opts.scopePath, "utf-8") : `# Plan
+
+Scope file not found at ${opts.scopePath}.`;
+    const minimalPlan = [
+      `# Plan (auto-generated from scope)`,
+      "",
+      "This plan was auto-generated because @plan did not produce a plan file.",
+      "Review and refine before executing.",
+      "",
+      scopeContent,
+      "",
+      "## Acceptance criteria",
+      "",
+      "- [ ] Review and refine this auto-generated plan",
+      "",
+      "## File-level changes",
+      "",
+      "- To be determined after plan review."
+    ].join("\n");
+    fs3.mkdirSync(path3.dirname(singleFilePlan), { recursive: true });
+    fs3.writeFileSync(singleFilePlan, minimalPlan);
+    return { planPath: singleFilePlan };
+  } finally {
+    await adapter.shutdown(handle);
+  }
+}
+export {
+  EventStreamReader,
+  EventStreamWriter,
+  MAX_ITERATIONS,
+  MAX_ITERATIONS_PER_PHASE_BY_TIER,
+  STALL_MS,
+  STALL_MS_BY_TIER,
+  STATUS_INTERVAL_MS,
+  STRUGGLE_THRESHOLD,
+  SessionEventEmitter,
+  SessionRunner,
+  StruggleDetector,
+  TIMEOUT_MS,
+  applyCLIOverrides,
+  autoShip,
+  buildConflictGraph,
+  checkKillSwitch,
+  childLogger,
+  createAutopilotLogger,
+  createStatusHeartbeat,
+  createWorktree,
+  deleteCheckpoint,
+  deriveState,
+  detectSentinel,
+  detectSpecPhases,
+  enrichPlanForFastModel,
+  filterUncheckedSpecPhases,
+  formatCost,
+  formatElapsed,
+  generateChangeset,
+  getChangedFiles,
+  hasParallelism,
+  hasSpec,
+  isFreeformFile,
+  markPhaseCompleted,
+  mergeWorktree,
+  parseItems,
+  parsePlanState,
+  parseSpecItems,
+  readCheckpoint,
+  readSpecConstraints,
+  readSpecGoal,
+  recordHead,
+  resetSoft,
+  resolveModel,
+  runLanes,
+  runLoopSession,
+  runPlanSession,
+  runRalphLoop,
+  runVerifyCommands,
+  validateMainSpec,
+  validatePhaseSpec,
+  validatePlan,
+  validateScope,
+  writeCheckpoint
+};